1 |
Unit Zlib;
|
2 |
|
3 |
|
4 |
{ Original:
|
5 |
zlib.h -- interface of the 'zlib' general purpose compression library
|
6 |
version 1.1.0, Feb 24th, 1998
|
7 |
|
8 |
Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
|
9 |
|
10 |
This software is provided 'as-is', without any express or implied
|
11 |
warranty. In no event will the authors be held liable for any damages
|
12 |
arising from the use of this software.
|
13 |
|
14 |
Permission is granted to anyone to use this software for any purpose,
|
15 |
including commercial applications, and to alter it and redistribute it
|
16 |
freely, subject to the following restrictions:
|
17 |
|
18 |
1. The origin of this software must not be misrepresented; you must not
|
19 |
claim that you wrote the original software. If you use this software
|
20 |
in a product, an acknowledgment in the product documentation would be
|
21 |
appreciated but is not required.
|
22 |
2. Altered source versions must be plainly marked as such, and must not be
|
23 |
misrepresented as being the original software.
|
24 |
3. This notice may not be removed or altered from any source distribution.
|
25 |
|
26 |
Jean-loup Gailly Mark Adler
|
27 |
jloup@gzip.org madler@alumni.caltech.edu
|
28 |
|
29 |
|
30 |
The data format used by the zlib library is described by RFCs (Request for
|
31 |
Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
|
32 |
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
|
33 |
|
34 |
|
35 |
Pascal tranlastion
|
36 |
Copyright (C) 1998 by Jacques Nomssi Nzali
|
37 |
For conditions of distribution and use, see copyright notice in readme.txt
|
38 |
}
|
39 |
|
40 |
interface
|
41 |
|
42 |
{$I zconf.inc}
|
43 |
|
44 |
uses
|
45 |
zutil;
|
46 |
|
47 |
{ zconf.h -- configuration of the zlib compression library }
|
48 |
{ zutil.c -- target dependent utility functions for the compression library }
|
49 |
|
50 |
{ The 'zlib' compression library provides in-memory compression and
|
51 |
decompression functions, including integrity checks of the uncompressed
|
52 |
data. This version of the library supports only one compression method
|
53 |
(deflation) but other algorithms will be added later and will have the same
|
54 |
stream interface.
|
55 |
|
56 |
Compression can be done in a single step if the buffers are large
|
57 |
enough (for example if an input file is mmap'ed), or can be done by
|
58 |
repeated calls of the compression function. In the latter case, the
|
59 |
application must provide more input and/or consume the output
|
60 |
(providing more output space) before each call.
|
61 |
|
62 |
The library also supports reading and writing files in gzip (.gz) format
|
63 |
with an interface similar to that of stdio.
|
64 |
|
65 |
The library does not install any signal handler. The decoder checks
|
66 |
the consistency of the compressed data, so the library should never
|
67 |
crash even in case of corrupted input. }
|
68 |
|
69 |
|
70 |
|
71 |
{ Compile with -DMAXSEG_64K if the alloc function cannot allocate more
|
72 |
than 64k bytes at a time (needed on systems with 16-bit int). }
|
73 |
|
74 |
{ Maximum value for memLevel in deflateInit2 }
|
75 |
{$ifdef MAXSEG_64K}
|
76 |
{$IFDEF VER70}
|
77 |
const
|
78 |
MAX_MEM_LEVEL = 7;
|
79 |
DEF_MEM_LEVEL = MAX_MEM_LEVEL; { default memLevel }
|
80 |
{$ELSE}
|
81 |
const
|
82 |
MAX_MEM_LEVEL = 8;
|
83 |
DEF_MEM_LEVEL = MAX_MEM_LEVEL; { default memLevel }
|
84 |
{$ENDIF}
|
85 |
{$else}
|
86 |
const
|
87 |
MAX_MEM_LEVEL = 9;
|
88 |
DEF_MEM_LEVEL = 8; { if MAX_MEM_LEVEL > 8 }
|
89 |
{$endif}
|
90 |
|
91 |
{ Maximum value for windowBits in deflateInit2 and inflateInit2 }
|
92 |
const
|
93 |
{$IFDEF VER70}
|
94 |
MAX_WBITS = 14; { 32K LZ77 window }
|
95 |
{$ELSE}
|
96 |
MAX_WBITS = 15; { 32K LZ77 window }
|
97 |
{$ENDIF}
|
98 |
|
99 |
{ default windowBits for decompression. MAX_WBITS is for compression only }
|
100 |
const
|
101 |
DEF_WBITS = MAX_WBITS;
|
102 |
|
103 |
{ The memory requirements for deflate are (in bytes):
|
104 |
1 shl (windowBits+2) + 1 shl (memLevel+9)
|
105 |
that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
|
106 |
plus a few kilobytes for small objects. For example, if you want to reduce
|
107 |
the default memory requirements from 256K to 128K, compile with
|
108 |
DMAX_WBITS=14 DMAX_MEM_LEVEL=7
|
109 |
Of course this will generally degrade compression (there's no free lunch).
|
110 |
|
111 |
The memory requirements for inflate are (in bytes) 1 shl windowBits
|
112 |
that is, 32K for windowBits=15 (default value) plus a few kilobytes
|
113 |
for small objects. }
|
114 |
|
115 |
|
116 |
{ Huffman code lookup table entry--this entry is four bytes for machines
|
117 |
that have 16-bit pointers (e.g. PC's in the small or medium model). }
|
118 |
|
119 |
type
|
120 |
pInflate_huft = ^inflate_huft;
|
121 |
inflate_huft = Record
|
122 |
Exop, { number of extra bits or operation }
|
123 |
bits : Byte; { number of bits in this code or subcode }
|
124 |
{pad : uInt;} { pad structure to a power of 2 (4 bytes for }
|
125 |
{ 16-bit, 8 bytes for 32-bit int's) }
|
126 |
base : uInt; { literal, length base, or distance base }
|
127 |
{ or table offset }
|
128 |
End;
|
129 |
|
130 |
type
|
131 |
huft_field = Array[0..(MaxMemBlock div SizeOf(inflate_huft))-1] of inflate_huft;
|
132 |
huft_ptr = ^huft_field;
|
133 |
type
|
134 |
ppInflate_huft = ^pInflate_huft;
|
135 |
|
136 |
type
|
137 |
inflate_codes_mode = ( { waiting for "i:"=input, "o:"=output, "x:"=nothing }
|
138 |
START, { x: set up for LEN }
|
139 |
LEN, { i: get length/literal/eob next }
|
140 |
LENEXT, { i: getting length extra (have base) }
|
141 |
DIST, { i: get distance next }
|
142 |
DISTEXT, { i: getting distance extra }
|
143 |
COPY, { o: copying bytes in window, waiting for space }
|
144 |
LIT, { o: got literal, waiting for output space }
|
145 |
WASH, { o: got eob, possibly still output waiting }
|
146 |
ZEND, { x: got eob and all data flushed }
|
147 |
BADCODE); { x: got error }
|
148 |
|
149 |
{ inflate codes private state }
|
150 |
type
|
151 |
pInflate_codes_state = ^inflate_codes_state;
|
152 |
inflate_codes_state = record
|
153 |
|
154 |
mode : inflate_codes_mode; { current inflate_codes mode }
|
155 |
|
156 |
{ mode dependent information }
|
157 |
len : uInt;
|
158 |
sub : record { submode }
|
159 |
Case Byte of
|
160 |
0:(code : record { if LEN or DIST, where in tree }
|
161 |
tree : pInflate_huft; { pointer into tree }
|
162 |
need : uInt; { bits needed }
|
163 |
end);
|
164 |
1:(lit : uInt); { if LIT, literal }
|
165 |
2:(copy: record { if EXT or COPY, where and how much }
|
166 |
get : uInt; { bits to get for extra }
|
167 |
dist : uInt; { distance back to copy from }
|
168 |
end);
|
169 |
end;
|
170 |
|
171 |
{ mode independent information }
|
172 |
lbits : Byte; { ltree bits decoded per branch }
|
173 |
dbits : Byte; { dtree bits decoder per branch }
|
174 |
ltree : pInflate_huft; { literal/length/eob tree }
|
175 |
dtree : pInflate_huft; { distance tree }
|
176 |
end;
|
177 |
|
178 |
type
|
179 |
check_func = function(check : uLong;
|
180 |
buf : pBytef;
|
181 |
{const buf : array of byte;}
|
182 |
len : uInt) : uLong;
|
183 |
type
|
184 |
inflate_block_mode =
|
185 |
(ZTYPE, { get type bits (3, including end bit) }
|
186 |
LENS, { get lengths for stored }
|
187 |
STORED, { processing stored block }
|
188 |
TABLE, { get table lengths }
|
189 |
BTREE, { get bit lengths tree for a dynamic block }
|
190 |
DTREE, { get length, distance trees for a dynamic block }
|
191 |
CODES, { processing fixed or dynamic block }
|
192 |
DRY, { output remaining window bytes }
|
193 |
BLKDONE, { finished last block, done }
|
194 |
BLKBAD); { got a data error--stuck here }
|
195 |
|
196 |
type
|
197 |
pInflate_blocks_state = ^inflate_blocks_state;
|
198 |
|
199 |
{ inflate blocks semi-private state }
|
200 |
inflate_blocks_state = record
|
201 |
|
202 |
mode : inflate_block_mode; { current inflate_block mode }
|
203 |
|
204 |
{ mode dependent information }
|
205 |
sub : record { submode }
|
206 |
case Byte of
|
207 |
0:(left : uInt); { if STORED, bytes left to copy }
|
208 |
1:(trees : record { if DTREE, decoding info for trees }
|
209 |
table : uInt; { table lengths (14 bits) }
|
210 |
index : uInt; { index into blens (or border) }
|
211 |
blens : PuIntArray; { bit lengths of codes }
|
212 |
bb : uInt; { bit length tree depth }
|
213 |
tb : pInflate_huft; { bit length decoding tree }
|
214 |
end);
|
215 |
2:(decode : record { if CODES, current state }
|
216 |
tl : pInflate_huft;
|
217 |
td : pInflate_huft; { trees to free }
|
218 |
codes : pInflate_codes_state;
|
219 |
end);
|
220 |
end;
|
221 |
last : boolean; { true if this block is the last block }
|
222 |
|
223 |
{ mode independent information }
|
224 |
bitk : uInt; { bits in bit buffer }
|
225 |
bitb : uLong; { bit buffer }
|
226 |
hufts : huft_ptr; {pInflate_huft;} { single malloc for tree space }
|
227 |
window : pBytef; { sliding window }
|
228 |
zend : pBytef; { one byte after sliding window }
|
229 |
read : pBytef; { window read pointer }
|
230 |
write : pBytef; { window write pointer }
|
231 |
checkfn : check_func; { check function }
|
232 |
check : uLong; { check on output }
|
233 |
end;
|
234 |
|
235 |
type
|
236 |
inflate_mode = (
|
237 |
METHOD, { waiting for method byte }
|
238 |
FLAG, { waiting for flag byte }
|
239 |
DICT4, { four dictionary check bytes to go }
|
240 |
DICT3, { three dictionary check bytes to go }
|
241 |
DICT2, { two dictionary check bytes to go }
|
242 |
DICT1, { one dictionary check byte to go }
|
243 |
DICT0, { waiting for inflateSetDictionary }
|
244 |
BLOCKS, { decompressing blocks }
|
245 |
CHECK4, { four check bytes to go }
|
246 |
CHECK3, { three check bytes to go }
|
247 |
CHECK2, { two check bytes to go }
|
248 |
CHECK1, { one check byte to go }
|
249 |
DONE, { finished check, done }
|
250 |
BAD); { got an error--stay here }
|
251 |
|
252 |
{ inflate private state }
|
253 |
type
|
254 |
pInternal_state = ^internal_state; { or point to a deflate_state record }
|
255 |
internal_state = record
|
256 |
|
257 |
mode : inflate_mode; { current inflate mode }
|
258 |
|
259 |
{ mode dependent information }
|
260 |
sub : record { submode }
|
261 |
case byte of
|
262 |
0:(method : uInt); { if FLAGS, method byte }
|
263 |
1:(check : record { if CHECK, check values to compare }
|
264 |
was : uLong; { computed check value }
|
265 |
need : uLong; { stream check value }
|
266 |
end);
|
267 |
2:(marker : uInt); { if BAD, inflateSync's marker bytes count }
|
268 |
end;
|
269 |
|
270 |
{ mode independent information }
|
271 |
nowrap : boolean; { flag for no wrapper }
|
272 |
wbits : uInt; { log2(window size) (8..15, defaults to 15) }
|
273 |
blocks : pInflate_blocks_state; { current inflate_blocks state }
|
274 |
end;
|
275 |
|
276 |
type
|
277 |
alloc_func = function(opaque : voidpf; items : uInt; size : uInt) : voidpf;
|
278 |
free_func = procedure(opaque : voidpf; address : voidpf);
|
279 |
|
280 |
type
|
281 |
z_streamp = ^z_stream;
|
282 |
z_stream = record
|
283 |
next_in : pBytef; { next input byte }
|
284 |
avail_in : uInt; { number of bytes available at next_in }
|
285 |
total_in : uLong; { total nb of input bytes read so far }
|
286 |
|
287 |
next_out : pBytef; { next output byte should be put there }
|
288 |
avail_out : uInt; { remaining free space at next_out }
|
289 |
total_out : uLong; { total nb of bytes output so far }
|
290 |
|
291 |
msg : string[255]; { last error message, '' if no error }
|
292 |
state : pInternal_state; { not visible by applications }
|
293 |
|
294 |
zalloc : alloc_func; { used to allocate the internal state }
|
295 |
zfree : free_func; { used to free the internal state }
|
296 |
opaque : voidpf; { private data object passed to zalloc and zfree }
|
297 |
|
298 |
data_type : int; { best guess about the data type: ascii or binary }
|
299 |
adler : uLong; { adler32 value of the uncompressed data }
|
300 |
reserved : uLong; { reserved for future use }
|
301 |
end;
|
302 |
|
303 |
|
304 |
{ The application must update next_in and avail_in when avail_in has
|
305 |
dropped to zero. It must update next_out and avail_out when avail_out
|
306 |
has dropped to zero. The application must initialize zalloc, zfree and
|
307 |
opaque before calling the init function. All other fields are set by the
|
308 |
compression library and must not be updated by the application.
|
309 |
|
310 |
The opaque value provided by the application will be passed as the first
|
311 |
parameter for calls of zalloc and zfree. This can be useful for custom
|
312 |
memory management. The compression library attaches no meaning to the
|
313 |
opaque value.
|
314 |
|
315 |
zalloc must return Z_NULL if there is not enough memory for the object.
|
316 |
On 16-bit systems, the functions zalloc and zfree must be able to allocate
|
317 |
exactly 65536 bytes, but will not be required to allocate more than this
|
318 |
if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
|
319 |
pointers returned by zalloc for objects of exactly 65536 bytes *must*
|
320 |
have their offset normalized to zero. The default allocation function
|
321 |
provided by this library ensures this (see zutil.c). To reduce memory
|
322 |
requirements and avoid any allocation of 64K objects, at the expense of
|
323 |
compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
|
324 |
|
325 |
The fields total_in and total_out can be used for statistics or
|
326 |
progress reports. After compression, total_in holds the total size of
|
327 |
the uncompressed data and may be saved for use in the decompressor
|
328 |
(particularly if the decompressor wants to decompress everything in
|
329 |
a single step). }
|
330 |
|
331 |
const { constants }
|
332 |
Z_NO_FLUSH = 0;
|
333 |
Z_PARTIAL_FLUSH = 1;
|
334 |
Z_SYNC_FLUSH = 2;
|
335 |
Z_FULL_FLUSH = 3;
|
336 |
Z_FINISH = 4;
|
337 |
{ Allowed flush values; see deflate() below for details }
|
338 |
|
339 |
Z_OK = 0;
|
340 |
Z_STREAM_END = 1;
|
341 |
Z_NEED_DICT = 2;
|
342 |
Z_ERRNO = (-1);
|
343 |
Z_STREAM_ERROR = (-2);
|
344 |
Z_DATA_ERROR = (-3);
|
345 |
Z_MEM_ERROR = (-4);
|
346 |
Z_BUF_ERROR = (-5);
|
347 |
Z_VERSION_ERROR = (-6);
|
348 |
{ Return codes for the compression/decompression functions. Negative
|
349 |
values are errors, positive values are used for special but normal events.}
|
350 |
|
351 |
Z_NO_COMPRESSION = 0;
|
352 |
Z_BEST_SPEED = 1;
|
353 |
Z_BEST_COMPRESSION = 9;
|
354 |
Z_DEFAULT_COMPRESSION = (-1);
|
355 |
{ compression levels }
|
356 |
|
357 |
Z_FILTERED = 1;
|
358 |
Z_HUFFMAN_ONLY = 2;
|
359 |
Z_DEFAULT_STRATEGY = 0;
|
360 |
{ compression strategy; see deflateInit2() below for details }
|
361 |
|
362 |
Z_BINARY = 0;
|
363 |
Z_ASCII = 1;
|
364 |
Z_UNKNOWN = 2;
|
365 |
{ Possible values of the data_type field }
|
366 |
|
367 |
Z_DEFLATED = 8;
|
368 |
{ The deflate compression method (the only one supported in this version) }
|
369 |
|
370 |
Z_NULL = NIL; { for initializing zalloc, zfree, opaque }
|
371 |
|
372 |
{$IFDEF GZIO}
|
373 |
var
|
374 |
errno : int;
|
375 |
{$ENDIF}
|
376 |
|
377 |
{ common constants }
|
378 |
|
379 |
|
380 |
{ The three kinds of block type }
|
381 |
const
|
382 |
STORED_BLOCK = 0;
|
383 |
STATIC_TREES = 1;
|
384 |
DYN_TREES = 2;
|
385 |
{ The minimum and maximum match lengths }
|
386 |
const
|
387 |
MIN_MATCH = 3;
|
388 |
{$ifdef MAX_MATCH_IS_258}
|
389 |
MAX_MATCH = 258;
|
390 |
{$else}
|
391 |
MAX_MATCH = ??; { deliberate syntax error }
|
392 |
{$endif}
|
393 |
|
394 |
const
|
395 |
PRESET_DICT = $20; { preset dictionary flag in zlib header }
|
396 |
|
397 |
|
398 |
{$IFDEF DEBUG}
|
399 |
procedure Assert(cond : boolean; msg : string);
|
400 |
{$ENDIF}
|
401 |
|
402 |
procedure Trace(x : string);
|
403 |
procedure Tracev(x : string);
|
404 |
procedure Tracevv(x : string);
|
405 |
procedure Tracevvv(x : string);
|
406 |
procedure Tracec(c : boolean; x : string);
|
407 |
procedure Tracecv(c : boolean; x : string);
|
408 |
|
409 |
function zlibVersion : string;
|
410 |
{ The application can compare zlibVersion and ZLIB_VERSION for consistency.
|
411 |
If the first character differs, the library code actually used is
|
412 |
not compatible with the zlib.h header file used by the application.
|
413 |
This check is automatically made by deflateInit and inflateInit. }
|
414 |
|
415 |
function zError(err : int) : string;
|
416 |
|
417 |
function ZALLOC (var strm : z_stream; items : uInt; size : uInt) : voidpf;
|
418 |
|
419 |
procedure ZFREE (var strm : z_stream; ptr : voidpf);
|
420 |
|
421 |
procedure TRY_FREE (var strm : z_stream; ptr : voidpf);
|
422 |
|
423 |
const
|
424 |
ZLIB_VERSION : string[10] = '1.1.2';
|
425 |
|
426 |
const
|
427 |
z_errbase = Z_NEED_DICT;
|
428 |
z_errmsg : Array[0..9] of string[21] = { indexed by 2-zlib_error }
|
429 |
('need dictionary', { Z_NEED_DICT 2 }
|
430 |
'stream end', { Z_STREAM_END 1 }
|
431 |
'', { Z_OK 0 }
|
432 |
'file error', { Z_ERRNO (-1) }
|
433 |
'stream error', { Z_STREAM_ERROR (-2) }
|
434 |
'data error', { Z_DATA_ERROR (-3) }
|
435 |
'insufficient memory', { Z_MEM_ERROR (-4) }
|
436 |
'buffer error', { Z_BUF_ERROR (-5) }
|
437 |
'incompatible version',{ Z_VERSION_ERROR (-6) }
|
438 |
'');
|
439 |
const
|
440 |
z_verbose : int = 1;
|
441 |
|
442 |
{$IFDEF DEBUG}
|
443 |
procedure z_error (m : string);
|
444 |
{$ENDIF}
|
445 |
|
446 |
implementation
|
447 |
|
448 |
function zError(err : int) : string;
|
449 |
begin
|
450 |
zError := z_errmsg[Z_NEED_DICT-err];
|
451 |
end;
|
452 |
|
453 |
function zlibVersion : string;
|
454 |
begin
|
455 |
zlibVersion := ZLIB_VERSION;
|
456 |
end;
|
457 |
|
458 |
procedure z_error (m : string);
|
459 |
begin
|
460 |
WriteLn(output, m);
|
461 |
Write('Zlib - Halt...');
|
462 |
ReadLn;
|
463 |
Halt(1);
|
464 |
end;
|
465 |
|
466 |
procedure Assert(cond : boolean; msg : string);
|
467 |
begin
|
468 |
if not cond then
|
469 |
z_error(msg);
|
470 |
end;
|
471 |
|
472 |
procedure Trace(x : string);
|
473 |
begin
|
474 |
WriteLn(x);
|
475 |
end;
|
476 |
|
477 |
procedure Tracev(x : string);
|
478 |
begin
|
479 |
if (z_verbose>0) then
|
480 |
WriteLn(x);
|
481 |
end;
|
482 |
|
483 |
procedure Tracevv(x : string);
|
484 |
begin
|
485 |
if (z_verbose>1) then
|
486 |
WriteLn(x);
|
487 |
end;
|
488 |
|
489 |
procedure Tracevvv(x : string);
|
490 |
begin
|
491 |
if (z_verbose>2) then
|
492 |
WriteLn(x);
|
493 |
end;
|
494 |
|
495 |
procedure Tracec(c : boolean; x : string);
|
496 |
begin
|
497 |
if (z_verbose>0) and (c) then
|
498 |
WriteLn(x);
|
499 |
end;
|
500 |
|
501 |
procedure Tracecv(c : boolean; x : string);
|
502 |
begin
|
503 |
if (z_verbose>1) and c then
|
504 |
WriteLn(x);
|
505 |
end;
|
506 |
|
507 |
function ZALLOC (var strm : z_stream; items : uInt; size : uInt) : voidpf;
|
508 |
begin
|
509 |
ZALLOC := strm.zalloc(strm.opaque, items, size);
|
510 |
end;
|
511 |
|
512 |
procedure ZFREE (var strm : z_stream; ptr : voidpf);
|
513 |
begin
|
514 |
strm.zfree(strm.opaque, ptr);
|
515 |
end;
|
516 |
|
517 |
procedure TRY_FREE (var strm : z_stream; ptr : voidpf);
|
518 |
begin
|
519 |
{if @strm <> Z_NULL then}
|
520 |
strm.zfree(strm.opaque, ptr);
|
521 |
end;
|
522 |
|
523 |
end. |