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)
103 { MBId, 0x0f, 10, 64 }, { MBId, 0xc8, 12, 128 },
104 { MBId, 0xc9, 12, 192 }, { MBId, 0x5b, 12, 256 },
105 { MBId, 0x33, 12, 320 }, { MBId, 0x34, 12, 384 },
106 { MBId, 0x35, 12, 448 }, { MBId, 0x6c, 13, 512 },
107 { MBId, 0x6d, 13, 576 }, { MBId, 0x4a, 13, 640 },
108 { MBId, 0x4b, 13, 704 }, { MBId, 0x4c, 13, 768 },
109 { MBId, 0x4d, 13, 832 }, { MBId, 0x72, 13, 896 },
110 { MBId, 0x73, 13, 960 }, { MBId, 0x74, 13, 1024 },
111 { MBId, 0x75, 13, 1088 }, { MBId, 0x76, 13, 1152 },
112 { MBId, 0x77, 13, 1216 }, { MBId, 0x52, 13, 1280 },
113 { MBId, 0x53, 13, 1344 }, { MBId, 0x54, 13, 1408 },
114 { MBId, 0x55, 13, 1472 }, { MBId, 0x5a, 13, 1536 },
115 { MBId, 0x5b, 13, 1600 }, { MBId, 0x64, 13, 1664 },
116 { MBId, 0x65, 13, 1728 }, { MBId, 0x00, 0, 0 }
122 { EXId, 0x08, 11, 1792 }, { EXId, 0x0c, 11, 1856 },
123 { EXId, 0x0d, 11, 1920 }, { EXId, 0x12, 12, 1984 },
124 { EXId, 0x13, 12, 2048 }, { EXId, 0x14, 12, 2112 },
125 { EXId, 0x15, 12, 2176 }, { EXId, 0x16, 12, 2240 },
126 { EXId, 0x17, 12, 2304 }, { EXId, 0x1c, 12, 2368 },
127 { EXId, 0x1d, 12, 2432 }, { EXId, 0x1e, 12, 2496 },
128 { EXId, 0x1f, 12, 2560 }, { EXId, 0x00, 0, 0 }
134 { MWId, 0x1b, 5, 64 }, { MWId, 0x12, 5, 128 },
135 { MWId, 0x17, 6, 192 }, { MWId, 0x37, 7, 256 },
136 { MWId, 0x36, 8, 320 }, { MWId, 0x37, 8, 384 },
137 { MWId, 0x64, 8, 448 }, { MWId, 0x65, 8, 512 },
138 { MWId, 0x68, 8, 576 }, { MWId, 0x67, 8, 640 },
139 { MWId, 0xcc, 9, 704 }, { MWId, 0xcd, 9, 768 },
140 { MWId, 0xd2, 9, 832 }, { MWId, 0xd3, 9, 896 },
141 { MWId, 0xd4, 9, 960 }, { MWId, 0xd5, 9, 1024 },
142 { MWId, 0xd6, 9, 1088 }, { MWId, 0xd7, 9, 1152 },
143 { MWId, 0xd8, 9, 1216 }, { MWId, 0xd9, 9, 1280 },
144 { MWId, 0xda, 9, 1344 }, { MWId, 0xdb, 9, 1408 },
145 { MWId, 0x98, 9, 1472 }, { MWId, 0x99, 9, 1536 },
146 { MWId, 0x9a, 9, 1600 }, { MWId, 0x18, 6, 1664 },
147 { MWId, 0x9b, 9, 1728 }, { MWId, 0x00, 0, 0 }
153 { TBId, 0x37, 10, 0 }, { TBId, 0x02, 3, 1 }, { TBId, 0x03, 2, 2 },
154 { TBId, 0x02, 2, 3 }, { TBId, 0x03, 3, 4 }, { TBId, 0x03, 4, 5 },
155 { TBId, 0x02, 4, 6 }, { TBId, 0x03, 5, 7 }, { TBId, 0x05, 6, 8 },
156 { TBId, 0x04, 6, 9 }, { TBId, 0x04, 7, 10 }, { TBId, 0x05, 7, 11 },
157 { TBId, 0x07, 7, 12 }, { TBId, 0x04, 8, 13 }, { TBId, 0x07, 8, 14 },
158 { TBId, 0x18, 9, 15 }, { TBId, 0x17, 10, 16 }, { TBId, 0x18, 10, 17 },
159 { TBId, 0x08, 10, 18 }, { TBId, 0x67, 11, 19 }, { TBId, 0x68, 11, 20 },
160 { TBId, 0x6c, 11, 21 }, { TBId, 0x37, 11, 22 }, { TBId, 0x28, 11, 23 },
161 { TBId, 0x17, 11, 24 }, { TBId, 0x18, 11, 25 }, { TBId, 0xca, 12, 26 },
162 { TBId, 0xcb, 12, 27 }, { TBId, 0xcc, 12, 28 }, { TBId, 0xcd, 12, 29 },
163 { TBId, 0x68, 12, 30 }, { TBId, 0x69, 12, 31 }, { TBId, 0x6a, 12, 32 },
164 { TBId, 0x6b, 12, 33 }, { TBId, 0xd2, 12, 34 }, { TBId, 0xd3, 12, 35 },
165 { TBId, 0xd4, 12, 36 }, { TBId, 0xd5, 12, 37 }, { TBId, 0xd6, 12, 38 },
166 { TBId, 0xd7, 12, 39 }, { TBId, 0x6c, 12, 40 }, { TBId, 0x6d, 12, 41 },
167 { TBId, 0xda, 12, 42 }, { TBId, 0xdb, 12, 43 }, { TBId, 0x54, 12, 44 },
168 { TBId, 0x55, 12, 45 }, { TBId, 0x56, 12, 46 }, { TBId, 0x57, 12, 47 },
169 { TBId, 0x64, 12, 48 }, { TBId, 0x65, 12, 49 }, { TBId, 0x52, 12, 50 },
170 { TBId, 0x53, 12, 51 }, { TBId, 0x24, 12, 52 }, { TBId, 0x37, 12, 53 },
171 { TBId, 0x38, 12, 54 }, { TBId, 0x27, 12, 55 }, { TBId, 0x28, 12, 56 },
172 { TBId, 0x58, 12, 57 }, { TBId, 0x59, 12, 58 }, { TBId, 0x2b, 12, 59 },
173 { TBId, 0x2c, 12, 60 }, { TBId, 0x5a, 12, 61 }, { TBId, 0x66, 12, 62 },
174 { TBId, 0x67, 12, 63 }, { TBId, 0x00, 0, 0 }
180 { TWId, 0x35, 8, 0 }, { TWId, 0x07, 6, 1 }, { TWId, 0x07, 4, 2 },
181 { TWId, 0x08, 4, 3 }, { TWId, 0x0b, 4, 4 }, { TWId, 0x0c, 4, 5 },
182 { TWId, 0x0e, 4, 6 }, { TWId, 0x0f, 4, 7 }, { TWId, 0x13, 5, 8 },
183 { TWId, 0x14, 5, 9 }, { TWId, 0x07, 5, 10 }, { TWId, 0x08, 5, 11 },
184 { TWId, 0x08, 6, 12 }, { TWId, 0x03, 6, 13 }, { TWId, 0x34, 6, 14 },
185 { TWId, 0x35, 6, 15 }, { TWId, 0x2a, 6, 16 }, { TWId, 0x2b, 6, 17 },
186 { TWId, 0x27, 7, 18 }, { TWId, 0x0c, 7, 19 }, { TWId, 0x08, 7, 20 },
187 { TWId, 0x17, 7, 21 }, { TWId, 0x03, 7, 22 }, { TWId, 0x04, 7, 23 },
188 { TWId, 0x28, 7, 24 }, { TWId, 0x2b, 7, 25 }, { TWId, 0x13, 7, 26 },
189 { TWId, 0x24, 7, 27 }, { TWId, 0x18, 7, 28 }, { TWId, 0x02, 8, 29 },
190 { TWId, 0x03, 8, 30 }, { TWId, 0x1a, 8, 31 }, { TWId, 0x1b, 8, 32 },
191 { TWId, 0x12, 8, 33 }, { TWId, 0x13, 8, 34 }, { TWId, 0x14, 8, 35 },
192 { TWId, 0x15, 8, 36 }, { TWId, 0x16, 8, 37 }, { TWId, 0x17, 8, 38 },
193 { TWId, 0x28, 8, 39 }, { TWId, 0x29, 8, 40 }, { TWId, 0x2a, 8, 41 },
194 { TWId, 0x2b, 8, 42 }, { TWId, 0x2c, 8, 43 }, { TWId, 0x2d, 8, 44 },
195 { TWId, 0x04, 8, 45 }, { TWId, 0x05, 8, 46 }, { TWId, 0x0a, 8, 47 },
196 { TWId, 0x0b, 8, 48 }, { TWId, 0x52, 8, 49 }, { TWId, 0x53, 8, 50 },
197 { TWId, 0x54, 8, 51 }, { TWId, 0x55, 8, 52 }, { TWId, 0x24, 8, 53 },
198 { TWId, 0x25, 8, 54 }, { TWId, 0x58, 8, 55 }, { TWId, 0x59, 8, 56 },
199 { TWId, 0x5a, 8, 57 }, { TWId, 0x5b, 8, 58 }, { TWId, 0x4a, 8, 59 },
200 { TWId, 0x4b, 8, 60 }, { TWId, 0x32, 8, 61 }, { TWId, 0x33, 8, 62 },
201 { TWId, 0x34, 8, 63 }, { TWId, 0x00, 0, 0 }
231static inline void Ascii85Tuple(
Ascii85Info *ascii85_info,
232 const unsigned char *magick_restrict data)
234#define MaxLineExtent 36L
242 code=((((size_t) data[0] << 8) | (size_t) data[1]) << 16) |
243 ((
size_t) data[2] << 8) | (size_t) data[3];
246 ascii85_info->tuple[0]=
'z';
247 ascii85_info->tuple[1]=
'\0';
250 quantum=85UL*85UL*85UL*85UL;
251 for (i=0; i < 4; i++)
255 ascii85_info->tuple[i]=(char) (x+(
int)
'!');
258 ascii85_info->tuple[4]=(char) ((code % 85L)+(
int)
'!');
259 ascii85_info->tuple[5]=
'\0';
262MagickExport
void Ascii85Initialize(
Image *image)
268 image->ascii85=(
Ascii85Info *) AcquireMagickMemory(
sizeof(*image->ascii85));
270 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
271 (void) memset(image->ascii85,0,
sizeof(*image->ascii85));
272 image->ascii85->line_break=(ssize_t) (MaxLineExtent << 1);
273 image->ascii85->offset=0;
276MagickExport
void Ascii85Flush(
Image *image)
278 assert(image != (
Image *) NULL);
279 assert(image->signature == MagickCoreSignature);
281 if (IsEventLogging() != MagickFalse)
282 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
283 if (image->ascii85->offset > 0)
285 image->ascii85->buffer[image->ascii85->offset]=
'\0';
286 image->ascii85->buffer[image->ascii85->offset+1]=
'\0';
287 image->ascii85->buffer[image->ascii85->offset+2]=
'\0';
288 Ascii85Tuple(image->ascii85,image->ascii85->buffer);
289 (void) WriteBlob(image,(
size_t) image->ascii85->offset+1,
290 (
const unsigned char *) (*image->ascii85->tuple ==
'z' ?
"!!!!" :
291 image->ascii85->tuple));
293 (void) WriteBlobByte(image,
'~');
294 (void) WriteBlobByte(image,
'>');
295 (void) WriteBlobByte(image,
'\n');
298MagickExport
void Ascii85Encode(
Image *image,
const unsigned char code)
309 assert(image != (
Image *) NULL);
310 assert(image->signature == MagickCoreSignature);
312 image->ascii85->buffer[image->ascii85->offset]=code;
313 image->ascii85->offset++;
314 if (image->ascii85->offset < 4)
316 p=image->ascii85->buffer;
317 for (n=image->ascii85->offset; n >= 4; n-=4)
319 Ascii85Tuple(image->ascii85,p);
320 for (q=image->ascii85->tuple; *q !=
'\0'; q++)
322 image->ascii85->line_break--;
323 if ((image->ascii85->line_break < 0) && (*q !=
'%'))
325 (void) WriteBlobByte(image,
'\n');
326 image->ascii85->line_break=2*MaxLineExtent;
328 (void) WriteBlobByte(image,(
unsigned char) *q);
332 image->ascii85->offset=n;
334 for (n=0; n < 4; n++)
335 image->ascii85->buffer[n]=(*p++);
363MagickExport MagickBooleanType HuffmanDecodeImage(
Image *image,
366#define HashSize 1021L
372#define InitializeHashTable(hash,table,a,b) \
375 while (entry->code != 0) \
377 hash[((entry->length+a)*(entry->code+b)) % HashSize]=(HuffmanTable *) entry; \
382#define InputBit(bit) \
384 if ((mask & 0xff) == 0) \
386 byte=ReadBlobByte(image); \
392 bit=(size_t) ((byte & mask) != 0 ? 0x01 : 0x00); \
441 assert(image != (
Image *) NULL);
442 assert(image->signature == MagickCoreSignature);
443 if (IsEventLogging() != MagickFalse)
444 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
445 if (image->blob == (
BlobInfo *) NULL)
446 ThrowBinaryException(BlobError,
"UnableToOpenBlob",image->filename);
447 mb_hash=(
HuffmanTable **) AcquireQuantumMemory(HashSize,
sizeof(*mb_hash));
448 mw_hash=(
HuffmanTable **) AcquireQuantumMemory(HashSize,
sizeof(*mw_hash));
449 scanline=(
unsigned char *) AcquireQuantumMemory((
size_t) image->columns,
453 (scanline == (
unsigned char *) NULL))
456 mb_hash=(
HuffmanTable **) RelinquishMagickMemory(mb_hash);
458 mw_hash=(
HuffmanTable **) RelinquishMagickMemory(mw_hash);
459 if (scanline != (
unsigned char *) NULL)
460 scanline=(
unsigned char *) RelinquishMagickMemory(scanline);
461 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
467 for (i=0; i < HashSize; i++)
472 InitializeHashTable(mw_hash,TWTable,MWHashA,MWHashB);
473 InitializeHashTable(mw_hash,MWTable,MWHashA,MWHashB);
474 InitializeHashTable(mw_hash,EXTable,MWHashA,MWHashB);
475 InitializeHashTable(mb_hash,TBTable,MBHashA,MBHashB);
476 InitializeHashTable(mb_hash,MBTable,MBHashA,MBHashB);
477 InitializeHashTable(mb_hash,EXTable,MBHashA,MBHashB);
485 while (runlength < 11)
487 do { InputBit(bit); }
while ((
int) bit == 0);
488 image->resolution.x=204.0;
489 image->resolution.y=196.0;
490 image->units=PixelsPerInchResolution;
491 image_view=AcquireAuthenticCacheView(image,exception);
492 for (y=0; ((y < (ssize_t) image->rows) && (null_lines < 3)); )
503 memset(scanline,0,
sizeof(*scanline)*image->columns);
517 if (x >= (ssize_t) image->columns)
519 while (runlength < 11)
521 do { InputBit(bit); }
while ((
int) bit == 0);
541 code=(code << 1)+(
size_t) bit;
544 if (bail != MagickFalse)
548 while (runlength < 11)
550 do { InputBit(bit); }
while ((
int) bit == 0);
553 if (color != MagickFalse)
557 entry=mw_hash[((length+MWHashA)*(code+MWHashB)) % HashSize];
563 entry=mb_hash[((length+MBHashA)*(code+MBHashB)) % HashSize];
567 if ((entry->length != length) || (entry->code != code))
574 count+=(ssize_t) entry->count;
575 if ((x+count) > (ssize_t) image->columns)
576 count=(ssize_t) image->columns-x;
579 if (color != MagickFalse)
585 for ( ; count > 0; count--)
586 if ((x >= 0) && (x < (ssize_t) image->columns))
587 scanline[x++]=(
unsigned char) 1;
590 ((color == MagickFalse) ? MagickTrue : MagickFalse);
597 count+=(ssize_t) entry->count;
610 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
611 if (q == (Quantum *) NULL)
613 for (x=0; x < (ssize_t) image->columns; x++)
615 index=(Quantum) (*p++);
616 SetPixelIndex(image,index,q);
617 SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
618 q+=(ptrdiff_t) GetPixelChannels(image);
620 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
622 proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
624 if (proceed == MagickFalse)
628 image_view=DestroyCacheView(image_view);
629 image->rows=(size_t) MagickMax((
size_t) y-3,1);
630 image->compression=FaxCompression;
634 mw_hash=(
HuffmanTable **) RelinquishMagickMemory(mw_hash);
635 mb_hash=(
HuffmanTable **) RelinquishMagickMemory(mb_hash);
636 scanline=(
unsigned char *) RelinquishMagickMemory(scanline);
669MagickExport MagickBooleanType HuffmanEncodeImage(
const ImageInfo *image_info,
672#define HuffmanOutputCode(entry) \
674 mask=one << (entry->length-1); \
677 OutputBit(((entry->code & mask) != 0 ? 1 : 0)); \
682#define OutputBit(count) \
684DisableMSCWarning(4127) \
689 if ((int) (bit & 0xff) == 0) \
691 if (LocaleCompare(image_info->magick,"FAX") == 0) \
692 (void) WriteBlobByte(image,(unsigned char) byte); \
694 Ascii85Encode(image,byte); \
696 bit=(unsigned char) 0x80; \
740 assert(image_info != (
ImageInfo *) NULL);
741 assert(image_info->signature == MagickCoreSignature);
742 assert(image != (
Image *) NULL);
743 assert(image->signature == MagickCoreSignature);
744 if (IsEventLogging() != MagickFalse)
745 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
746 assert(inject_image != (
Image *) NULL);
747 assert(inject_image->signature == MagickCoreSignature);
749 width=inject_image->columns;
750 if (LocaleCompare(image_info->magick,
"FAX") == 0)
751 width=(size_t) MagickMax(inject_image->columns,1728);
752 scanline=(
unsigned char *) AcquireQuantumMemory((
size_t) width+1UL,
754 if (scanline == (
unsigned char *) NULL)
755 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
756 inject_image->filename);
757 (void) memset(scanline,0,width*
sizeof(*scanline));
758 huffman_image=CloneImage(inject_image,0,0,MagickTrue,exception);
759 if (huffman_image == (
Image *) NULL)
761 scanline=(
unsigned char *) RelinquishMagickMemory(scanline);
764 (void) SetImageType(huffman_image,BilevelType,exception);
766 bit=(
unsigned char) 0x80;
767 if (LocaleCompare(image_info->magick,
"FAX") != 0)
768 Ascii85Initialize(image);
774 for (k=0; k < 11; k++)
782 for (y=0; y < (ssize_t) huffman_image->rows; y++)
784 p=GetVirtualPixels(huffman_image,0,y,huffman_image->columns,1,exception);
785 if (p == (
const Quantum *) NULL)
787 for (x=0; x < (ssize_t) huffman_image->columns; x++)
789 *q++=(
unsigned char) (GetPixelIntensity(huffman_image,p) >=
790 ((
double) QuantumRange/2.0) ? 0 : 1);
791 p+=(ptrdiff_t) GetPixelChannels(huffman_image);
797 for (n=(ssize_t) width; n > 0; )
802 for (runlength=0; ((n > 0) && (*q == 0)); n--)
809 if (runlength < 1792)
810 entry=MWTable+((runlength/64)-1);
812 entry=EXTable+(MagickMin((
size_t) runlength,2560)-1792)/64;
813 runlength-=(long) entry->count;
814 HuffmanOutputCode(entry);
816 entry=TWTable+MagickMin((
size_t) runlength,63);
817 HuffmanOutputCode(entry);
823 for (runlength=0; ((*q != 0) && (n > 0)); n--)
830 entry=MBTable+((runlength/64)-1);
831 if (runlength >= 1792)
832 entry=EXTable+(MagickMin((
size_t) runlength,2560)-1792)/64;
833 runlength-=(long) entry->count;
834 HuffmanOutputCode(entry);
836 entry=TBTable+MagickMin((
size_t) runlength,63);
837 HuffmanOutputCode(entry);
843 for (k=0; k < 11; k++)
847 if (GetPreviousImageInList(huffman_image) == (
Image *) NULL)
849 proceed=SetImageProgress(huffman_image,LoadImageTag,
850 (MagickOffsetType) y,huffman_image->rows);
851 if (proceed == MagickFalse)
858 for (i=0; i < 6; i++)
860 for (k=0; k < 11; k++)
867 if (((
int) bit != 0x80) != 0)
869 if (LocaleCompare(image_info->magick,
"FAX") == 0)
870 (void) WriteBlobByte(image,
byte);
872 Ascii85Encode(image,
byte);
874 if (LocaleCompare(image_info->magick,
"FAX") != 0)
876 huffman_image=DestroyImage(huffman_image);
877 scanline=(
unsigned char *) RelinquishMagickMemory(scanline);
912MagickExport MagickBooleanType LZWEncodeImage(
Image *image,
const size_t length,
913 unsigned char *magick_restrict pixels,
ExceptionInfo *exception)
917#define OutputCode(code) \
919 accumulator+=code << (32-code_width-number_bits); \
920 number_bits+=code_width; \
921 while (number_bits >= 8) \
923 (void) WriteBlobByte(image,(unsigned char) (accumulator >> 24)); \
924 accumulator=accumulator << 8; \
929 typedef struct _TableType
956 assert(image != (
Image *) NULL);
957 assert(image->signature == MagickCoreSignature);
958 assert(pixels != (
unsigned char *) NULL);
960 assert(exception->signature == MagickCoreSignature);
961 if (IsEventLogging() != MagickFalse)
962 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
963 table=(TableType *) AcquireQuantumMemory(1UL << 12,
sizeof(*table));
964 if (table == (TableType *) NULL)
965 ThrowBinaryException(ResourceLimitWarning,
"MemoryAllocationFailed",
975 for (index=0; index < 256; index++)
977 table[index].prefix=(-1);
978 table[index].suffix=(ssize_t) index;
979 table[index].next=(-1);
983 last_code=(size_t) pixels[0];
984 for (i=1; i < (ssize_t) length; i++)
989 index=(ssize_t) last_code;
991 if ((table[index].prefix != (ssize_t) last_code) ||
992 (table[index].suffix != (ssize_t) pixels[i]))
993 index=table[index].next;
996 last_code=(size_t) index;
999 if (last_code != (
size_t) index)
1004 OutputCode(last_code);
1005 table[next_index].prefix=(ssize_t) last_code;
1006 table[next_index].suffix=(ssize_t) pixels[i];
1007 table[next_index].next=table[last_code].next;
1008 table[last_code].next=(ssize_t) next_index;
1013 if ((next_index >> code_width) != 0)
1016 if (code_width > 12)
1023 for (index=0; index < 256; index++)
1025 table[index].prefix=(-1);
1026 table[index].suffix=index;
1027 table[index].next=(-1);
1029 next_index=LZWEod+1;
1033 last_code=(size_t) pixels[i];
1039 OutputCode(last_code);
1041 if (number_bits != 0)
1042 (void) WriteBlobByte(image,(
unsigned char) (accumulator >> 24));
1043 table=(TableType *) RelinquishMagickMemory(table);
1077MagickExport MagickBooleanType PackbitsEncodeImage(
Image *image,
1078 const size_t length,
unsigned char *magick_restrict pixels,
1094 assert(image != (
Image *) NULL);
1095 assert(image->signature == MagickCoreSignature);
1096 assert(pixels != (
unsigned char *) NULL);
1097 if (IsEventLogging() != MagickFalse)
1098 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1099 packbits=(
unsigned char *) AcquireQuantumMemory(128UL,
sizeof(*packbits));
1100 if (packbits == (
unsigned char *) NULL)
1101 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
1103 for (i=(ssize_t) length; i != 0; )
1110 (void) WriteBlobByte(image,(
unsigned char) 0);
1111 (void) WriteBlobByte(image,*pixels);
1117 (void) WriteBlobByte(image,(
unsigned char) 1);
1118 (void) WriteBlobByte(image,*pixels);
1119 (void) WriteBlobByte(image,pixels[1]);
1125 if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
1127 (void) WriteBlobByte(image,(
unsigned char) ((256-3)+1));
1128 (void) WriteBlobByte(image,*pixels);
1131 (void) WriteBlobByte(image,(
unsigned char) 2);
1132 (void) WriteBlobByte(image,*pixels);
1133 (void) WriteBlobByte(image,pixels[1]);
1134 (void) WriteBlobByte(image,pixels[2]);
1139 if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
1145 while (((ssize_t) count < i) && (*pixels == *(pixels+count)))
1152 (void) WriteBlobByte(image,(
unsigned char) ((256-count)+1));
1153 (void) WriteBlobByte(image,*pixels);
1161 while ((*(pixels+count) != *(pixels+count+1)) ||
1162 (*(pixels+count+1) != *(pixels+count+2)))
1164 packbits[count+1]=pixels[count];
1166 if (((ssize_t) count >= (i-3)) || (count >= 127))
1170 *packbits=(
unsigned char) (count-1);
1171 for (j=0; j <= (ssize_t) count; j++)
1172 (
void) WriteBlobByte(image,packbits[j]);
1178 (void) WriteBlobByte(image,(
unsigned char) 128);
1179 packbits=(
unsigned char *) RelinquishMagickMemory(packbits);
1183#if defined(MAGICKCORE_ZLIB_DELEGATE)
1217static voidpf AcquireZIPMemory(voidpf context,
unsigned int items,
1221 return((voidpf) AcquireQuantumMemory(items,size));
1224static void RelinquishZIPMemory(voidpf context,voidpf memory)
1227 memory=RelinquishMagickMemory(memory);
1230MagickExport MagickBooleanType ZLIBEncodeImage(
Image *image,
const size_t length,
1231 unsigned char *magick_restrict pixels,
ExceptionInfo *exception)
1248 assert(image != (
Image *) NULL);
1249 assert(image->signature == MagickCoreSignature);
1250 if (IsEventLogging() != MagickFalse)
1251 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1252 compress_packets=(size_t) (1.001*length+12);
1253 compress_pixels=(
unsigned char *) AcquireQuantumMemory(compress_packets,
1254 sizeof(*compress_pixels));
1255 if (compress_pixels == (
unsigned char *) NULL)
1256 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
1258 (void) memset(&stream,0,
sizeof(stream));
1259 stream.next_in=pixels;
1260 stream.avail_in=(
unsigned int) length;
1261 stream.next_out=compress_pixels;
1262 stream.avail_out=(
unsigned int) compress_packets;
1263 stream.zalloc=AcquireZIPMemory;
1264 stream.zfree=RelinquishZIPMemory;
1265 stream.opaque=(voidpf) NULL;
1266 status=deflateInit(&stream,(
int) (image->quality ==
1267 UndefinedCompressionQuality ? 7 : MagickMin(image->quality/10,9)));
1270 status=deflate(&stream,Z_FINISH);
1271 if (status == Z_STREAM_END)
1272 status=deflateEnd(&stream);
1274 (
void) deflateEnd(&stream);
1275 compress_packets=(size_t) stream.total_out;
1278 ThrowBinaryException(CoderError,
"UnableToZipCompressImage",image->filename)
1279 for (i=0; i < (ssize_t) compress_packets; i++)
1280 (
void) WriteBlobByte(image,compress_pixels[i]);
1281 compress_pixels=(
unsigned char *) RelinquishMagickMemory(compress_pixels);
1285MagickExport MagickBooleanType ZLIBEncodeImage(
Image *image,
1286 const size_t magick_unused(length),
unsigned char *magick_unused(pixels),
1289 magick_unreferenced(length);
1290 magick_unreferenced(pixels);
1291 assert(image != (
Image *) NULL);
1292 assert(image->signature == MagickCoreSignature);
1293 if (IsEventLogging() != MagickFalse)
1294 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1295 (void) ThrowMagickException(exception,GetMagickModule(),MissingDelegateError,
1296 "DelegateLibrarySupportNotBuiltIn",
"'%s' (ZIP)",image->filename);
1297 return(MagickFalse);