1 (* zlibpas -- Pascal interface to the zlib data compression library

     2  *

     3  * Copyright (C) 2003 Cosmin Truta.

     4  * Derived from original sources by Bob Dellaca.

     5  * For conditions of distribution and use, see copyright notice in readme.txt

     6  *)

     7 

     8 unit zlibpas;

     9 

    10 interface

    11 

    12 const

    13   ZLIB_VERSION = '1.2.3';

    14 

    15 type

    16   alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;

    17                  cdecl;

    18   free_func  = procedure(opaque, address: Pointer);

    19                  cdecl;

    20 

    21   in_func    = function(opaque: Pointer; var buf: PByte): Integer;

    22                  cdecl;

    23   out_func   = function(opaque: Pointer; buf: PByte; size: Integer): Integer;

    24                  cdecl;

    25 

    26   z_streamp = ^z_stream;

    27   z_stream = packed record

    28     next_in: PChar;       (* next input byte *)

    29     avail_in: Integer;    (* number of bytes available at next_in *)

    30     total_in: LongInt;    (* total nb of input bytes read so far *)

    31 

    32     next_out: PChar;      (* next output byte should be put there *)

    33     avail_out: Integer;   (* remaining free space at next_out *)

    34     total_out: LongInt;   (* total nb of bytes output so far *)

    35 

    36     msg: PChar;           (* last error message, NULL if no error *)

    37     state: Pointer;       (* not visible by applications *)

    38 

    39     zalloc: alloc_func;   (* used to allocate the internal state *)

    40     zfree: free_func;     (* used to free the internal state *)

    41     opaque: Pointer;      (* private data object passed to zalloc and zfree *)

    42 

    43     data_type: Integer;   (* best guess about the data type: ascii or binary *)

    44     adler: LongInt;       (* adler32 value of the uncompressed data *)

    45     reserved: LongInt;    (* reserved for future use *)

    46   end;

    47 

    48 (* constants *)

    49 const

    50   Z_NO_FLUSH      = 0;

    51   Z_PARTIAL_FLUSH = 1;

    52   Z_SYNC_FLUSH    = 2;

    53   Z_FULL_FLUSH    = 3;

    54   Z_FINISH        = 4;

    55 

    56   Z_OK            =  0;

    57   Z_STREAM_END    =  1;

    58   Z_NEED_DICT     =  2;

    59   Z_ERRNO         = -1;

    60   Z_STREAM_ERROR  = -2;

    61   Z_DATA_ERROR    = -3;

    62   Z_MEM_ERROR     = -4;

    63   Z_BUF_ERROR     = -5;

    64   Z_VERSION_ERROR = -6;

    65 

    66   Z_NO_COMPRESSION       =  0;

    67   Z_BEST_SPEED           =  1;

    68   Z_BEST_COMPRESSION     =  9;

    69   Z_DEFAULT_COMPRESSION  = -1;

    70 

    71   Z_FILTERED            = 1;

    72   Z_HUFFMAN_ONLY        = 2;

    73   Z_RLE                 = 3;

    74   Z_DEFAULT_STRATEGY    = 0;

    75 

    76   Z_BINARY   = 0;

    77   Z_ASCII    = 1;

    78   Z_UNKNOWN  = 2;

    79 

    80   Z_DEFLATED = 8;

    81 

    82 (* basic functions *)

    83 function zlibVersion: PChar;

    84 function deflateInit(var strm: z_stream; level: Integer): Integer;

    85 function deflate(var strm: z_stream; flush: Integer): Integer;

    86 function deflateEnd(var strm: z_stream): Integer;

    87 function inflateInit(var strm: z_stream): Integer;

    88 function inflate(var strm: z_stream; flush: Integer): Integer;

    89 function inflateEnd(var strm: z_stream): Integer;

    90 

    91 (* advanced functions *)

    92 function deflateInit2(var strm: z_stream; level, method, windowBits,

    93                       memLevel, strategy: Integer): Integer;

    94 function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;

    95                               dictLength: Integer): Integer;

    96 function deflateCopy(var dest, source: z_stream): Integer;

    97 function deflateReset(var strm: z_stream): Integer;

    98 function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;

    99 function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;

   100 function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;

   101 function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;

   102 function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;

   103                               dictLength: Integer): Integer;

   104 function inflateSync(var strm: z_stream): Integer;

   105 function inflateCopy(var dest, source: z_stream): Integer;

   106 function inflateReset(var strm: z_stream): Integer;

   107 function inflateBackInit(var strm: z_stream;

   108                          windowBits: Integer; window: PChar): Integer;

   109 function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;

   110                      out_fn: out_func; out_desc: Pointer): Integer;

   111 function inflateBackEnd(var strm: z_stream): Integer;

   112 function zlibCompileFlags: LongInt;

   113 

   114 (* utility functions *)

   115 function compress(dest: PChar; var destLen: LongInt;

   116                   const source: PChar; sourceLen: LongInt): Integer;

   117 function compress2(dest: PChar; var destLen: LongInt;

   118                   const source: PChar; sourceLen: LongInt;

   119                   level: Integer): Integer;

   120 function compressBound(sourceLen: LongInt): LongInt;

   121 function uncompress(dest: PChar; var destLen: LongInt;

   122                     const source: PChar; sourceLen: LongInt): Integer;

   123 

   124 (* checksum functions *)

   125 function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;

   126 function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;

   127 

   128 (* various hacks, don't look :) *)

   129 function deflateInit_(var strm: z_stream; level: Integer;

   130                       const version: PChar; stream_size: Integer): Integer;

   131 function inflateInit_(var strm: z_stream; const version: PChar;

   132                       stream_size: Integer): Integer;

   133 function deflateInit2_(var strm: z_stream;

   134                        level, method, windowBits, memLevel, strategy: Integer;

   135                        const version: PChar; stream_size: Integer): Integer;

   136 function inflateInit2_(var strm: z_stream; windowBits: Integer;

   137                        const version: PChar; stream_size: Integer): Integer;

   138 function inflateBackInit_(var strm: z_stream;

   139                           windowBits: Integer; window: PChar;

   140                           const version: PChar; stream_size: Integer): Integer;

   141 

   142 

   143 implementation

   144 

   145 {$L adler32.obj}

   146 {$L compress.obj}

   147 {$L crc32.obj}

   148 {$L deflate.obj}

   149 {$L infback.obj}

   150 {$L inffast.obj}

   151 {$L inflate.obj}

   152 {$L inftrees.obj}

   153 {$L trees.obj}

   154 {$L uncompr.obj}

   155 {$L zutil.obj}

   156 

   157 function adler32; external;

   158 function compress; external;

   159 function compress2; external;

   160 function compressBound; external;

   161 function crc32; external;

   162 function deflate; external;

   163 function deflateBound; external;

   164 function deflateCopy; external;

   165 function deflateEnd; external;

   166 function deflateInit_; external;

   167 function deflateInit2_; external;

   168 function deflateParams; external;

   169 function deflatePrime; external;

   170 function deflateReset; external;

   171 function deflateSetDictionary; external;

   172 function inflate; external;

   173 function inflateBack; external;

   174 function inflateBackEnd; external;

   175 function inflateBackInit_; external;

   176 function inflateCopy; external;

   177 function inflateEnd; external;

   178 function inflateInit_; external;

   179 function inflateInit2_; external;

   180 function inflateReset; external;

   181 function inflateSetDictionary; external;

   182 function inflateSync; external;

   183 function uncompress; external;

   184 function zlibCompileFlags; external;

   185 function zlibVersion; external;

   186 

   187 function deflateInit(var strm: z_stream; level: Integer): Integer;

   188 begin

   189   Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));

   190 end;

   191 

   192 function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,

   193                       strategy: Integer): Integer;

   194 begin

   195   Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,

   196                           ZLIB_VERSION, sizeof(z_stream));

   197 end;

   198 

   199 function inflateInit(var strm: z_stream): Integer;

   200 begin

   201   Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));

   202 end;

   203 

   204 function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;

   205 begin

   206   Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));

   207 end;

   208 

   209 function inflateBackInit(var strm: z_stream;

   210                          windowBits: Integer; window: PChar): Integer;

   211 begin

   212   Result := inflateBackInit_(strm, windowBits, window,

   213                              ZLIB_VERSION, sizeof(z_stream));

   214 end;

   215 

   216 function _malloc(Size: Integer): Pointer; cdecl;

   217 begin

   218   GetMem(Result, Size);

   219 end;

   220 

   221 procedure _free(Block: Pointer); cdecl;

   222 begin

   223   FreeMem(Block);

   224 end;

   225 

   226 procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;

   227 begin

   228   FillChar(P^, count, B);

   229 end;

   230 

   231 procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;

   232 begin

   233   Move(source^, dest^, count);

   234 end;

   235 

   236 end.