← Back to branch summary

~ubuntu-branches/ubuntu/raring/smplayer/raring

« back to all changes in this revision

Viewing changes to zlib/contrib/pascal/zlibpas.pas

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2013-02-12 03:00:21 UTC
  • mfrom: (20.1.2 experimental)
  • Revision ID: package-import@ubuntu.com-20130212030021-q5mg053fru2u6zl8
Tags: 0.8.3-1
http://bugs.debian.org/698300
* Team upload.
* New upstream release. (Closes: #698300)

Show diffs side-by-side

added added

removed removed

Lines of Context:
zlib/contrib/pascal/zlibpas.pas
 
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.7';
 
14
  ZLIB_VERNUM  = $1270;
 
15
 
 
16
type
 
17
  alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;
 
18
                 cdecl;
 
19
  free_func  = procedure(opaque, address: Pointer);
 
20
                 cdecl;
 
21
 
 
22
  in_func    = function(opaque: Pointer; var buf: PByte): Integer;
 
23
                 cdecl;
 
24
  out_func   = function(opaque: Pointer; buf: PByte; size: Integer): Integer;
 
25
                 cdecl;
 
26
 
 
27
  z_streamp = ^z_stream;
 
28
  z_stream = packed record
 
29
    next_in: PChar;       (* next input byte *)
 
30
    avail_in: Integer;    (* number of bytes available at next_in *)
 
31
    total_in: LongInt;    (* total nb of input bytes read so far *)
 
32
 
 
33
    next_out: PChar;      (* next output byte should be put there *)
 
34
    avail_out: Integer;   (* remaining free space at next_out *)
 
35
    total_out: LongInt;   (* total nb of bytes output so far *)
 
36
 
 
37
    msg: PChar;           (* last error message, NULL if no error *)
 
38
    state: Pointer;       (* not visible by applications *)
 
39
 
 
40
    zalloc: alloc_func;   (* used to allocate the internal state *)
 
41
    zfree: free_func;     (* used to free the internal state *)
 
42
    opaque: Pointer;      (* private data object passed to zalloc and zfree *)
 
43
 
 
44
    data_type: Integer;   (* best guess about the data type: ascii or binary *)
 
45
    adler: LongInt;       (* adler32 value of the uncompressed data *)
 
46
    reserved: LongInt;    (* reserved for future use *)
 
47
  end;
 
48
 
 
49
  gz_headerp = ^gz_header;
 
50
  gz_header = packed record
 
51
    text: Integer;        (* true if compressed data believed to be text *)
 
52
    time: LongInt;        (* modification time *)
 
53
    xflags: Integer;      (* extra flags (not used when writing a gzip file) *)
 
54
    os: Integer;          (* operating system *)
 
55
    extra: PChar;         (* pointer to extra field or Z_NULL if none *)
 
56
    extra_len: Integer;   (* extra field length (valid if extra != Z_NULL) *)
 
57
    extra_max: Integer;   (* space at extra (only when reading header) *)
 
58
    name: PChar;          (* pointer to zero-terminated file name or Z_NULL *)
 
59
    name_max: Integer;    (* space at name (only when reading header) *)
 
60
    comment: PChar;       (* pointer to zero-terminated comment or Z_NULL *)
 
61
    comm_max: Integer;    (* space at comment (only when reading header) *)
 
62
    hcrc: Integer;        (* true if there was or will be a header crc *)
 
63
    done: Integer;        (* true when done reading gzip header *)
 
64
  end;
 
65
 
 
66
(* constants *)
 
67
const
 
68
  Z_NO_FLUSH      = 0;
 
69
  Z_PARTIAL_FLUSH = 1;
 
70
  Z_SYNC_FLUSH    = 2;
 
71
  Z_FULL_FLUSH    = 3;
 
72
  Z_FINISH        = 4;
 
73
  Z_BLOCK         = 5;
 
74
  Z_TREES         = 6;
 
75
 
 
76
  Z_OK            =  0;
 
77
  Z_STREAM_END    =  1;
 
78
  Z_NEED_DICT     =  2;
 
79
  Z_ERRNO         = -1;
 
80
  Z_STREAM_ERROR  = -2;
 
81
  Z_DATA_ERROR    = -3;
 
82
  Z_MEM_ERROR     = -4;
 
83
  Z_BUF_ERROR     = -5;
 
84
  Z_VERSION_ERROR = -6;
 
85
 
 
86
  Z_NO_COMPRESSION       =  0;
 
87
  Z_BEST_SPEED           =  1;
 
88
  Z_BEST_COMPRESSION     =  9;
 
89
  Z_DEFAULT_COMPRESSION  = -1;
 
90
 
 
91
  Z_FILTERED            = 1;
 
92
  Z_HUFFMAN_ONLY        = 2;
 
93
  Z_RLE                 = 3;
 
94
  Z_FIXED               = 4;
 
95
  Z_DEFAULT_STRATEGY    = 0;
 
96
 
 
97
  Z_BINARY   = 0;
 
98
  Z_TEXT     = 1;
 
99
  Z_ASCII    = 1;
 
100
  Z_UNKNOWN  = 2;
 
101
 
 
102
  Z_DEFLATED = 8;
 
103
 
 
104
(* basic functions *)
 
105
function zlibVersion: PChar;
 
106
function deflateInit(var strm: z_stream; level: Integer): Integer;
 
107
function deflate(var strm: z_stream; flush: Integer): Integer;
 
108
function deflateEnd(var strm: z_stream): Integer;
 
109
function inflateInit(var strm: z_stream): Integer;
 
110
function inflate(var strm: z_stream; flush: Integer): Integer;
 
111
function inflateEnd(var strm: z_stream): Integer;
 
112
 
 
113
(* advanced functions *)
 
114
function deflateInit2(var strm: z_stream; level, method, windowBits,
 
115
                      memLevel, strategy: Integer): Integer;
 
116
function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;
 
117
                              dictLength: Integer): Integer;
 
