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