1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % CCC U U TTTTT %
6 % C U U T %
7 % C U U T %
8 % C U U T %
9 % CCC UUU T %
10 % %
11 % %
12 % Read DR Halo Image Format %
13 % %
14 % Software Design %
15 % Jaroslav Fojtik %
16 % June 2000 %
17 % %
18 % %
19 % Permission is hereby granted, free of charge, to any person obtaining a %
20 % copy of this software and associated documentation files ("ImageMagick"), %
21 % to deal in ImageMagick without restriction, including without limitation %
22 % the rights to use, copy, modify, merge, publish, distribute, sublicense, %
23 % and/or sell copies of ImageMagick, and to permit persons to whom the %
24 % ImageMagick is furnished to do so, subject to the following conditions: %
25 % %
26 % The above copyright notice and this permission notice shall be included in %
27 % all copies or substantial portions of ImageMagick. %
28 % %
29 % The software is provided "as is", without warranty of any kind, express or %
30 % implied, including but not limited to the warranties of merchantability, %
31 % fitness for a particular purpose and noninfringement. In no event shall %
32 % ImageMagick Studio be liable for any claim, damages or other liability, %
33 % whether in an action of contract, tort or otherwise, arising from, out of %
34 % or in connection with ImageMagick or the use or other dealings in %
35 % ImageMagick. %
36 % %
37 % Except as contained in this notice, the name of the ImageMagick Studio %
38 % shall not be used in advertising or otherwise to promote the sale, use or %
39 % other dealings in ImageMagick without prior written authorization from the %
40 % ImageMagick Studio. %
41 % %
42 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
43 %
44 %
45 */
46
47 /*
48 Include declarations.
49 */
50 #include "MagickCore/studio.h"
51 #include "MagickCore/attribute.h"
52 #include "MagickCore/blob.h"
53 #include "MagickCore/blob-private.h"
54 #include "MagickCore/cache.h"
55 #include "MagickCore/color.h"
56 #include "MagickCore/color-private.h"
57 #include "MagickCore/colormap.h"
58 #include "MagickCore/colormap-private.h"
59 #include "MagickCore/exception.h"
60 #include "MagickCore/exception-private.h"
61 #include "MagickCore/image.h"
62 #include "MagickCore/image-private.h"
63 #include "MagickCore/list.h"
64 #include "MagickCore/magick.h"
65 #include "MagickCore/memory_.h"
66 #include "MagickCore/pixel-accessor.h"
67 #include "MagickCore/quantum-private.h"
68 #include "MagickCore/static.h"
69 #include "MagickCore/string_.h"
70 #include "MagickCore/module.h"
71 #include "MagickCore/utility.h"
72 #include "MagickCore/utility-private.h"
73
74 typedef struct
75 {
76 unsigned Width;
77 unsigned Height;
78 unsigned Reserved;
79 } CUTHeader;
80
81 typedef struct
82 {
83 char FileId[2];
84 unsigned Version;
85 unsigned Size;
86 char FileType;
87 char SubType;
88 unsigned BoardID;
89 unsigned GraphicsMode;
90 unsigned MaxIndex;
91 unsigned MaxRed;
92 unsigned MaxGreen;
93 unsigned MaxBlue;
94 char PaletteId[20];
95 } CUTPalHeader;
96
97
InsertRow(Image * image,ssize_t depth,unsigned char * p,ssize_t y,ExceptionInfo * exception)98 static void InsertRow(Image *image,ssize_t depth,unsigned char *p,ssize_t y,
99 ExceptionInfo *exception)
100 {
101 size_t bit; ssize_t x;
102 register Quantum *q;
103 Quantum index;
104
105 index=0;
106 switch (depth)
107 {
108 case 1: /* Convert bitmap scanline. */
109 {
110 q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
111 if (q == (Quantum *) NULL)
112 break;
113 for (x=0; x < ((ssize_t) image->columns-7); x+=8)
114 {
115 for (bit=0; bit < 8; bit++)
116 {
117 index=(Quantum) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
118 SetPixelIndex(image,index,q);
119 q+=GetPixelChannels(image);
120 }
121 p++;
122 }
123 if ((image->columns % 8) != 0)
124 {
125 for (bit=0; bit < (image->columns % 8); bit++)
126 {
127 index=(Quantum) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
128 SetPixelIndex(image,index,q);
129 q+=GetPixelChannels(image);
130 }
131 p++;
132 }
133 (void) SyncAuthenticPixels(image,exception);
134 break;
135 }
136 case 2: /* Convert PseudoColor scanline. */
137 {
138 q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
139 if (q == (Quantum *) NULL)
140 break;
141 for (x=0; x < ((ssize_t) image->columns-1); x+=2)
142 {
143 index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
144 SetPixelIndex(image,index,q);
145 q+=GetPixelChannels(image);
146 index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
147 SetPixelIndex(image,index,q);
148 q+=GetPixelChannels(image);
149 index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,exception);
150 SetPixelIndex(image,index,q);
151 q+=GetPixelChannels(image);
152 index=ConstrainColormapIndex(image,(*p) & 0x3,exception);
153 SetPixelIndex(image,index,q);
154 q+=GetPixelChannels(image);
155 p++;
156 }
157 if ((image->columns % 4) != 0)
158 {
159 index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
160 SetPixelIndex(image,index,q);
161 q+=GetPixelChannels(image);
162 if ((image->columns % 4) >= 1)
163
164 {
165 index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
166 SetPixelIndex(image,index,q);
167 q+=GetPixelChannels(image);
168 if ((image->columns % 4) >= 2)
169
170 {
171 index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,
172 exception);
173 SetPixelIndex(image,index,q);
174 q+=GetPixelChannels(image);
175 }
176 }
177 p++;
178 }
179 (void) SyncAuthenticPixels(image,exception);
180 break;
181 }
182
183 case 4: /* Convert PseudoColor scanline. */
184 {
185 q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
186 if (q == (Quantum *) NULL)
187 break;
188 for (x=0; x < ((ssize_t) image->columns-1); x+=2)
189 {
190 index=ConstrainColormapIndex(image,(*p >> 4) & 0xf,exception);
191 SetPixelIndex(image,index,q);
192 q+=GetPixelChannels(image);
193 index=ConstrainColormapIndex(image,(*p) & 0xf,exception);
194 SetPixelIndex(image,index,q);
195 q+=GetPixelChannels(image);
196 p++;
197 }
198 if ((image->columns % 2) != 0)
199 {
200 index=ConstrainColormapIndex(image,(*p >> 4) & 0xf,exception);
201 SetPixelIndex(image,index,q);
202 q+=GetPixelChannels(image);
203 p++;
204 }
205 (void) SyncAuthenticPixels(image,exception);
206 break;
207 }
208 case 8: /* Convert PseudoColor scanline. */
209 {
210 q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
211 if (q == (Quantum *) NULL) break;
212 for (x=0; x < (ssize_t) image->columns; x++)
213 {
214 index=ConstrainColormapIndex(image,*p,exception);
215 SetPixelIndex(image,index,q);
216 p++;
217 q+=GetPixelChannels(image);
218 }
219 (void) SyncAuthenticPixels(image,exception);
220 break;
221 }
222 }
223 }
224
225 /*
226 Compute the number of colors in Grayed R[i]=G[i]=B[i] image
227 */
GetCutColors(Image * image,ExceptionInfo * exception)228 static int GetCutColors(Image *image,ExceptionInfo *exception)
229 {
230 Quantum
231 intensity,
232 scale_intensity;
233
234 register Quantum
235 *q;
236
237 ssize_t
238 x,
239 y;
240
241 intensity=0;
242 scale_intensity=ScaleCharToQuantum(16);
243 for (y=0; y < (ssize_t) image->rows; y++)
244 {
245 q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
246 if (q == (Quantum *) NULL)
247 break;
248 for (x=0; x < (ssize_t) image->columns; x++)
249 {
250 if (intensity < GetPixelRed(image,q))
251 intensity=GetPixelRed(image,q);
252 if (intensity >= scale_intensity)
253 return(255);
254 q+=GetPixelChannels(image);
255 }
256 }
257 if (intensity < ScaleCharToQuantum(2))
258 return(2);
259 if (intensity < ScaleCharToQuantum(16))
260 return(16);
261 return((int) intensity);
262 }
263
264 /*
265 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
266 % %
267 % %
268 % %
269 % R e a d C U T I m a g e %
270 % %
271 % %
272 % %
273 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
274 %
275 % ReadCUTImage() reads an CUT X image file and returns it. It
276 % allocates the memory necessary for the new Image structure and returns a
277 % pointer to the new image.
278 %
279 % The format of the ReadCUTImage method is:
280 %
281 % Image *ReadCUTImage(const ImageInfo *image_info,ExceptionInfo *exception)
282 %
283 % A description of each parameter follows:
284 %
285 % o image_info: the image info.
286 %
287 % o exception: return any errors or warnings in this structure.
288 %
289 */
ReadCUTImage(const ImageInfo * image_info,ExceptionInfo * exception)290 static Image *ReadCUTImage(const ImageInfo *image_info,ExceptionInfo *exception)
291 {
292 Image *image,*palette;
293 ImageInfo *clone_info;
294 MagickBooleanType status;
295
296 MagickOffsetType
297 offset;
298
299 size_t EncodedByte;
300 unsigned char RunCount,RunValue,RunCountMasked;
301 CUTHeader Header;
302 CUTPalHeader PalHeader;
303 ssize_t depth;
304 ssize_t i,j;
305 ssize_t ldblk;
306 unsigned char *BImgBuff=NULL,*ptrB;
307 register Quantum *q;
308
309 /*
310 Open image file.
311 */
312 assert(image_info != (const ImageInfo *) NULL);
313 assert(image_info->signature == MagickCoreSignature);
314 if (image_info->debug != MagickFalse)
315 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
316 image_info->filename);
317 assert(exception != (ExceptionInfo *) NULL);
318 assert(exception->signature == MagickCoreSignature);
319 image=AcquireImage(image_info,exception);
320 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
321 if (status == MagickFalse)
322 {
323 image=DestroyImageList(image);
324 return((Image *) NULL);
325 }
326 /*
327 Read CUT image.
328 */
329 palette=NULL;
330 clone_info=NULL;
331 Header.Width=ReadBlobLSBShort(image);
332 Header.Height=ReadBlobLSBShort(image);
333 Header.Reserved=ReadBlobLSBShort(image);
334
335 if (Header.Width==0 || Header.Height==0 || Header.Reserved!=0)
336 CUT_KO: ThrowReaderException(CorruptImageError,"ImproperImageHeader");
337
338 /*---This code checks first line of image---*/
339 EncodedByte=ReadBlobLSBShort(image);
340 RunCount=(unsigned char) ReadBlobByte(image);
341 RunCountMasked=RunCount & 0x7F;
342 ldblk=0;
343 while((int) RunCountMasked!=0) /*end of line?*/
344 {
345 i=1;
346 if((int) RunCount<0x80) i=(ssize_t) RunCountMasked;
347 offset=SeekBlob(image,TellBlob(image)+i,SEEK_SET);
348 if (offset < 0)
349 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
350 if(EOFBlob(image) != MagickFalse) goto CUT_KO; /*wrong data*/
351 EncodedByte-=i+1;
352 ldblk+=(ssize_t) RunCountMasked;
353
354 RunCount=(unsigned char) ReadBlobByte(image);
355 if(EOFBlob(image) != MagickFalse) goto CUT_KO; /*wrong data: unexpected eof in line*/
356 RunCountMasked=RunCount & 0x7F;
357 }
358 if(EncodedByte!=1) goto CUT_KO; /*wrong data: size incorrect*/
359 i=0; /*guess a number of bit planes*/
360 if(ldblk==(int) Header.Width) i=8;
361 if(2*ldblk==(int) Header.Width) i=4;
362 if(8*ldblk==(int) Header.Width) i=1;
363 if(i==0) goto CUT_KO; /*wrong data: incorrect bit planes*/
364 depth=i;
365
366 image->columns=Header.Width;
367 image->rows=Header.Height;
368 image->depth=8;
369 image->colors=(size_t) (GetQuantumRange(1UL*i)+1);
370
371 if (image_info->ping != MagickFalse) goto Finish;
372 status=SetImageExtent(image,image->columns,image->rows,exception);
373 if (status == MagickFalse)
374 return(DestroyImageList(image));
375
376 /* ----- Do something with palette ----- */
377 if ((clone_info=CloneImageInfo(image_info)) == NULL) goto NoPalette;
378
379
380 i=(ssize_t) strlen(clone_info->filename);
381 j=i;
382 while(--i>0)
383 {
384 if(clone_info->filename[i]=='.')
385 {
386 break;
387 }
388 if(clone_info->filename[i]=='/' || clone_info->filename[i]=='\\' ||
389 clone_info->filename[i]==':' )
390 {
391 i=j;
392 break;
393 }
394 }
395
396 (void) CopyMagickString(clone_info->filename+i,".PAL",(size_t)
397 (MagickPathExtent-i));
398 if((clone_info->file=fopen_utf8(clone_info->filename,"rb"))==NULL)
399 {
400 (void) CopyMagickString(clone_info->filename+i,".pal",(size_t)
401 (MagickPathExtent-i));
402 if((clone_info->file=fopen_utf8(clone_info->filename,"rb"))==NULL)
403 {
404 clone_info->filename[i]='\0';
405 if((clone_info->file=fopen_utf8(clone_info->filename,"rb"))==NULL)
406 {
407 clone_info=DestroyImageInfo(clone_info);
408 clone_info=NULL;
409 goto NoPalette;
410 }
411 }
412 }
413
414 if( (palette=AcquireImage(clone_info,exception))==NULL ) goto NoPalette;
415 status=OpenBlob(clone_info,palette,ReadBinaryBlobMode,exception);
416 if (status == MagickFalse)
417 {
418 ErasePalette:
419 palette=DestroyImage(palette);
420 palette=NULL;
421 goto NoPalette;
422 }
423
424
425 if(palette!=NULL)
426 {
427 (void) ReadBlob(palette,2,(unsigned char *) PalHeader.FileId);
428 if(strncmp(PalHeader.FileId,"AH",2) != 0) goto ErasePalette;
429 PalHeader.Version=ReadBlobLSBShort(palette);
430 PalHeader.Size=ReadBlobLSBShort(palette);
431 PalHeader.FileType=(char) ReadBlobByte(palette);
432 PalHeader.SubType=(char) ReadBlobByte(palette);
433 PalHeader.BoardID=ReadBlobLSBShort(palette);
434 PalHeader.GraphicsMode=ReadBlobLSBShort(palette);
435 PalHeader.MaxIndex=ReadBlobLSBShort(palette);
436 PalHeader.MaxRed=ReadBlobLSBShort(palette);
437 PalHeader.MaxGreen=ReadBlobLSBShort(palette);
438 PalHeader.MaxBlue=ReadBlobLSBShort(palette);
439 (void) ReadBlob(palette,20,(unsigned char *) PalHeader.PaletteId);
440
441 if(PalHeader.MaxIndex<1) goto ErasePalette;
442 image->colors=PalHeader.MaxIndex+1;
443 if (AcquireImageColormap(image,image->colors,exception) == MagickFalse) goto NoMemory;
444
445 if(PalHeader.MaxRed==0) PalHeader.MaxRed=(unsigned int) QuantumRange; /*avoid division by 0*/
446 if(PalHeader.MaxGreen==0) PalHeader.MaxGreen=(unsigned int) QuantumRange;
447 if(PalHeader.MaxBlue==0) PalHeader.MaxBlue=(unsigned int) QuantumRange;
448
449 for(i=0;i<=(int) PalHeader.MaxIndex;i++)
450 { /*this may be wrong- I don't know why is palette such strange*/
451 j=(ssize_t) TellBlob(palette);
452 if((j % 512)>512-6)
453 {
454 j=((j / 512)+1)*512;
455 offset=SeekBlob(palette,j,SEEK_SET);
456 if (offset < 0)
457 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
458 }
459 image->colormap[i].red=(Quantum) ReadBlobLSBShort(palette);
460 if (QuantumRange != (Quantum) PalHeader.MaxRed)
461 {
462 image->colormap[i].red=ClampToQuantum(((double)
463 image->colormap[i].red*QuantumRange+(PalHeader.MaxRed>>1))/
464 PalHeader.MaxRed);
465 }
466 image->colormap[i].green=(Quantum) ReadBlobLSBShort(palette);
467 if (QuantumRange != (Quantum) PalHeader.MaxGreen)
468 {
469 image->colormap[i].green=ClampToQuantum
470 (((double) image->colormap[i].green*QuantumRange+(PalHeader.MaxGreen>>1))/PalHeader.MaxGreen);
471 }
472 image->colormap[i].blue=(Quantum) ReadBlobLSBShort(palette);
473 if (QuantumRange != (Quantum) PalHeader.MaxBlue)
474 {
475 image->colormap[i].blue=ClampToQuantum
476 (((double)image->colormap[i].blue*QuantumRange+(PalHeader.MaxBlue>>1))/PalHeader.MaxBlue);
477 }
478
479 }
480 }
481
482
483
484 NoPalette:
485 if(palette==NULL)
486 {
487
488 image->colors=256;
489 if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
490 {
491 NoMemory:
492 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
493 }
494
495 for (i=0; i < (ssize_t)image->colors; i++)
496 {
497 image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
498 image->colormap[i].green=ScaleCharToQuantum((unsigned char) i);
499 image->colormap[i].blue=ScaleCharToQuantum((unsigned char) i);
500 }
501 }
502
503
504 /* ----- Load RLE compressed raster ----- */
505 BImgBuff=(unsigned char *) AcquireQuantumMemory((size_t) ldblk,
506 sizeof(*BImgBuff)); /*Ldblk was set in the check phase*/
507 if(BImgBuff==NULL) goto NoMemory;
508
509 offset=SeekBlob(image,6 /*sizeof(Header)*/,SEEK_SET);
510 if (offset < 0)
511 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
512 for (i=0; i < (int) Header.Height; i++)
513 {
514 EncodedByte=ReadBlobLSBShort(image);
515
516 ptrB=BImgBuff;
517 j=ldblk;
518
519 RunCount=(unsigned char) ReadBlobByte(image);
520 RunCountMasked=RunCount & 0x7F;
521
522 while ((int) RunCountMasked != 0)
523 {
524 if((ssize_t) RunCountMasked>j)
525 { /*Wrong Data*/
526 RunCountMasked=(unsigned char) j;
527 if(j==0)
528 {
529 break;
530 }
531 }
532
533 if((int) RunCount>0x80)
534 {
535 RunValue=(unsigned char) ReadBlobByte(image);
536 (void) ResetMagickMemory(ptrB,(int) RunValue,(size_t) RunCountMasked);
537 }
538 else {
539 (void) ReadBlob(image,(size_t) RunCountMasked,ptrB);
540 }
541
542 ptrB+=(int) RunCountMasked;
543 j-=(int) RunCountMasked;
544
545 if (EOFBlob(image) != MagickFalse) goto Finish; /* wrong data: unexpected eof in line */
546 RunCount=(unsigned char) ReadBlobByte(image);
547 RunCountMasked=RunCount & 0x7F;
548 }
549
550 InsertRow(image,depth,BImgBuff,i,exception);
551 }
552 (void) SyncImage(image,exception);
553
554
555 /*detect monochrome image*/
556
557 if(palette==NULL)
558 { /*attempt to detect binary (black&white) images*/
559 if ((image->storage_class == PseudoClass) &&
560 (SetImageGray(image,exception) != MagickFalse))
561 {
562 if(GetCutColors(image,exception)==2)
563 {
564 for (i=0; i < (ssize_t)image->colors; i++)
565 {
566 register Quantum
567 sample;
568 sample=ScaleCharToQuantum((unsigned char) i);
569 if(image->colormap[i].red!=sample) goto Finish;
570 if(image->colormap[i].green!=sample) goto Finish;
571 if(image->colormap[i].blue!=sample) goto Finish;
572 }
573
574 image->colormap[1].red=image->colormap[1].green=
575 image->colormap[1].blue=QuantumRange;
576 for (i=0; i < (ssize_t)image->rows; i++)
577 {
578 q=QueueAuthenticPixels(image,0,i,image->columns,1,exception);
579 for (j=0; j < (ssize_t)image->columns; j++)
580 {
581 if (GetPixelRed(image,q) == ScaleCharToQuantum(1))
582 {
583 SetPixelRed(image,QuantumRange,q);
584 SetPixelGreen(image,QuantumRange,q);
585 SetPixelBlue(image,QuantumRange,q);
586 }
587 q+=GetPixelChannels(image);
588 }
589 if (SyncAuthenticPixels(image,exception) == MagickFalse) goto Finish;
590 }
591 }
592 }
593 }
594
595 Finish:
596 if (BImgBuff != NULL)
597 BImgBuff=(unsigned char *) RelinquishMagickMemory(BImgBuff);
598 if (palette != NULL)
599 palette=DestroyImage(palette);
600 if (clone_info != NULL)
601 clone_info=DestroyImageInfo(clone_info);
602 if (EOFBlob(image) != MagickFalse)
603 ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
604 image->filename);
605 (void) CloseBlob(image);
606 return(GetFirstImageInList(image));
607 }
608
609 /*
610 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
611 % %
612 % %
613 % %
614 % R e g i s t e r C U T I m a g e %
615 % %
616 % %
617 % %
618 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
619 %
620 % RegisterCUTImage() adds attributes for the CUT image format to
621 % the list of supported formats. The attributes include the image format
622 % tag, a method to read and/or write the format, whether the format
623 % supports the saving of more than one frame to the same file or blob,
624 % whether the format supports native in-memory I/O, and a brief
625 % description of the format.
626 %
627 % The format of the RegisterCUTImage method is:
628 %
629 % size_t RegisterCUTImage(void)
630 %
631 */
RegisterCUTImage(void)632 ModuleExport size_t RegisterCUTImage(void)
633 {
634 MagickInfo
635 *entry;
636
637 entry=AcquireMagickInfo("CUT","CUT","DR Halo");
638 entry->decoder=(DecodeImageHandler *) ReadCUTImage;
639 entry->flags|=CoderSeekableStreamFlag;
640 (void) RegisterMagickInfo(entry);
641 return(MagickImageCoderSignature);
642 }
643
644 /*
645 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
646 % %
647 % %
648 % %
649 % U n r e g i s t e r C U T I m a g e %
650 % %
651 % %
652 % %
653 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
654 %
655 % UnregisterCUTImage() removes format registrations made by the
656 % CUT module from the list of supported formats.
657 %
658 % The format of the UnregisterCUTImage method is:
659 %
660 % UnregisterCUTImage(void)
661 %
662 */
UnregisterCUTImage(void)663 ModuleExport void UnregisterCUTImage(void)
664 {
665 (void) UnregisterMagickInfo("CUT");
666 }
667