118
function deflateCopy(var dest, source: z_stream): Integer;
 
119
function deflateReset(var strm: z_stream): Integer;
 
120
function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;
 
121
function deflateTune(var strm: z_stream; good_length, max_lazy, nice_length, max_chain: Integer): Integer;
 
122
function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
 
123
function deflatePending(var strm: z_stream; var pending: Integer; var bits: Integer): Integer;
 
124
function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
 
125
function deflateSetHeader(var strm: z_stream; head: gz_header): Integer;
 
126
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
 
127
function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;
 
128
                              dictLength: Integer): Integer;
 
129
function inflateSync(var strm: z_stream): Integer;
 
130
function inflateCopy(var dest, source: z_stream): Integer;
 
131
function inflateReset(var strm: z_stream): Integer;
 
132
function inflateReset2(var strm: z_stream; windowBits: Integer): Integer;
 
133
function inflatePrime(var strm: z_stream; bits, value: Integer): Integer;
 
134
function inflateMark(var strm: z_stream): LongInt;
 
135
function inflateGetHeader(var strm: z_stream; var head: gz_header): Integer;
 
136
function inflateBackInit(var strm: z_stream;
 
137
                         windowBits: Integer; window: PChar): Integer;
 
138
function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
 
139
                     out_fn: out_func; out_desc: Pointer): Integer;
 
140
function inflateBackEnd(var strm: z_stream): Integer;
 
141
function zlibCompileFlags: LongInt;
 
142
 
 
143
(* utility functions *)
 
144
function compress(dest: PChar; var destLen: LongInt;
 
145
                  const source: PChar; sourceLen: LongInt): Integer;
 
146
function compress2(dest: PChar; var destLen: LongInt;
 
147
                  const source: PChar; sourceLen: LongInt;
 
148
                  level: Integer): Integer;
 
149
function compressBound(sourceLen: LongInt): LongInt;
 
150
function uncompress(dest: PChar; var destLen: LongInt;
 
151
                    const source: PChar; sourceLen: LongInt): Integer;
 
152
 
 
153
(* checksum functions *)
 
154
function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;
 
155
function adler32_combine(adler1, adler2, len2: LongInt): LongInt;
 
156
function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
 
157
function crc32_combine(crc1, crc2, len2: LongInt): LongInt;
 
