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