1 | {*******************************************************} |
---|
2 | { } |
---|
3 | { Borland Delphi Supplemental Components } |
---|
4 | { ZLIB Data Compression Interface Unit } |
---|
5 | { } |
---|
6 | { Copyright (c) 1997,99 Borland Corporation } |
---|
7 | { } |
---|
8 | {*******************************************************} |
---|
9 | |
---|
10 | { Updated for zlib 1.2.x by Cosmin Truta <cosmint@cs.ubbcluj.ro> } |
---|
11 | |
---|
12 | unit ZLib; |
---|
13 | |
---|
14 | interface |
---|
15 | |
---|
16 | uses SysUtils, Classes; |
---|
17 | |
---|
18 | type |
---|
19 | TAlloc = function (AppData: Pointer; Items, Size: Integer): Pointer; cdecl; |
---|
20 | TFree = procedure (AppData, Block: Pointer); cdecl; |
---|
21 | |
---|
22 | // Internal structure. Ignore. |
---|
23 | TZStreamRec = packed record |
---|
24 | next_in: PChar; // next input byte |
---|
25 | avail_in: Integer; // number of bytes available at next_in |
---|
26 | total_in: Longint; // total nb of input bytes read so far |
---|
27 | |
---|
28 | next_out: PChar; // next output byte should be put here |
---|
29 | avail_out: Integer; // remaining free space at next_out |
---|
30 | total_out: Longint; // total nb of bytes output so far |
---|
31 | |
---|
32 | msg: PChar; // last error message, NULL if no error |
---|
33 | internal: Pointer; // not visible by applications |
---|
34 | |
---|
35 | zalloc: TAlloc; // used to allocate the internal state |
---|
36 | zfree: TFree; // used to free the internal state |
---|
37 | AppData: Pointer; // private data object passed to zalloc and zfree |
---|
38 | |
---|
39 | data_type: Integer; // best guess about the data type: ascii or binary |
---|
40 | adler: Longint; // adler32 value of the uncompressed data |
---|
41 | reserved: Longint; // reserved for future use |
---|
42 | end; |
---|
43 | |
---|
44 | // Abstract ancestor class |
---|
45 | TCustomZlibStream = class(TStream) |
---|
46 | private |
---|
47 | FStrm: TStream; |
---|
48 | FStrmPos: Integer; |
---|
49 | FOnProgress: TNotifyEvent; |
---|
50 | FZRec: TZStreamRec; |
---|
51 | FBuffer: array [Word] of Char; |
---|
52 | protected |
---|
53 | procedure Progress(Sender: TObject); dynamic; |
---|
54 | property OnProgress: TNotifyEvent read FOnProgress write FOnProgress; |
---|
55 | constructor Create(Strm: TStream); |
---|
56 | end; |
---|
57 | |
---|
58 | { TCompressionStream compresses data on the fly as data is written to it, and |
---|
59 | stores the compressed data to another stream. |
---|
60 | |
---|
61 | TCompressionStream is write-only and strictly sequential. Reading from the |
---|
62 | stream will raise an exception. Using Seek to move the stream pointer |
---|
63 | will raise an exception. |
---|
64 | |
---|
65 | Output data is cached internally, written to the output stream only when |
---|
66 | the internal output buffer is full. All pending output data is flushed |
---|
67 | when the stream is destroyed. |
---|
68 | |
---|
69 | The Position property returns the number of uncompressed bytes of |
---|
70 | data that have been written to the stream so far. |
---|
71 | |
---|
72 | CompressionRate returns the on-the-fly percentage by which the original |
---|
73 | data has been compressed: (1 - (CompressedBytes / UncompressedBytes)) * 100 |
---|
74 | If raw data size = 100 and compressed data size = 25, the CompressionRate |
---|
75 | is 75% |
---|
76 | |
---|
77 | The OnProgress event is called each time the output buffer is filled and |
---|
78 | written to the output stream. This is useful for updating a progress |
---|
79 | indicator when you are writing a large chunk of data to the compression |
---|
80 | stream in a single call.} |
---|
81 | |
---|
82 | |
---|
83 | TCompressionLevel = (clNone, clFastest, clDefault, clMax); |
---|
84 | |
---|
85 | TCompressionStream = class(TCustomZlibStream) |
---|
86 | private |
---|
87 | function GetCompressionRate: Single; |
---|
88 | public |
---|
89 | constructor Create(CompressionLevel: TCompressionLevel; Dest: TStream); |
---|
90 | destructor Destroy; override; |
---|
91 | function Read(var Buffer; Count: Longint): Longint; override; |
---|
92 | function Write(const Buffer; Count: Longint): Longint; override; |
---|
93 | function Seek(Offset: Longint; Origin: Word): Longint; override; |
---|
94 | property CompressionRate: Single read GetCompressionRate; |
---|
95 | property OnProgress; |
---|
96 | end; |
---|
97 | |
---|
98 | { TDecompressionStream decompresses data on the fly as data is read from it. |
---|
99 | |
---|
100 | Compressed data comes from a separate source stream. TDecompressionStream |
---|
101 | is read-only and unidirectional; you can seek forward in the stream, but not |
---|
102 | backwards. The special case of setting the stream position to zero is |
---|
103 | allowed. Seeking forward decompresses data until the requested position in |
---|
104 | the uncompressed data has been reached. Seeking backwards, seeking relative |
---|
105 | to the end of the stream, requesting the size of the stream, and writing to |
---|
106 | the stream will raise an exception. |
---|
107 | |
---|
108 | The Position property returns the number of bytes of uncompressed data that |
---|
109 | have been read from the stream so far. |
---|
110 | |
---|
111 | The OnProgress event is called each time the internal input buffer of |
---|
112 | compressed data is exhausted and the next block is read from the input stream. |
---|
113 | This is useful for updating a progress indicator when you are reading a |
---|
114 | large chunk of data from the decompression stream in a single call.} |
---|
115 | |
---|
116 | TDecompressionStream = class(TCustomZlibStream) |
---|
117 | public |
---|
118 | constructor Create(Source: TStream); |
---|
119 | destructor Destroy; override; |
---|
120 | function Read(var Buffer; Count: Longint): Longint; override; |
---|
121 | function Write(const Buffer; Count: Longint): Longint; override; |
---|
122 | function Seek(Offset: Longint; Origin: Word): Longint; override; |
---|
123 | property OnProgress; |
---|
124 | end; |
---|
125 | |
---|
126 | |
---|
127 | |
---|
128 | { CompressBuf compresses data, buffer to buffer, in one call. |
---|
129 | In: InBuf = ptr to compressed data |
---|
130 | InBytes = number of bytes in InBuf |
---|
131 | Out: OutBuf = ptr to newly allocated buffer containing decompressed data |
---|
132 | OutBytes = number of bytes in OutBuf } |
---|
133 | procedure CompressBuf(const InBuf: Pointer; InBytes: Integer; |
---|
134 | out OutBuf: Pointer; out OutBytes: Integer); |
---|
135 | |
---|
136 | |
---|
137 | { DecompressBuf decompresses data, buffer to buffer, in one call. |
---|
138 | In: InBuf = ptr to compressed data |
---|
139 | InBytes = number of bytes in InBuf |
---|
140 | OutEstimate = zero, or est. size of the decompressed data |
---|
141 | Out: OutBuf = ptr to newly allocated buffer containing decompressed data |
---|
142 | OutBytes = number of bytes in OutBuf } |
---|
143 | procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer; |
---|
144 | OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer); |
---|
145 | |
---|
146 | { DecompressToUserBuf decompresses data, buffer to buffer, in one call. |
---|
147 | In: InBuf = ptr to compressed data |
---|
148 | InBytes = number of bytes in InBuf |
---|
149 | Out: OutBuf = ptr to user-allocated buffer to contain decompressed data |
---|
150 | BufSize = number of bytes in OutBuf } |
---|
151 | procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer; |
---|
152 | const OutBuf: Pointer; BufSize: Integer); |
---|
153 | |
---|
154 | const |
---|
155 | zlib_version = '1.2.3'; |
---|
156 | |
---|
157 | type |
---|
158 | EZlibError = class(Exception); |
---|
159 | ECompressionError = class(EZlibError); |
---|
160 | EDecompressionError = class(EZlibError); |
---|
161 | |
---|
162 | implementation |
---|
163 | |
---|
164 | uses ZLibConst; |
---|
165 | |
---|
166 | const |
---|
167 | Z_NO_FLUSH = 0; |
---|
168 | Z_PARTIAL_FLUSH = 1; |
---|
169 | Z_SYNC_FLUSH = 2; |
---|
170 | Z_FULL_FLUSH = 3; |
---|
171 | Z_FINISH = 4; |
---|
172 | |
---|
173 | Z_OK = 0; |
---|
174 | Z_STREAM_END = 1; |
---|
175 | Z_NEED_DICT = 2; |
---|
176 | Z_ERRNO = (-1); |
---|
177 | Z_STREAM_ERROR = (-2); |
---|
178 | Z_DATA_ERROR = (-3); |
---|
179 | Z_MEM_ERROR = (-4); |
---|
180 | Z_BUF_ERROR = (-5); |
---|
181 | Z_VERSION_ERROR = (-6); |
---|
182 | |
---|
183 | Z_NO_COMPRESSION = 0; |
---|
184 | Z_BEST_SPEED = 1; |
---|
185 | Z_BEST_COMPRESSION = 9; |
---|
186 | Z_DEFAULT_COMPRESSION = (-1); |
---|
187 | |
---|
188 | Z_FILTERED = 1; |
---|
189 | Z_HUFFMAN_ONLY = 2; |
---|
190 | Z_RLE = 3; |
---|
191 | Z_DEFAULT_STRATEGY = 0; |
---|
192 | |
---|
193 | Z_BINARY = 0; |
---|
194 | Z_ASCII = 1; |
---|
195 | Z_UNKNOWN = 2; |
---|
196 | |
---|
197 | Z_DEFLATED = 8; |
---|
198 | |
---|
199 | |
---|
200 | {$L adler32.obj} |
---|
201 | {$L compress.obj} |
---|
202 | {$L crc32.obj} |
---|
203 | {$L deflate.obj} |
---|
204 | {$L infback.obj} |
---|
205 | {$L inffast.obj} |
---|
206 | {$L inflate.obj} |
---|
207 | {$L inftrees.obj} |
---|
208 | {$L trees.obj} |
---|
209 | {$L uncompr.obj} |
---|
210 | {$L zutil.obj} |
---|
211 | |
---|
212 | procedure adler32; external; |
---|
213 | procedure compressBound; external; |
---|
214 | procedure crc32; external; |
---|
215 | procedure deflateInit2_; external; |
---|
216 | procedure deflateParams; external; |
---|
217 | |
---|
218 | function _malloc(Size: Integer): Pointer; cdecl; |
---|
219 | begin |
---|
220 | Result := AllocMem(Size); |
---|
221 | end; |
---|
222 | |
---|
223 | procedure _free(Block: Pointer); cdecl; |
---|
224 | begin |
---|
225 | FreeMem(Block); |
---|
226 | end; |
---|
227 | |
---|
228 | procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl; |
---|
229 | begin |
---|
230 | FillChar(P^, count, B); |
---|
231 | end; |
---|
232 | |
---|
233 | procedure _memcpy(dest, source: Pointer; count: Integer); cdecl; |
---|
234 | begin |
---|
235 | Move(source^, dest^, count); |
---|
236 | end; |
---|
237 | |
---|
238 | |
---|
239 | |
---|
240 | // deflate compresses data |
---|
241 | function deflateInit_(var strm: TZStreamRec; level: Integer; version: PChar; |
---|
242 | recsize: Integer): Integer; external; |
---|
243 | function deflate(var strm: TZStreamRec; flush: Integer): Integer; external; |
---|
244 | function deflateEnd(var strm: TZStreamRec): Integer; external; |
---|
245 | |
---|
246 | // inflate decompresses data |
---|
247 | function inflateInit_(var strm: TZStreamRec; version: PChar; |
---|
248 | recsize: Integer): Integer; external; |
---|
249 | function inflate(var strm: TZStreamRec; flush: Integer): Integer; external; |
---|
250 | function inflateEnd(var strm: TZStreamRec): Integer; external; |
---|
251 | function inflateReset(var strm: TZStreamRec): Integer; external; |
---|
252 | |
---|
253 | |
---|
254 | function zlibAllocMem(AppData: Pointer; Items, Size: Integer): Pointer; cdecl; |
---|
255 | begin |
---|
256 | // GetMem(Result, Items*Size); |
---|
257 | Result := AllocMem(Items * Size); |
---|
258 | end; |
---|
259 | |
---|
260 | procedure zlibFreeMem(AppData, Block: Pointer); cdecl; |
---|
261 | begin |
---|
262 | FreeMem(Block); |
---|
263 | end; |
---|
264 | |
---|
265 | {function zlibCheck(code: Integer): Integer; |
---|
266 | begin |
---|
267 | Result := code; |
---|
268 | if code < 0 then |
---|
269 | raise EZlibError.Create('error'); //!! |
---|
270 | end;} |
---|
271 | |
---|
272 | function CCheck(code: Integer): Integer; |
---|
273 | begin |
---|
274 | Result := code; |
---|
275 | if code < 0 then |
---|
276 | raise ECompressionError.Create('error'); //!! |
---|
277 | end; |
---|
278 | |
---|
279 | function DCheck(code: Integer): Integer; |
---|
280 | begin |
---|
281 | Result := code; |
---|
282 | if code < 0 then |
---|
283 | raise EDecompressionError.Create('error'); //!! |
---|
284 | end; |
---|
285 | |
---|
286 | procedure CompressBuf(const InBuf: Pointer; InBytes: Integer; |
---|
287 | out OutBuf: Pointer; out OutBytes: Integer); |
---|
288 | var |
---|
289 | strm: TZStreamRec; |
---|
290 | P: Pointer; |
---|
291 | begin |
---|
292 | FillChar(strm, sizeof(strm), 0); |
---|
293 | strm.zalloc := zlibAllocMem; |
---|
294 | strm.zfree := zlibFreeMem; |
---|
295 | OutBytes := ((InBytes + (InBytes div 10) + 12) + 255) and not 255; |
---|
296 | GetMem(OutBuf, OutBytes); |
---|
297 | try |
---|
298 | strm.next_in := InBuf; |
---|
299 | strm.avail_in := InBytes; |
---|
300 | strm.next_out := OutBuf; |
---|
301 | strm.avail_out := OutBytes; |
---|
302 | CCheck(deflateInit_(strm, Z_BEST_COMPRESSION, zlib_version, sizeof(strm))); |
---|
303 | try |
---|
304 | while CCheck(deflate(strm, Z_FINISH)) <> Z_STREAM_END do |
---|
305 | begin |
---|
306 | P := OutBuf; |
---|
307 | Inc(OutBytes, 256); |
---|
308 | ReallocMem(OutBuf, OutBytes); |
---|
309 | strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P))); |
---|
310 | strm.avail_out := 256; |
---|
311 | end; |
---|
312 | finally |
---|
313 | CCheck(deflateEnd(strm)); |
---|
314 | end; |
---|
315 | ReallocMem(OutBuf, strm.total_out); |
---|
316 | OutBytes := strm.total_out; |
---|
317 | except |
---|
318 | FreeMem(OutBuf); |
---|
319 | raise |
---|
320 | end; |
---|
321 | end; |
---|
322 | |
---|
323 | |
---|
324 | procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer; |
---|
325 | OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer); |
---|
326 | var |
---|
327 | strm: TZStreamRec; |
---|
328 | P: Pointer; |
---|
329 | BufInc: Integer; |
---|
330 | begin |
---|
331 | FillChar(strm, sizeof(strm), 0); |
---|
332 | strm.zalloc := zlibAllocMem; |
---|
333 | strm.zfree := zlibFreeMem; |
---|
334 | BufInc := (InBytes + 255) and not 255; |
---|
335 | if OutEstimate = 0 then |
---|
336 | OutBytes := BufInc |
---|
337 | else |
---|
338 | OutBytes := OutEstimate; |
---|
339 | GetMem(OutBuf, OutBytes); |
---|
340 | try |
---|
341 | strm.next_in := InBuf; |
---|
342 | strm.avail_in := InBytes; |
---|
343 | strm.next_out := OutBuf; |
---|
344 | strm.avail_out := OutBytes; |
---|
345 | DCheck(inflateInit_(strm, zlib_version, sizeof(strm))); |
---|
346 | try |
---|
347 | while DCheck(inflate(strm, Z_NO_FLUSH)) <> Z_STREAM_END do |
---|
348 | begin |
---|
349 | P := OutBuf; |
---|
350 | Inc(OutBytes, BufInc); |
---|
351 | ReallocMem(OutBuf, OutBytes); |
---|
352 | strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P))); |
---|
353 | strm.avail_out := BufInc; |
---|
354 | end; |
---|
355 | finally |
---|
356 | DCheck(inflateEnd(strm)); |
---|
357 | end; |
---|
358 | ReallocMem(OutBuf, strm.total_out); |
---|
359 | OutBytes := strm.total_out; |
---|
360 | except |
---|
361 | FreeMem(OutBuf); |
---|
362 | raise |
---|
363 | end; |
---|
364 | end; |
---|
365 | |
---|
366 | procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer; |
---|
367 | const OutBuf: Pointer; BufSize: Integer); |
---|
368 | var |
---|
369 | strm: TZStreamRec; |
---|
370 | begin |
---|
371 | FillChar(strm, sizeof(strm), 0); |
---|
372 | strm.zalloc := zlibAllocMem; |
---|
373 | strm.zfree := zlibFreeMem; |
---|
374 | strm.next_in := InBuf; |
---|
375 | strm.avail_in := InBytes; |
---|
376 | strm.next_out := OutBuf; |
---|
377 | strm.avail_out := BufSize; |
---|
378 | DCheck(inflateInit_(strm, zlib_version, sizeof(strm))); |
---|
379 | try |
---|
380 | if DCheck(inflate(strm, Z_FINISH)) <> Z_STREAM_END then |
---|
381 | raise EZlibError.CreateRes(@sTargetBufferTooSmall); |
---|
382 | finally |
---|
383 | DCheck(inflateEnd(strm)); |
---|
384 | end; |
---|
385 | end; |
---|
386 | |
---|
387 | // TCustomZlibStream |
---|
388 | |
---|
389 | constructor TCustomZLibStream.Create(Strm: TStream); |
---|
390 | begin |
---|
391 | inherited Create; |
---|
392 | FStrm := Strm; |
---|
393 | FStrmPos := Strm.Position; |
---|
394 | FZRec.zalloc := zlibAllocMem; |
---|
395 | FZRec.zfree := zlibFreeMem; |
---|
396 | end; |
---|
397 | |
---|
398 | procedure TCustomZLibStream.Progress(Sender: TObject); |
---|
399 | begin |
---|
400 | if Assigned(FOnProgress) then FOnProgress(Sender); |
---|
401 | end; |
---|
402 | |
---|
403 | |
---|
404 | // TCompressionStream |
---|
405 | |
---|
406 | constructor TCompressionStream.Create(CompressionLevel: TCompressionLevel; |
---|
407 | Dest: TStream); |
---|
408 | const |
---|
409 | Levels: array [TCompressionLevel] of ShortInt = |
---|
410 | (Z_NO_COMPRESSION, Z_BEST_SPEED, Z_DEFAULT_COMPRESSION, Z_BEST_COMPRESSION); |
---|
411 | begin |
---|
412 | inherited Create(Dest); |
---|
413 | FZRec.next_out := FBuffer; |
---|
414 | FZRec.avail_out := sizeof(FBuffer); |
---|
415 | CCheck(deflateInit_(FZRec, Levels[CompressionLevel], zlib_version, sizeof(FZRec))); |
---|
416 | end; |
---|
417 | |
---|
418 | destructor TCompressionStream.Destroy; |
---|
419 | begin |
---|
420 | FZRec.next_in := nil; |
---|
421 | FZRec.avail_in := 0; |
---|
422 | try |
---|
423 | if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos; |
---|
424 | while (CCheck(deflate(FZRec, Z_FINISH)) <> Z_STREAM_END) |
---|
425 | and (FZRec.avail_out = 0) do |
---|
426 | begin |
---|
427 | FStrm.WriteBuffer(FBuffer, sizeof(FBuffer)); |
---|
428 | FZRec.next_out := FBuffer; |
---|
429 | FZRec.avail_out := sizeof(FBuffer); |
---|
430 | end; |
---|
431 | if FZRec.avail_out < sizeof(FBuffer) then |
---|
432 | FStrm.WriteBuffer(FBuffer, sizeof(FBuffer) - FZRec.avail_out); |
---|
433 | finally |
---|
434 | deflateEnd(FZRec); |
---|
435 | end; |
---|
436 | inherited Destroy; |
---|
437 | end; |
---|
438 | |
---|
439 | function TCompressionStream.Read(var Buffer; Count: Longint): Longint; |
---|
440 | begin |
---|
441 | raise ECompressionError.CreateRes(@sInvalidStreamOp); |
---|
442 | end; |
---|
443 | |
---|
444 | function TCompressionStream.Write(const Buffer; Count: Longint): Longint; |
---|
445 | begin |
---|
446 | FZRec.next_in := @Buffer; |
---|
447 | FZRec.avail_in := Count; |
---|
448 | if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos; |
---|
449 | while (FZRec.avail_in > 0) do |
---|
450 | begin |
---|
451 | CCheck(deflate(FZRec, 0)); |
---|
452 | if FZRec.avail_out = 0 then |
---|
453 | begin |
---|
454 | FStrm.WriteBuffer(FBuffer, sizeof(FBuffer)); |
---|
455 | FZRec.next_out := FBuffer; |
---|
456 | FZRec.avail_out := sizeof(FBuffer); |
---|
457 | FStrmPos := FStrm.Position; |
---|
458 | Progress(Self); |
---|
459 | end; |
---|
460 | end; |
---|
461 | Result := Count; |
---|
462 | end; |
---|
463 | |
---|
464 | function TCompressionStream.Seek(Offset: Longint; Origin: Word): Longint; |
---|
465 | begin |
---|
466 | if (Offset = 0) and (Origin = soFromCurrent) then |
---|
467 | Result := FZRec.total_in |
---|
468 | else |
---|
469 | raise ECompressionError.CreateRes(@sInvalidStreamOp); |
---|
470 | end; |
---|
471 | |
---|
472 | function TCompressionStream.GetCompressionRate: Single; |
---|
473 | begin |
---|
474 | if FZRec.total_in = 0 then |
---|
475 | Result := 0 |
---|
476 | else |
---|
477 | Result := (1.0 - (FZRec.total_out / FZRec.total_in)) * 100.0; |
---|
478 | end; |
---|
479 | |
---|
480 | |
---|
481 | // TDecompressionStream |
---|
482 | |
---|
483 | constructor TDecompressionStream.Create(Source: TStream); |
---|
484 | begin |
---|
485 | inherited Create(Source); |
---|
486 | FZRec.next_in := FBuffer; |
---|
487 | FZRec.avail_in := 0; |
---|
488 | DCheck(inflateInit_(FZRec, zlib_version, sizeof(FZRec))); |
---|
489 | end; |
---|
490 | |
---|
491 | destructor TDecompressionStream.Destroy; |
---|
492 | begin |
---|
493 | FStrm.Seek(-FZRec.avail_in, 1); |
---|
494 | inflateEnd(FZRec); |
---|
495 | inherited Destroy; |
---|
496 | end; |
---|
497 | |
---|
498 | function TDecompressionStream.Read(var Buffer; Count: Longint): Longint; |
---|
499 | begin |
---|
500 | FZRec.next_out := @Buffer; |
---|
501 | FZRec.avail_out := Count; |
---|
502 | if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos; |
---|
503 | while (FZRec.avail_out > 0) do |
---|
504 | begin |
---|
505 | if FZRec.avail_in = 0 then |
---|
506 | begin |
---|
507 | FZRec.avail_in := FStrm.Read(FBuffer, sizeof(FBuffer)); |
---|
508 | if FZRec.avail_in = 0 then |
---|
509 | begin |
---|
510 | Result := Count - FZRec.avail_out; |
---|
511 | Exit; |
---|
512 | end; |
---|
513 | FZRec.next_in := FBuffer; |
---|
514 | FStrmPos := FStrm.Position; |
---|
515 | Progress(Self); |
---|
516 | end; |
---|
517 | CCheck(inflate(FZRec, 0)); |
---|
518 | end; |
---|
519 | Result := Count; |
---|
520 | end; |
---|
521 | |
---|
522 | function TDecompressionStream.Write(const Buffer; Count: Longint): Longint; |
---|
523 | begin |
---|
524 | raise EDecompressionError.CreateRes(@sInvalidStreamOp); |
---|
525 | end; |
---|
526 | |
---|
527 | function TDecompressionStream.Seek(Offset: Longint; Origin: Word): Longint; |
---|
528 | var |
---|
529 | I: Integer; |
---|
530 | Buf: array [0..4095] of Char; |
---|
531 | begin |
---|
532 | if (Offset = 0) and (Origin = soFromBeginning) then |
---|
533 | begin |
---|
534 | DCheck(inflateReset(FZRec)); |
---|
535 | FZRec.next_in := FBuffer; |
---|
536 | FZRec.avail_in := 0; |
---|
537 | FStrm.Position := 0; |
---|
538 | FStrmPos := 0; |
---|
539 | end |
---|
540 | else if ( (Offset >= 0) and (Origin = soFromCurrent)) or |
---|
541 | ( ((Offset - FZRec.total_out) > 0) and (Origin = soFromBeginning)) then |
---|
542 | begin |
---|
543 | if Origin = soFromBeginning then Dec(Offset, FZRec.total_out); |
---|
544 | if Offset > 0 then |
---|
545 | begin |
---|
546 | for I := 1 to Offset div sizeof(Buf) do |
---|
547 | ReadBuffer(Buf, sizeof(Buf)); |
---|
548 | ReadBuffer(Buf, Offset mod sizeof(Buf)); |
---|
549 | end; |
---|
550 | end |
---|
551 | else |
---|
552 | raise EDecompressionError.CreateRes(@sInvalidStreamOp); |
---|
553 | Result := FZRec.total_out; |
---|
554 | end; |
---|
555 | |
---|
556 | |
---|
557 | end. |
---|