158
 
 
159
(* various hacks, don't look :) *)
 
160
function deflateInit_(var strm: z_stream; level: Integer;
 
161
                      const version: PChar; stream_size: Integer): Integer;
 
162
function inflateInit_(var strm: z_stream; const version: PChar;
 
163
                      stream_size: Integer): Integer;
 
164
function deflateInit2_(var strm: z_stream;
 
165
                       level, method, windowBits, memLevel, strategy: Integer;
 
166
                       const version: PChar; stream_size: Integer): Integer;
 
167
function inflateInit2_(var strm: z_stream; windowBits: Integer;
 
168
                       const version: PChar; stream_size: Integer): Integer;
 
169
function inflateBackInit_(var strm: z_stream;
 
170
                          windowBits: Integer; window: PChar;
 
171
                          const version: PChar; stream_size: Integer): Integer;
 
172
 
 
173
 
 
174
implementation
 
175
 
 
176
{$L adler32.obj}
 
177
{$L compress.obj}
 
178
{$L crc32.obj}
 
179
{$L deflate.obj}
 
180
{$L infback.obj}
 
181
{$L inffast.obj}
 
182
{$L inflate.obj}
 
183
{$L inftrees.obj}
 
184
{$L trees.obj}
 
185
{$L uncompr.obj}
 
186
{$L zutil.obj}
 
187
 
 
188
function adler32; external;
 
189
function adler32_combine; external;
 
190
function compress; external;
 
191
function compress2; external;
 
192
function compressBound; external;
 
193
function crc32; external;
 
194
function crc32_combine; external;
 
195
function deflate; external;
 
196
function deflateBound; external;
 
197
function deflateCopy; external;
 
198
function deflateEnd; external;
 
199
function deflateInit_; external;
 
200
function deflateInit2_; external;
 
201
function deflateParams; external;
 
202
function deflatePending; external;
 
203
function deflatePrime; external;
 
204
function deflateReset; external;
 
205
function deflateSetDictionary; external;
 
206
function deflateSetHeader; external;
 
207
function deflateTune; external;
 
208
function inflate; external;
 
209
function inflateBack; external;
 
210
function inflateBackEnd; external;
 
211
function inflateBackInit_; external;
 
212
function inflateCopy; external;
 
213
function inflateEnd; external;
 
214
function inflateGetHeader; external;
 
215
function inflateInit_; external;
 
216
function inflateInit2_; external;
 
217
function inflateMark; external;
 
218
function inflatePrime; external;
 
219
function inflateReset; external;
 
220
function inflateReset2; external;
 
221
function inflateSetDictionary; external;
 
222
function inflateSync; external;
 
223
function uncompress; external;
 
224
function zlibCompileFlags; external;
 
225
function zlibVersion; external;
 
226
 
 
227
function deflateInit(var strm: z_stream; level: Integer): Integer;
 
228
begin
 
229
  Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
 
230
end;
 
231
 
 
232
function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,
 
233
                      strategy: Integer): Integer;
 
234
begin
 
235
  Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
 
236
                          ZLIB_VERSION, sizeof(z_stream));
 
237
end;
 
238
 
 
239
function inflateInit(var strm: z_stream): Integer;
 
240
begin
 
241
  Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
 
242
end;
 
243
 
 
244
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
 
245
begin
 
246
  Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));
 
247
end;
 
248
 
 
249
function inflateBackInit(var strm: z_stream;
 
250
                         windowBits: Integer; window: PChar): Integer;
 
251
begin
 
252
  Result := inflateBackInit_(strm, windowBits, window,
 
253
                             ZLIB_VERSION, sizeof(z_stream));
 
254
end;
 
255
 
 
256
function _malloc(Size: Integer): Pointer; cdecl;
 
257
begin
 
258
  GetMem(Result, Size);
 
259
end;
 
260
 
 
261
procedure _free(Block: Pointer); cdecl;
 
262
begin
 
263
  FreeMem(Block);
 
264
end;
 
265
 
 
266
procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
 
267
begin
 
268
  FillChar(P^, count, B);
 
269
end;
 
270
 
 
271
procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
 
272
begin
 
273
  Move(source^, dest^, count);
 
274
end;
 
275
 
 
276
end.