| 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.13'; |
| 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. |