1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % CCCC OOO M M PPPP RRRR EEEEE SSSSS SSSSS %
7 % C O O MM MM P P R R E SS SS %
8 % C O O M M M PPPP RRRR EEE SSS SSS %
9 % C O O M M P R R E SS SS %
10 % CCCC OOO M M P R R EEEEE SSSSS SSSSS %
11 % %
12 % %
13 % MagickCore Image Compression/Decompression Methods %
14 % %
15 % Software Design %
16 % Cristy %
17 % May 1993 %
18 % %
19 % %
20 % Copyright 1999-2016 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
22 % %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
25 % %
26 % http://www.imagemagick.org/script/license.php %
27 % %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
33 % %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 %
38 */
39
40 /*
41 Include declarations.
42 */
43 #include "MagickCore/studio.h"
44 #include "MagickCore/attribute.h"
45 #include "MagickCore/blob.h"
46 #include "MagickCore/blob-private.h"
47 #include "MagickCore/color-private.h"
48 #include "MagickCore/cache.h"
49 #include "MagickCore/compress.h"
50 #include "MagickCore/constitute.h"
51 #include "MagickCore/exception.h"
52 #include "MagickCore/exception-private.h"
53 #include "MagickCore/image-private.h"
54 #include "MagickCore/list.h"
55 #include "MagickCore/memory_.h"
56 #include "MagickCore/monitor.h"
57 #include "MagickCore/monitor-private.h"
58 #include "MagickCore/option.h"
59 #include "MagickCore/pixel-accessor.h"
60 #include "MagickCore/resource_.h"
61 #include "MagickCore/string_.h"
62 #if defined(MAGICKCORE_ZLIB_DELEGATE)
63 #include "zlib.h"
64 #endif
65
66 /*
67 Typedef declarations.
68 */
69 struct _Ascii85Info
70 {
71 ssize_t
72 offset,
73 line_break;
74
75 unsigned char
76 buffer[10];
77 };
78
79 typedef struct HuffmanTable
80 {
81 size_t
82 id,
83 code,
84 length,
85 count;
86 } HuffmanTable;
87
88 /*
89 Huffman coding declarations.
90 */
91 #define TWId 23
92 #define MWId 24
93 #define TBId 25
94 #define MBId 26
95 #define EXId 27
96
97 static const HuffmanTable
98 MBTable[]=
99 {
100 { MBId, 0x0f, 10, 64 }, { MBId, 0xc8, 12, 128 },
101 { MBId, 0xc9, 12, 192 }, { MBId, 0x5b, 12, 256 },
102 { MBId, 0x33, 12, 320 }, { MBId, 0x34, 12, 384 },
103 { MBId, 0x35, 12, 448 }, { MBId, 0x6c, 13, 512 },
104 { MBId, 0x6d, 13, 576 }, { MBId, 0x4a, 13, 640 },
105 { MBId, 0x4b, 13, 704 }, { MBId, 0x4c, 13, 768 },
106 { MBId, 0x4d, 13, 832 }, { MBId, 0x72, 13, 896 },
107 { MBId, 0x73, 13, 960 }, { MBId, 0x74, 13, 1024 },
108 { MBId, 0x75, 13, 1088 }, { MBId, 0x76, 13, 1152 },
109 { MBId, 0x77, 13, 1216 }, { MBId, 0x52, 13, 1280 },
110 { MBId, 0x53, 13, 1344 }, { MBId, 0x54, 13, 1408 },
111 { MBId, 0x55, 13, 1472 }, { MBId, 0x5a, 13, 1536 },
112 { MBId, 0x5b, 13, 1600 }, { MBId, 0x64, 13, 1664 },
113 { MBId, 0x65, 13, 1728 }, { MBId, 0x00, 0, 0 }
114 };
115
116 static const HuffmanTable
117 EXTable[]=
118 {
119 { EXId, 0x08, 11, 1792 }, { EXId, 0x0c, 11, 1856 },
120 { EXId, 0x0d, 11, 1920 }, { EXId, 0x12, 12, 1984 },
121 { EXId, 0x13, 12, 2048 }, { EXId, 0x14, 12, 2112 },
122 { EXId, 0x15, 12, 2176 }, { EXId, 0x16, 12, 2240 },
123 { EXId, 0x17, 12, 2304 }, { EXId, 0x1c, 12, 2368 },
124 { EXId, 0x1d, 12, 2432 }, { EXId, 0x1e, 12, 2496 },
125 { EXId, 0x1f, 12, 2560 }, { EXId, 0x00, 0, 0 }
126 };
127
128 static const HuffmanTable
129 MWTable[]=
130 {
131 { MWId, 0x1b, 5, 64 }, { MWId, 0x12, 5, 128 },
132 { MWId, 0x17, 6, 192 }, { MWId, 0x37, 7, 256 },
133 { MWId, 0x36, 8, 320 }, { MWId, 0x37, 8, 384 },
134 { MWId, 0x64, 8, 448 }, { MWId, 0x65, 8, 512 },
135 { MWId, 0x68, 8, 576 }, { MWId, 0x67, 8, 640 },
136 { MWId, 0xcc, 9, 704 }, { MWId, 0xcd, 9, 768 },
137 { MWId, 0xd2, 9, 832 }, { MWId, 0xd3, 9, 896 },
138 { MWId, 0xd4, 9, 960 }, { MWId, 0xd5, 9, 1024 },
139 { MWId, 0xd6, 9, 1088 }, { MWId, 0xd7, 9, 1152 },
140 { MWId, 0xd8, 9, 1216 }, { MWId, 0xd9, 9, 1280 },
141 { MWId, 0xda, 9, 1344 }, { MWId, 0xdb, 9, 1408 },
142 { MWId, 0x98, 9, 1472 }, { MWId, 0x99, 9, 1536 },
143 { MWId, 0x9a, 9, 1600 }, { MWId, 0x18, 6, 1664 },
144 { MWId, 0x9b, 9, 1728 }, { MWId, 0x00, 0, 0 }
145 };
146
147 static const HuffmanTable
148 TBTable[]=
149 {
150 { TBId, 0x37, 10, 0 }, { TBId, 0x02, 3, 1 }, { TBId, 0x03, 2, 2 },
151 { TBId, 0x02, 2, 3 }, { TBId, 0x03, 3, 4 }, { TBId, 0x03, 4, 5 },
152 { TBId, 0x02, 4, 6 }, { TBId, 0x03, 5, 7 }, { TBId, 0x05, 6, 8 },
153 { TBId, 0x04, 6, 9 }, { TBId, 0x04, 7, 10 }, { TBId, 0x05, 7, 11 },
154 { TBId, 0x07, 7, 12 }, { TBId, 0x04, 8, 13 }, { TBId, 0x07, 8, 14 },
155 { TBId, 0x18, 9, 15 }, { TBId, 0x17, 10, 16 }, { TBId, 0x18, 10, 17 },
156 { TBId, 0x08, 10, 18 }, { TBId, 0x67, 11, 19 }, { TBId, 0x68, 11, 20 },
157 { TBId, 0x6c, 11, 21 }, { TBId, 0x37, 11, 22 }, { TBId, 0x28, 11, 23 },
158 { TBId, 0x17, 11, 24 }, { TBId, 0x18, 11, 25 }, { TBId, 0xca, 12, 26 },
159 { TBId, 0xcb, 12, 27 }, { TBId, 0xcc, 12, 28 }, { TBId, 0xcd, 12, 29 },
160 { TBId, 0x68, 12, 30 }, { TBId, 0x69, 12, 31 }, { TBId, 0x6a, 12, 32 },
161 { TBId, 0x6b, 12, 33 }, { TBId, 0xd2, 12, 34 }, { TBId, 0xd3, 12, 35 },
162 { TBId, 0xd4, 12, 36 }, { TBId, 0xd5, 12, 37 }, { TBId, 0xd6, 12, 38 },
163 { TBId, 0xd7, 12, 39 }, { TBId, 0x6c, 12, 40 }, { TBId, 0x6d, 12, 41 },
164 { TBId, 0xda, 12, 42 }, { TBId, 0xdb, 12, 43 }, { TBId, 0x54, 12, 44 },
165 { TBId, 0x55, 12, 45 }, { TBId, 0x56, 12, 46 }, { TBId, 0x57, 12, 47 },
166 { TBId, 0x64, 12, 48 }, { TBId, 0x65, 12, 49 }, { TBId, 0x52, 12, 50 },
167 { TBId, 0x53, 12, 51 }, { TBId, 0x24, 12, 52 }, { TBId, 0x37, 12, 53 },
168 { TBId, 0x38, 12, 54 }, { TBId, 0x27, 12, 55 }, { TBId, 0x28, 12, 56 },
169 { TBId, 0x58, 12, 57 }, { TBId, 0x59, 12, 58 }, { TBId, 0x2b, 12, 59 },
170 { TBId, 0x2c, 12, 60 }, { TBId, 0x5a, 12, 61 }, { TBId, 0x66, 12, 62 },
171 { TBId, 0x67, 12, 63 }, { TBId, 0x00, 0, 0 }
172 };
173
174 static const HuffmanTable
175 TWTable[]=
176 {
177 { TWId, 0x35, 8, 0 }, { TWId, 0x07, 6, 1 }, { TWId, 0x07, 4, 2 },
178 { TWId, 0x08, 4, 3 }, { TWId, 0x0b, 4, 4 }, { TWId, 0x0c, 4, 5 },
179 { TWId, 0x0e, 4, 6 }, { TWId, 0x0f, 4, 7 }, { TWId, 0x13, 5, 8 },
180 { TWId, 0x14, 5, 9 }, { TWId, 0x07, 5, 10 }, { TWId, 0x08, 5, 11 },
181 { TWId, 0x08, 6, 12 }, { TWId, 0x03, 6, 13 }, { TWId, 0x34, 6, 14 },
182 { TWId, 0x35, 6, 15 }, { TWId, 0x2a, 6, 16 }, { TWId, 0x2b, 6, 17 },
183 { TWId, 0x27, 7, 18 }, { TWId, 0x0c, 7, 19 }, { TWId, 0x08, 7, 20 },
184 { TWId, 0x17, 7, 21 }, { TWId, 0x03, 7, 22 }, { TWId, 0x04, 7, 23 },
185 { TWId, 0x28, 7, 24 }, { TWId, 0x2b, 7, 25 }, { TWId, 0x13, 7, 26 },
186 { TWId, 0x24, 7, 27 }, { TWId, 0x18, 7, 28 }, { TWId, 0x02, 8, 29 },
187 { TWId, 0x03, 8, 30 }, { TWId, 0x1a, 8, 31 }, { TWId, 0x1b, 8, 32 },
188 { TWId, 0x12, 8, 33 }, { TWId, 0x13, 8, 34 }, { TWId, 0x14, 8, 35 },
189 { TWId, 0x15, 8, 36 }, { TWId, 0x16, 8, 37 }, { TWId, 0x17, 8, 38 },
190 { TWId, 0x28, 8, 39 }, { TWId, 0x29, 8, 40 }, { TWId, 0x2a, 8, 41 },
191 { TWId, 0x2b, 8, 42 }, { TWId, 0x2c, 8, 43 }, { TWId, 0x2d, 8, 44 },
192 { TWId, 0x04, 8, 45 }, { TWId, 0x05, 8, 46 }, { TWId, 0x0a, 8, 47 },
193 { TWId, 0x0b, 8, 48 }, { TWId, 0x52, 8, 49 }, { TWId, 0x53, 8, 50 },
194 { TWId, 0x54, 8, 51 }, { TWId, 0x55, 8, 52 }, { TWId, 0x24, 8, 53 },
195 { TWId, 0x25, 8, 54 }, { TWId, 0x58, 8, 55 }, { TWId, 0x59, 8, 56 },
196 { TWId, 0x5a, 8, 57 }, { TWId, 0x5b, 8, 58 }, { TWId, 0x4a, 8, 59 },
197 { TWId, 0x4b, 8, 60 }, { TWId, 0x32, 8, 61 }, { TWId, 0x33, 8, 62 },
198 { TWId, 0x34, 8, 63 }, { TWId, 0x00, 0, 0 }
199 };
200
201 /*
202 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
203 % %
204 % %
205 % %
206 % A S C I I 8 5 E n c o d e %
207 % %
208 % %
209 % %
210 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
211 %
212 % ASCII85Encode() encodes data in ASCII base-85 format. ASCII base-85
213 % encoding produces five ASCII printing characters from every four bytes of
214 % binary data.
215 %
216 % The format of the ASCII85Encode method is:
217 %
218 % void Ascii85Encode(Image *image,const size_t code)
219 %
220 % A description of each parameter follows:
221 %
222 % o code: a binary unsigned char to encode to ASCII 85.
223 %
224 % o file: write the encoded ASCII character to this file.
225 %
226 %
227 */
228 #define MaxLineExtent 36
229
Ascii85Tuple(unsigned char * data)230 static char *Ascii85Tuple(unsigned char *data)
231 {
232 static char
233 tuple[6];
234
235 register ssize_t
236 i,
237 x;
238
239 size_t
240 code,
241 quantum;
242
243 code=((((size_t) data[0] << 8) | (size_t) data[1]) << 16) |
244 ((size_t) data[2] << 8) | (size_t) data[3];
245 if (code == 0L)
246 {
247 tuple[0]='z';
248 tuple[1]='\0';
249 return(tuple);
250 }
251 quantum=85UL*85UL*85UL*85UL;
252 for (i=0; i < 4; i++)
253 {
254 x=(ssize_t) (code/quantum);
255 code-=quantum*x;
256 tuple[i]=(char) (x+(int) '!');
257 quantum/=85L;
258 }
259 tuple[4]=(char) ((code % 85L)+(int) '!');
260 tuple[5]='\0';
261 return(tuple);
262 }
263
Ascii85Initialize(Image * image)264 MagickExport void Ascii85Initialize(Image *image)
265 {
266 /*
267 Allocate image structure.
268 */
269 if (image->ascii85 == (Ascii85Info *) NULL)
270 image->ascii85=(Ascii85Info *) AcquireMagickMemory(sizeof(*image->ascii85));
271 if (image->ascii85 == (Ascii85Info *) NULL)
272 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
273 (void) ResetMagickMemory(image->ascii85,0,sizeof(*image->ascii85));
274 image->ascii85->line_break=MaxLineExtent << 1;
275 image->ascii85->offset=0;
276 }
277
Ascii85Flush(Image * image)278 MagickExport void Ascii85Flush(Image *image)
279 {
280 register char
281 *tuple;
282
283 assert(image != (Image *) NULL);
284 assert(image->signature == MagickCoreSignature);
285 if (image->debug != MagickFalse)
286 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
287 assert(image->ascii85 != (Ascii85Info *) NULL);
288 if (image->ascii85->offset > 0)
289 {
290 image->ascii85->buffer[image->ascii85->offset]='\0';
291 image->ascii85->buffer[image->ascii85->offset+1]='\0';
292 image->ascii85->buffer[image->ascii85->offset+2]='\0';
293 tuple=Ascii85Tuple(image->ascii85->buffer);
294 (void) WriteBlob(image,(size_t) image->ascii85->offset+1,
295 (const unsigned char *) (*tuple == 'z' ? "!!!!" : tuple));
296 }
297 (void) WriteBlobByte(image,'~');
298 (void) WriteBlobByte(image,'>');
299 (void) WriteBlobByte(image,'\n');
300 }
301
Ascii85Encode(Image * image,const unsigned char code)302 MagickExport void Ascii85Encode(Image *image,const unsigned char code)
303 {
304 register char
305 *q;
306
307 register unsigned char
308 *p;
309
310 ssize_t
311 n;
312
313 assert(image != (Image *) NULL);
314 assert(image->signature == MagickCoreSignature);
315 assert(image->ascii85 != (Ascii85Info *) NULL);
316 image->ascii85->buffer[image->ascii85->offset]=code;
317 image->ascii85->offset++;
318 if (image->ascii85->offset < 4)
319 return;
320 p=image->ascii85->buffer;
321 for (n=image->ascii85->offset; n >= 4; n-=4)
322 {
323 for (q=Ascii85Tuple(p); *q != '\0'; q++)
324 {
325 image->ascii85->line_break--;
326 if ((image->ascii85->line_break < 0) && (*q != '%'))
327 {
328 (void) WriteBlobByte(image,'\n');
329 image->ascii85->line_break=2*MaxLineExtent;
330 }
331 (void) WriteBlobByte(image,(unsigned char) *q);
332 }
333 p+=8;
334 }
335 image->ascii85->offset=n;
336 p-=4;
337 for (n=0; n < 4; n++)
338 image->ascii85->buffer[n]=(*p++);
339 }
340
341 /*
342 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
343 % %
344 % %
345 % %
346 % H u f f m a n D e c o d e I m a g e %
347 % %
348 % %
349 % %
350 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
351 %
352 % HuffmanDecodeImage() uncompresses an image via Huffman-coding.
353 %
354 % The format of the HuffmanDecodeImage method is:
355 %
356 % MagickBooleanType HuffmanDecodeImage(Image *image,
357 % ExceptionInfo *exception)
358 %
359 % A description of each parameter follows:
360 %
361 % o image: the image.
362 %
363 % o exception: return any errors or warnings in this structure.
364 %
365 */
HuffmanDecodeImage(Image * image,ExceptionInfo * exception)366 MagickExport MagickBooleanType HuffmanDecodeImage(Image *image,
367 ExceptionInfo *exception)
368 {
369 #define HashSize 1021
370 #define MBHashA 293
371 #define MBHashB 2695
372 #define MWHashA 3510
373 #define MWHashB 1178
374
375 #define InitializeHashTable(hash,table,a,b) \
376 { \
377 entry=table; \
378 while (entry->code != 0) \
379 { \
380 hash[((entry->length+a)*(entry->code+b)) % HashSize]=(HuffmanTable *) entry; \
381 entry++; \
382 } \
383 }
384
385 #define InputBit(bit) \
386 { \
387 if ((mask & 0xff) == 0) \
388 { \
389 byte=ReadBlobByte(image); \
390 if (byte == EOF) \
391 break; \
392 mask=0x80; \
393 } \
394 runlength++; \
395 bit=(size_t) ((byte & mask) != 0 ? 0x01 : 0x00); \
396 mask>>=1; \
397 if (bit != 0) \
398 runlength=0; \
399 }
400
401 CacheView
402 *image_view;
403
404 const HuffmanTable
405 *entry;
406
407 HuffmanTable
408 **mb_hash,
409 **mw_hash;
410
411 int
412 byte;
413
414 MagickBooleanType
415 proceed;
416
417 Quantum
418 index;
419
420 register ssize_t
421 i;
422
423 register unsigned char
424 *p;
425
426 size_t
427 bit,
428 code,
429 mask,
430 length,
431 null_lines,
432 runlength;
433
434 ssize_t
435 count,
436 y;
437
438 unsigned char
439 *scanline;
440
441 unsigned int
442 bail,
443 color;
444
445 /*
446 Allocate buffers.
447 */
448 assert(image != (Image *) NULL);
449 assert(image->signature == MagickCoreSignature);
450 if (image->debug != MagickFalse)
451 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
452 mb_hash=(HuffmanTable **) AcquireQuantumMemory(HashSize,sizeof(*mb_hash));
453 mw_hash=(HuffmanTable **) AcquireQuantumMemory(HashSize,sizeof(*mw_hash));
454 scanline=(unsigned char *) AcquireQuantumMemory((size_t) image->columns,
455 sizeof(*scanline));
456 if ((mb_hash == (HuffmanTable **) NULL) ||
457 (mw_hash == (HuffmanTable **) NULL) ||
458 (scanline == (unsigned char *) NULL))
459 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
460 image->filename);
461 /*
462 Initialize Huffman tables.
463 */
464 for (i=0; i < HashSize; i++)
465 {
466 mb_hash[i]=(HuffmanTable *) NULL;
467 mw_hash[i]=(HuffmanTable *) NULL;
468 }
469 InitializeHashTable(mw_hash,TWTable,MWHashA,MWHashB);
470 InitializeHashTable(mw_hash,MWTable,MWHashA,MWHashB);
471 InitializeHashTable(mw_hash,EXTable,MWHashA,MWHashB);
472 InitializeHashTable(mb_hash,TBTable,MBHashA,MBHashB);
473 InitializeHashTable(mb_hash,MBTable,MBHashA,MBHashB);
474 InitializeHashTable(mb_hash,EXTable,MBHashA,MBHashB);
475 /*
476 Uncompress 1D Huffman to runlength encoded pixels.
477 */
478 byte=0;
479 mask=0;
480 null_lines=0;
481 runlength=0;
482 while (runlength < 11)
483 InputBit(bit);
484 do { InputBit(bit); } while ((int) bit == 0);
485 image->resolution.x=204.0;
486 image->resolution.y=196.0;
487 image->units=PixelsPerInchResolution;
488 image_view=AcquireAuthenticCacheView(image,exception);
489 for (y=0; ((y < (ssize_t) image->rows) && (null_lines < 3)); )
490 {
491 register Quantum
492 *magick_restrict q;
493
494 register ssize_t
495 x;
496
497 /*
498 Initialize scanline to white.
499 */
500 ResetMagickMemory(scanline,0,sizeof(*scanline)*image->columns);
501 /*
502 Decode Huffman encoded scanline.
503 */
504 color=MagickTrue;
505 code=0;
506 count=0;
507 length=0;
508 runlength=0;
509 x=0;
510 for ( ; ; )
511 {
512 if (byte == EOF)
513 break;
514 if (x >= (ssize_t) image->columns)
515 {
516 while (runlength < 11)
517 InputBit(bit);
518 do { InputBit(bit); } while ((int) bit == 0);
519 break;
520 }
521 bail=MagickFalse;
522 do
523 {
524 if (runlength < 11)
525 InputBit(bit)
526 else
527 {
528 InputBit(bit);
529 if ((int) bit != 0)
530 {
531 null_lines++;
532 if (x != 0)
533 null_lines=0;
534 bail=MagickTrue;
535 break;
536 }
537 }
538 code=(code << 1)+(size_t) bit;
539 length++;
540 } while (code == 0);
541 if (bail != MagickFalse)
542 break;
543 if (length > 13)
544 {
545 while (runlength < 11)
546 InputBit(bit);
547 do { InputBit(bit); } while ((int) bit == 0);
548 break;
549 }
550 if (color != MagickFalse)
551 {
552 if (length < 4)
553 continue;
554 entry=mw_hash[((length+MWHashA)*(code+MWHashB)) % HashSize];
555 }
556 else
557 {
558 if (length < 2)
559 continue;
560 entry=mb_hash[((length+MBHashA)*(code+MBHashB)) % HashSize];
561 }
562 if (entry == (const HuffmanTable *) NULL)
563 continue;
564 if ((entry->length != length) || (entry->code != code))
565 continue;
566 switch (entry->id)
567 {
568 case TWId:
569 case TBId:
570 {
571 count+=(ssize_t) entry->count;
572 if ((x+count) > (ssize_t) image->columns)
573 count=(ssize_t) image->columns-x;
574 if (count > 0)
575 {
576 if (color != MagickFalse)
577 {
578 x+=count;
579 count=0;
580 }
581 else
582 for ( ; count > 0; count--)
583 scanline[x++]=(unsigned char) 1;
584 }
585 color=(unsigned int)
586 ((color == MagickFalse) ? MagickTrue : MagickFalse);
587 break;
588 }
589 case MWId:
590 case MBId:
591 case EXId:
592 {
593 count+=(ssize_t) entry->count;
594 break;
595 }
596 default:
597 break;
598 }
599 code=0;
600 length=0;
601 }
602 /*
603 Transfer scanline to image pixels.
604 */
605 p=scanline;
606 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
607 if (q == (Quantum *) NULL)
608 break;
609 for (x=0; x < (ssize_t) image->columns; x++)
610 {
611 index=(Quantum) (*p++);
612 SetPixelIndex(image,index,q);
613 SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
614 q+=GetPixelChannels(image);
615 }
616 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
617 break;
618 proceed=SetImageProgress(image,LoadImageTag,y,image->rows);
619 if (proceed == MagickFalse)
620 break;
621 y++;
622 }
623 image_view=DestroyCacheView(image_view);
624 image->rows=(size_t) MagickMax((size_t) y-3,1);
625 image->compression=FaxCompression;
626 /*
627 Free decoder memory.
628 */
629 mw_hash=(HuffmanTable **) RelinquishMagickMemory(mw_hash);
630 mb_hash=(HuffmanTable **) RelinquishMagickMemory(mb_hash);
631 scanline=(unsigned char *) RelinquishMagickMemory(scanline);
632 return(MagickTrue);
633 }
634
635 /*
636 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
637 % %
638 % %
639 % %
640 % H u f f m a n E n c o d e I m a g e %
641 % %
642 % %
643 % %
644 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
645 %
646 % HuffmanEncodeImage() compresses an image via Huffman-coding.
647 %
648 % The format of the HuffmanEncodeImage method is:
649 %
650 % MagickBooleanType HuffmanEncodeImage(const ImageInfo *image_info,
651 % Image *image,Image *inject_image,ExceptionInfo *exception)
652 %
653 % A description of each parameter follows:
654 %
655 % o image_info: the image info..
656 %
657 % o image: the image.
658 %
659 % o inject_image: inject into the image stream.
660 %
661 % o exception: return any errors or warnings in this structure.
662 %
663 */
HuffmanEncodeImage(const ImageInfo * image_info,Image * image,Image * inject_image,ExceptionInfo * exception)664 MagickExport MagickBooleanType HuffmanEncodeImage(const ImageInfo *image_info,
665 Image *image,Image *inject_image,ExceptionInfo *exception)
666 {
667 #define HuffmanOutputCode(entry) \
668 { \
669 mask=one << (entry->length-1); \
670 while (mask != 0) \
671 { \
672 OutputBit(((entry->code & mask) != 0 ? 1 : 0)); \
673 mask>>=1; \
674 } \
675 }
676
677 #define OutputBit(count) \
678 { \
679 DisableMSCWarning(4127) \
680 if (count > 0) \
681 byte=byte | bit; \
682 RestoreMSCWarning \
683 bit>>=1; \
684 if ((int) (bit & 0xff) == 0) \
685 { \
686 if (LocaleCompare(image_info->magick,"FAX") == 0) \
687 (void) WriteBlobByte(image,(unsigned char) byte); \
688 else \
689 Ascii85Encode(image,byte); \
690 byte='\0'; \
691 bit=(unsigned char) 0x80; \
692 } \
693 }
694
695 const HuffmanTable
696 *entry;
697
698 int
699 k,
700 runlength;
701
702 Image
703 *huffman_image;
704
705 MagickBooleanType
706 proceed;
707
708 register ssize_t
709 i,
710 x;
711
712 register const Quantum
713 *p;
714
715 register unsigned char
716 *q;
717
718 size_t
719 mask,
720 one,
721 width;
722
723 ssize_t
724 n,
725 y;
726
727 unsigned char
728 byte,
729 bit,
730 *scanline;
731
732 /*
733 Allocate scanline buffer.
734 */
735 assert(image_info != (ImageInfo *) NULL);
736 assert(image_info->signature == MagickCoreSignature);
737 assert(image != (Image *) NULL);
738 assert(image->signature == MagickCoreSignature);
739 if (image->debug != MagickFalse)
740 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
741 assert(inject_image != (Image *) NULL);
742 assert(inject_image->signature == MagickCoreSignature);
743 one=1;
744 width=inject_image->columns;
745 if (LocaleCompare(image_info->magick,"FAX") == 0)
746 width=(size_t) MagickMax(inject_image->columns,1728);
747 scanline=(unsigned char *) AcquireQuantumMemory((size_t) width+1UL,
748 sizeof(*scanline));
749 if (scanline == (unsigned char *) NULL)
750 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
751 inject_image->filename);
752 (void) ResetMagickMemory(scanline,0,width*sizeof(*scanline));
753 huffman_image=CloneImage(inject_image,0,0,MagickTrue,exception);
754 if (huffman_image == (Image *) NULL)
755 {
756 scanline=(unsigned char *) RelinquishMagickMemory(scanline);
757 return(MagickFalse);
758 }
759 (void) SetImageType(huffman_image,BilevelType,exception);
760 byte='\0';
761 bit=(unsigned char) 0x80;
762 if (LocaleCompare(image_info->magick,"FAX") != 0)
763 Ascii85Initialize(image);
764 else
765 {
766 /*
767 End of line.
768 */
769 for (k=0; k < 11; k++)
770 OutputBit(0);
771 OutputBit(1);
772 }
773 /*
774 Compress to 1D Huffman pixels.
775 */
776 q=scanline;
777 for (y=0; y < (ssize_t) huffman_image->rows; y++)
778 {
779 p=GetVirtualPixels(huffman_image,0,y,huffman_image->columns,1,exception);
780 if (p == (const Quantum *) NULL)
781 break;
782 for (x=0; x < (ssize_t) huffman_image->columns; x++)
783 {
784 *q++=(unsigned char) (GetPixelIntensity(huffman_image,p) >=
785 ((double) QuantumRange/2.0) ? 0 : 1);
786 p+=GetPixelChannels(huffman_image);
787 }
788 /*
789 Huffman encode scanline.
790 */
791 q=scanline;
792 for (n=(ssize_t) width; n > 0; )
793 {
794 /*
795 Output white run.
796 */
797 for (runlength=0; ((n > 0) && (*q == 0)); n--)
798 {
799 q++;
800 runlength++;
801 }
802 if (runlength >= 64)
803 {
804 if (runlength < 1792)
805 entry=MWTable+((runlength/64)-1);
806 else
807 entry=EXTable+(MagickMin((size_t) runlength,2560)-1792)/64;
808 runlength-=(long) entry->count;
809 HuffmanOutputCode(entry);
810 }
811 entry=TWTable+MagickMin((size_t) runlength,63);
812 HuffmanOutputCode(entry);
813 if (n != 0)
814 {
815 /*
816 Output black run.
817 */
818 for (runlength=0; ((*q != 0) && (n > 0)); n--)
819 {
820 q++;
821 runlength++;
822 }
823 if (runlength >= 64)
824 {
825 entry=MBTable+((runlength/64)-1);
826 if (runlength >= 1792)
827 entry=EXTable+(MagickMin((size_t) runlength,2560)-1792)/64;
828 runlength-=(long) entry->count;
829 HuffmanOutputCode(entry);
830 }
831 entry=TBTable+MagickMin((size_t) runlength,63);
832 HuffmanOutputCode(entry);
833 }
834 }
835 /*
836 End of line.
837 */
838 for (k=0; k < 11; k++)
839 OutputBit(0);
840 OutputBit(1);
841 q=scanline;
842 if (GetPreviousImageInList(huffman_image) == (Image *) NULL)
843 {
844 proceed=SetImageProgress(huffman_image,LoadImageTag,y,
845 huffman_image->rows);
846 if (proceed == MagickFalse)
847 break;
848 }
849 }
850 /*
851 End of page.
852 */
853 for (i=0; i < 6; i++)
854 {
855 for (k=0; k < 11; k++)
856 OutputBit(0);
857 OutputBit(1);
858 }
859 /*
860 Flush bits.
861 */
862 if (((int) bit != 0x80) != 0)
863 {
864 if (LocaleCompare(image_info->magick,"FAX") == 0)
865 (void) WriteBlobByte(image,byte);
866 else
867 Ascii85Encode(image,byte);
868 }
869 if (LocaleCompare(image_info->magick,"FAX") != 0)
870 Ascii85Flush(image);
871 huffman_image=DestroyImage(huffman_image);
872 scanline=(unsigned char *) RelinquishMagickMemory(scanline);
873 return(MagickTrue);
874 }
875
876 /*
877 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
878 % %
879 % %
880 % %
881 % L Z W E n c o d e I m a g e %
882 % %
883 % %
884 % %
885 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
886 %
887 % LZWEncodeImage() compresses an image via LZW-coding specific to Postscript
888 % Level II or Portable Document Format.
889 %
890 % The format of the LZWEncodeImage method is:
891 %
892 % MagickBooleanType LZWEncodeImage(Image *image,const size_t length,
893 % unsigned char *magick_restrict pixels,ExceptionInfo *exception)
894 %
895 % A description of each parameter follows:
896 %
897 % o image: the image.
898 %
899 % o length: A value that specifies the number of pixels to compress.
900 %
901 % o pixels: the address of an unsigned array of characters containing the
902 % pixels to compress.
903 %
904 % o exception: return any errors or warnings in this structure.
905 %
906 */
LZWEncodeImage(Image * image,const size_t length,unsigned char * magick_restrict pixels,ExceptionInfo * exception)907 MagickExport MagickBooleanType LZWEncodeImage(Image *image,const size_t length,
908 unsigned char *magick_restrict pixels,ExceptionInfo *exception)
909 {
910 #define LZWClr 256UL /* Clear Table Marker */
911 #define LZWEod 257UL /* End of Data marker */
912 #define OutputCode(code) \
913 { \
914 accumulator+=code << (32-code_width-number_bits); \
915 number_bits+=code_width; \
916 while (number_bits >= 8) \
917 { \
918 (void) WriteBlobByte(image,(unsigned char) (accumulator >> 24)); \
919 accumulator=accumulator << 8; \
920 number_bits-=8; \
921 } \
922 }
923
924 typedef struct _TableType
925 {
926 ssize_t
927 prefix,
928 suffix,
929 next;
930 } TableType;
931
932 register ssize_t
933 i;
934
935 size_t
936 accumulator,
937 number_bits,
938 code_width,
939 last_code,
940 next_index;
941
942 ssize_t
943 index;
944
945 TableType
946 *table;
947
948 /*
949 Allocate string table.
950 */
951 assert(image != (Image *) NULL);
952 assert(image->signature == MagickCoreSignature);
953 if (image->debug != MagickFalse)
954 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
955 assert(pixels != (unsigned char *) NULL);
956 assert(exception != (ExceptionInfo *) NULL);
957 assert(exception->signature == MagickCoreSignature);
958 table=(TableType *) AcquireQuantumMemory(1UL << 12,sizeof(*table));
959 if (table == (TableType *) NULL)
960 return(MagickFalse);
961 /*
962 Initialize variables.
963 */
964 accumulator=0;
965 code_width=9;
966 number_bits=0;
967 last_code=0;
968 OutputCode(LZWClr);
969 for (index=0; index < 256; index++)
970 {
971 table[index].prefix=(-1);
972 table[index].suffix=(short) index;
973 table[index].next=(-1);
974 }
975 next_index=LZWEod+1;
976 code_width=9;
977 last_code=(size_t) pixels[0];
978 for (i=1; i < (ssize_t) length; i++)
979 {
980 /*
981 Find string.
982 */
983 index=(ssize_t) last_code;
984 while (index != -1)
985 if ((table[index].prefix != (ssize_t) last_code) ||
986 (table[index].suffix != (ssize_t) pixels[i]))
987 index=table[index].next;
988 else
989 {
990 last_code=(size_t) index;
991 break;
992 }
993 if (last_code != (size_t) index)
994 {
995 /*
996 Add string.
997 */
998 OutputCode(last_code);
999 table[next_index].prefix=(ssize_t) last_code;
1000 table[next_index].suffix=(short) pixels[i];
1001 table[next_index].next=table[last_code].next;
1002 table[last_code].next=(ssize_t) next_index;
1003 next_index++;
1004 /*
1005 Did we just move up to next bit width?
1006 */
1007 if ((next_index >> code_width) != 0)
1008 {
1009 code_width++;
1010 if (code_width > 12)
1011 {
1012 /*
1013 Did we overflow the max bit width?
1014 */
1015 code_width--;
1016 OutputCode(LZWClr);
1017 for (index=0; index < 256; index++)
1018 {
1019 table[index].prefix=(-1);
1020 table[index].suffix=index;
1021 table[index].next=(-1);
1022 }
1023 next_index=LZWEod+1;
1024 code_width=9;
1025 }
1026 }
1027 last_code=(size_t) pixels[i];
1028 }
1029 }
1030 /*
1031 Flush tables.
1032 */
1033 OutputCode(last_code);
1034 OutputCode(LZWEod);
1035 if (number_bits != 0)
1036 (void) WriteBlobByte(image,(unsigned char) (accumulator >> 24));
1037 table=(TableType *) RelinquishMagickMemory(table);
1038 return(MagickTrue);
1039 }
1040
1041 /*
1042 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1043 % %
1044 % %
1045 % %
1046 % P a c k b i t s E n c o d e I m a g e %
1047 % %
1048 % %
1049 % %
1050 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1051 %
1052 % PackbitsEncodeImage() compresses an image via Macintosh Packbits encoding
1053 % specific to Postscript Level II or Portable Document Format. To ensure
1054 % portability, the binary Packbits bytes are encoded as ASCII Base-85.
1055 %
1056 % The format of the PackbitsEncodeImage method is:
1057 %
1058 % MagickBooleanType PackbitsEncodeImage(Image *image,const size_t length,
1059 % unsigned char *magick_restrict pixels)
1060 %
1061 % A description of each parameter follows:
1062 %
1063 % o image: the image.
1064 %
1065 % o length: A value that specifies the number of pixels to compress.
1066 %
1067 % o pixels: the address of an unsigned array of characters containing the
1068 % pixels to compress.
1069 %
1070 */
PackbitsEncodeImage(Image * image,const size_t length,unsigned char * magick_restrict pixels,ExceptionInfo * exception)1071 MagickExport MagickBooleanType PackbitsEncodeImage(Image *image,
1072 const size_t length,unsigned char *magick_restrict pixels,
1073 ExceptionInfo *exception)
1074 {
1075 int
1076 count;
1077
1078 register ssize_t
1079 i,
1080 j;
1081
1082 unsigned char
1083 *packbits;
1084
1085 /*
1086 Compress pixels with Packbits encoding.
1087 */
1088 assert(image != (Image *) NULL);
1089 assert(image->signature == MagickCoreSignature);
1090 if (image->debug != MagickFalse)
1091 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1092 assert(pixels != (unsigned char *) NULL);
1093 packbits=(unsigned char *) AcquireQuantumMemory(128UL,sizeof(*packbits));
1094 if (packbits == (unsigned char *) NULL)
1095 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1096 image->filename);
1097 for (i=(ssize_t) length; i != 0; )
1098 {
1099 switch (i)
1100 {
1101 case 1:
1102 {
1103 i--;
1104 (void) WriteBlobByte(image,(unsigned char) 0);
1105 (void) WriteBlobByte(image,*pixels);
1106 break;
1107 }
1108 case 2:
1109 {
1110 i-=2;
1111 (void) WriteBlobByte(image,(unsigned char) 1);
1112 (void) WriteBlobByte(image,*pixels);
1113 (void) WriteBlobByte(image,pixels[1]);
1114 break;
1115 }
1116 case 3:
1117 {
1118 i-=3;
1119 if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
1120 {
1121 (void) WriteBlobByte(image,(unsigned char) ((256-3)+1));
1122 (void) WriteBlobByte(image,*pixels);
1123 break;
1124 }
1125 (void) WriteBlobByte(image,(unsigned char) 2);
1126 (void) WriteBlobByte(image,*pixels);
1127 (void) WriteBlobByte(image,pixels[1]);
1128 (void) WriteBlobByte(image,pixels[2]);
1129 break;
1130 }
1131 default:
1132 {
1133 if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
1134 {
1135 /*
1136 Packed run.
1137 */
1138 count=3;
1139 while (((ssize_t) count < i) && (*pixels == *(pixels+count)))
1140 {
1141 count++;
1142 if (count >= 127)
1143 break;
1144 }
1145 i-=count;
1146 (void) WriteBlobByte(image,(unsigned char) ((256-count)+1));
1147 (void) WriteBlobByte(image,*pixels);
1148 pixels+=count;
1149 break;
1150 }
1151 /*
1152 Literal run.
1153 */
1154 count=0;
1155 while ((*(pixels+count) != *(pixels+count+1)) ||
1156 (*(pixels+count+1) != *(pixels+count+2)))
1157 {
1158 packbits[count+1]=pixels[count];
1159 count++;
1160 if (((ssize_t) count >= (i-3)) || (count >= 127))
1161 break;
1162 }
1163 i-=count;
1164 *packbits=(unsigned char) (count-1);
1165 for (j=0; j <= (ssize_t) count; j++)
1166 (void) WriteBlobByte(image,packbits[j]);
1167 pixels+=count;
1168 break;
1169 }
1170 }
1171 }
1172 (void) WriteBlobByte(image,(unsigned char) 128); /* EOD marker */
1173 packbits=(unsigned char *) RelinquishMagickMemory(packbits);
1174 return(MagickTrue);
1175 }
1176
1177 #if defined(MAGICKCORE_ZLIB_DELEGATE)
1178 /*
1179 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1180 % %
1181 % %
1182 % %
1183 % Z L I B E n c o d e I m a g e %
1184 % %
1185 % %
1186 % %
1187 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1188 %
1189 % ZLIBEncodeImage compresses an image via ZLIB-coding specific to
1190 % Postscript Level II or Portable Document Format.
1191 %
1192 % The format of the ZLIBEncodeImage method is:
1193 %
1194 % MagickBooleanType ZLIBEncodeImage(Image *image,const size_t length,
1195 % unsigned char *magick_restrict pixels,ExceptionInfo *exception)
1196 %
1197 % A description of each parameter follows:
1198 %
1199 % o file: the address of a structure of type FILE. ZLIB encoded pixels
1200 % are written to this file.
1201 %
1202 % o length: A value that specifies the number of pixels to compress.
1203 %
1204 % o pixels: the address of an unsigned array of characters containing the
1205 % pixels to compress.
1206 %
1207 % o exception: return any errors or warnings in this structure.
1208 %
1209 */
1210
AcquireZIPMemory(voidpf context,unsigned int items,unsigned int size)1211 static voidpf AcquireZIPMemory(voidpf context,unsigned int items,
1212 unsigned int size)
1213 {
1214 (void) context;
1215 return((voidpf) AcquireQuantumMemory(items,size));
1216 }
1217
RelinquishZIPMemory(voidpf context,voidpf memory)1218 static void RelinquishZIPMemory(voidpf context,voidpf memory)
1219 {
1220 (void) context;
1221 memory=RelinquishMagickMemory(memory);
1222 }
1223
ZLIBEncodeImage(Image * image,const size_t length,unsigned char * magick_restrict pixels,ExceptionInfo * exception)1224 MagickExport MagickBooleanType ZLIBEncodeImage(Image *image,const size_t length,
1225 unsigned char *magick_restrict pixels,ExceptionInfo *exception)
1226 {
1227 int
1228 status;
1229
1230 register ssize_t
1231 i;
1232
1233 size_t
1234 compress_packets;
1235
1236 unsigned char
1237 *compress_pixels;
1238
1239 z_stream
1240 stream;
1241
1242 assert(image != (Image *) NULL);
1243 assert(image->signature == MagickCoreSignature);
1244 if (image->debug != MagickFalse)
1245 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1246 compress_packets=(size_t) (1.001*length+12);
1247 compress_pixels=(unsigned char *) AcquireQuantumMemory(compress_packets,
1248 sizeof(*compress_pixels));
1249 if (compress_pixels == (unsigned char *) NULL)
1250 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1251 image->filename);
1252 stream.next_in=pixels;
1253 stream.avail_in=(unsigned int) length;
1254 stream.next_out=compress_pixels;
1255 stream.avail_out=(unsigned int) compress_packets;
1256 stream.zalloc=AcquireZIPMemory;
1257 stream.zfree=RelinquishZIPMemory;
1258 stream.opaque=(voidpf) NULL;
1259 status=deflateInit(&stream,(int) (image->quality ==
1260 UndefinedCompressionQuality ? 7 : MagickMin(image->quality/10,9)));
1261 if (status == Z_OK)
1262 {
1263 status=deflate(&stream,Z_FINISH);
1264 if (status == Z_STREAM_END)
1265 status=deflateEnd(&stream);
1266 else
1267 (void) deflateEnd(&stream);
1268 compress_packets=(size_t) stream.total_out;
1269 }
1270 if (status != Z_OK)
1271 ThrowBinaryException(CoderError,"UnableToZipCompressImage",image->filename)
1272 for (i=0; i < (ssize_t) compress_packets; i++)
1273 (void) WriteBlobByte(image,compress_pixels[i]);
1274 compress_pixels=(unsigned char *) RelinquishMagickMemory(compress_pixels);
1275 return(MagickTrue);
1276 }
1277 #else
ZLIBEncodeImage(Image * image,const size_t magick_unused (length),unsigned char * magick_unused (pixels),ExceptionInfo * exception)1278 MagickExport MagickBooleanType ZLIBEncodeImage(Image *image,
1279 const size_t magick_unused(length),unsigned char *magick_unused(pixels),
1280 ExceptionInfo *exception)
1281 {
1282 assert(image != (Image *) NULL);
1283 assert(image->signature == MagickCoreSignature);
1284 if (image->debug != MagickFalse)
1285 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1286 (void) ThrowMagickException(exception,GetMagickModule(),MissingDelegateError,
1287 "DelegateLibrarySupportNotBuiltIn","'%s' (ZIP)",image->filename);
1288 return(MagickFalse);
1289 }
1290 #endif
1291