MagickCore  7.0.7
Convert, Edit, Or Compose Bitmap Images
compress.c
Go to the documentation of this file.
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 
40 /*
41  Include declarations.
42 */
43 #include "MagickCore/studio.h"
44 #include "MagickCore/attribute.h"
45 #include "MagickCore/blob.h"
48 #include "MagickCore/cache.h"
49 #include "MagickCore/compress.h"
50 #include "MagickCore/constitute.h"
51 #include "MagickCore/exception.h"
54 #include "MagickCore/list.h"
55 #include "MagickCore/memory_.h"
56 #include "MagickCore/monitor.h"
58 #include "MagickCore/option.h"
60 #include "MagickCore/resource_.h"
61 #include "MagickCore/string_.h"
62 #if defined(MAGICKCORE_ZLIB_DELEGATE)
63 #include "zlib.h"
64 #endif
65 
66 /*
67  Typedef declarations.
68 */
70 {
71  ssize_t
73  line_break;
74 
75  unsigned char
76  buffer[10];
77 };
78 
79 typedef struct HuffmanTable
80 {
81  size_t
82  id,
83  code,
84  length,
85  count;
86 } HuffmanTable;
87 
88 /*
89  Huffman coding declarations.
90 */
91 #define TWId 23
92 #define MWId 24
93 #define TBId 25
94 #define MBId 26
95 #define EXId 27
96 
97 static const HuffmanTable
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
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
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
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
176  {
177  { TWId, 0x35, 8, 0 }, { TWId, 0x07, 6, 1 }, { TWId, 0x07, 4, 2 },
178  { TWId, 0x08, 4, 3 }, { TWId, 0x0b, 4, 4 }, { TWId, 0x0c, 4, 5 },
179  { TWId, 0x0e, 4, 6 }, { TWId, 0x0f, 4, 7 }, { TWId, 0x13, 5, 8 },
180  { TWId, 0x14, 5, 9 }, { TWId, 0x07, 5, 10 }, { TWId, 0x08, 5, 11 },
181  { TWId, 0x08, 6, 12 }, { TWId, 0x03, 6, 13 }, { TWId, 0x34, 6, 14 },
182  { TWId, 0x35, 6, 15 }, { TWId, 0x2a, 6, 16 }, { TWId, 0x2b, 6, 17 },
183  { TWId, 0x27, 7, 18 }, { TWId, 0x0c, 7, 19 }, { TWId, 0x08, 7, 20 },
184  { TWId, 0x17, 7, 21 }, { TWId, 0x03, 7, 22 }, { TWId, 0x04, 7, 23 },
185  { TWId, 0x28, 7, 24 }, { TWId, 0x2b, 7, 25 }, { TWId, 0x13, 7, 26 },
186  { TWId, 0x24, 7, 27 }, { TWId, 0x18, 7, 28 }, { TWId, 0x02, 8, 29 },
187  { TWId, 0x03, 8, 30 }, { TWId, 0x1a, 8, 31 }, { TWId, 0x1b, 8, 32 },
188  { TWId, 0x12, 8, 33 }, { TWId, 0x13, 8, 34 }, { TWId, 0x14, 8, 35 },
189  { TWId, 0x15, 8, 36 }, { TWId, 0x16, 8, 37 }, { TWId, 0x17, 8, 38 },
190  { TWId, 0x28, 8, 39 }, { TWId, 0x29, 8, 40 }, { TWId, 0x2a, 8, 41 },
191  { TWId, 0x2b, 8, 42 }, { TWId, 0x2c, 8, 43 }, { TWId, 0x2d, 8, 44 },
192  { TWId, 0x04, 8, 45 }, { TWId, 0x05, 8, 46 }, { TWId, 0x0a, 8, 47 },
193  { TWId, 0x0b, 8, 48 }, { TWId, 0x52, 8, 49 }, { TWId, 0x53, 8, 50 },
194  { TWId, 0x54, 8, 51 }, { TWId, 0x55, 8, 52 }, { TWId, 0x24, 8, 53 },
195  { TWId, 0x25, 8, 54 }, { TWId, 0x58, 8, 55 }, { TWId, 0x59, 8, 56 },
196  { TWId, 0x5a, 8, 57 }, { TWId, 0x5b, 8, 58 }, { TWId, 0x4a, 8, 59 },
197  { TWId, 0x4b, 8, 60 }, { TWId, 0x32, 8, 61 }, { TWId, 0x33, 8, 62 },
198  { TWId, 0x34, 8, 63 }, { TWId, 0x00, 0, 0 }
199  };
200 
201 /*
202 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
203 % %
204 % %
205 % %
206 % A S C I I 8 5 E n c o d e %
207 % %
208 % %
209 % %
210 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
211 %
212 % ASCII85Encode() encodes data in ASCII base-85 format. ASCII base-85
213 % encoding produces five ASCII printing characters from every four bytes of
214 % binary data.
215 %
216 % The format of the ASCII85Encode method is:
217 %
218 % void Ascii85Encode(Image *image,const size_t code)
219 %
220 % A description of each parameter follows:
221 %
222 % o code: a binary unsigned char to encode to ASCII 85.
223 %
224 % o file: write the encoded ASCII character to this file.
225 %
226 %
227 */
228 #define MaxLineExtent 36
229 
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 
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 
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 
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 */
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 
408  **mb_hash,
409  **mw_hash;
410 
411  int
412  byte;
413 
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  }
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;
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;
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);
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 
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 */
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 
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 
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 */
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;
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 
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 */
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 
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
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);
1301  "DelegateLibrarySupportNotBuiltIn","'%s' (ZIP)",image->filename);
1302  return(MagickFalse);
1303 }
1304 #endif
size_t rows
Definition: image.h:172
#define magick_restrict
Definition: MagickCore.h:41
struct HuffmanTable HuffmanTable
MagickExport CacheView * DestroyCacheView(CacheView *cache_view)
Definition: cache-view.c:252
size_t code
Definition: compress.c:82
MagickExport MagickBooleanType PackbitsEncodeImage(Image *image, const size_t length, unsigned char *magick_restrict pixels, ExceptionInfo *exception)
Definition: compress.c:1083
size_t signature
Definition: image.h:479
MagickExport MagickBooleanType HuffmanDecodeImage(Image *image, ExceptionInfo *exception)
Definition: compress.c:366
static MagickBooleanType SetImageProgress(const Image *image, const char *tag, const MagickOffsetType offset, const MagickSizeType extent)
PixelInfo * colormap
Definition: image.h:179
Ascii85Info * ascii85
Definition: image.h:309
char magick[MagickPathExtent]
Definition: image.h:471
MagickExport void Ascii85Initialize(Image *image)
Definition: compress.c:264
static const HuffmanTable TBTable[]
Definition: compress.c:148
size_t length
Definition: compress.c:82
#define MWId
Definition: compress.c:92
#define MBHashA
#define ThrowFatalException(severity, tag)
size_t signature
Definition: exception.h:123
#define TBId
Definition: compress.c:93
#define TWId
Definition: compress.c:91
ssize_t offset
Definition: compress.c:72
#define MBId
Definition: compress.c:94
MagickExport ssize_t WriteBlob(Image *, const size_t, const void *)
MagickExport const char LoadImageTag[]
Definition: image.c:115
#define LZWClr
static void SetPixelViaPixelInfo(const Image *magick_restrict image, const PixelInfo *magick_restrict pixel_info, Quantum *magick_restrict pixel)
ResolutionType units
Definition: image.h:198
MagickExport MagickBooleanType HuffmanEncodeImage(const ImageInfo *image_info, Image *image, Image *inject_image, ExceptionInfo *exception)
Definition: compress.c:675
#define MBHashB
CompressionType compression
Definition: image.h:160
#define ThrowBinaryException(severity, tag, context)
Definition: log.h:52
ssize_t MagickOffsetType
Definition: magick-type.h:127
Definition: image.h:151
MagickExport Image * GetPreviousImageInList(const Image *images)
Definition: list.c:794
#define MWHashA
double x
Definition: geometry.h:123
#define MagickCoreSignature
MagickExport MagickBooleanType SetImageType(Image *image, const ImageType type, ExceptionInfo *exception)
Definition: attribute.c:1228
unsigned char buffer[10]
Definition: compress.c:76
MagickBooleanType
Definition: magick-type.h:156
#define InitializeHashTable(hash, table, a, b)
MagickExport ssize_t WriteBlobByte(Image *, const unsigned char)
MagickExport const Quantum * GetVirtualPixels(const Image *image, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
Definition: cache.c:3153
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:533
static const HuffmanTable MBTable[]
Definition: compress.c:98
MagickExport void Ascii85Flush(Image *image)
Definition: compress.c:278
double y
Definition: geometry.h:123
#define magick_unused(x)
#define UndefinedCompressionQuality
Definition: image-private.h:36
MagickExport Quantum * QueueCacheViewAuthenticPixels(CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
Definition: cache-view.c:977
MagickExport void Ascii85Encode(Image *image, const unsigned char code)
Definition: compress.c:302
MagickExport MagickBooleanType ThrowMagickException(ExceptionInfo *exception, const char *module, const char *function, const size_t line, const ExceptionType severity, const char *tag, const char *format,...)
Definition: exception.c:1058
MagickExport MagickBooleanType LogMagickEvent(const LogEventType type, const char *module, const char *function, const size_t line, const char *format,...)
Definition: log.c:1397
static char * Ascii85Tuple(unsigned char *data)
Definition: compress.c:230
size_t signature
Definition: image.h:354
size_t columns
Definition: image.h:172
#define LZWEod
#define MagickMax(x, y)
Definition: image-private.h:26
static const HuffmanTable EXTable[]
Definition: compress.c:117
size_t quality
Definition: image.h:163
#define EXId
Definition: compress.c:95
ssize_t line_break
Definition: compress.c:72
static size_t GetPixelChannels(const Image *magick_restrict image)
MagickExport int LocaleCompare(const char *p, const char *q)
Definition: locale.c:1408
char filename[MagickPathExtent]
Definition: image.h:319
#define GetMagickModule()
Definition: log.h:28
size_t count
Definition: compress.c:82
#define MWHashB
unsigned short Quantum
Definition: magick-type.h:82
MagickExport void * AcquireMagickMemory(const size_t size)
Definition: memory.c:462
size_t id
Definition: compress.c:82
#define OutputCode(code)
static void SetPixelIndex(const Image *magick_restrict image, const Quantum index, Quantum *magick_restrict pixel)
BlobInfo * blob
Definition: image.h:328
#define MagickMin(x, y)
Definition: image-private.h:27
#define OutputBit(count)
MagickExport void * RelinquishMagickMemory(void *memory)
Definition: memory.c:1027
PointInfo resolution
Definition: image.h:209
#define magick_unreferenced(x)
#define HuffmanOutputCode(entry)
#define MaxLineExtent
Definition: compress.c:228
MagickExport MagickBooleanType ZLIBEncodeImage(Image *image, const size_t magick_unused(length), unsigned char *magick_unused(pixels), ExceptionInfo *exception)
Definition: compress.c:1290
#define MagickExport
MagickExport MagickBooleanType SyncCacheViewAuthenticPixels(CacheView *magick_restrict cache_view, ExceptionInfo *exception)
Definition: cache-view.c:1100
MagickExport CacheView * AcquireAuthenticCacheView(const Image *image, ExceptionInfo *exception)
Definition: cache-view.c:112
#define InputBit(bit)
static const HuffmanTable MWTable[]
Definition: compress.c:129
#define HashSize
static const HuffmanTable TWTable[]
Definition: compress.c:175
MagickExport MagickRealType GetPixelIntensity(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
Definition: pixel.c:2358
MagickExport Image * DestroyImage(Image *image)
Definition: image.c:1183
MagickExport Image * CloneImage(const Image *image, const size_t columns, const size_t rows, const MagickBooleanType detach, ExceptionInfo *exception)
Definition: image.c:800
MagickExport MagickBooleanType LZWEncodeImage(Image *image, const size_t length, unsigned char *magick_restrict pixels, ExceptionInfo *exception)
Definition: compress.c:918
#define QuantumRange
Definition: magick-type.h:83
MagickBooleanType debug
Definition: image.h:334