granicus.if.org Git - imagemagick/blob - magick/compress.c

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