mxzlib.pas

delphi源代码。iocp远控比较完整的代码

unit MxZLib;

interface

uses
  Windows;

const
  ZLIB_VERSION = '1.2.3';

type
  TZAlloc = function(opaque: Pointer; items, size: Integer): Pointer;
  TZFree = procedure(opaque, block: Pointer);
  TZCompressionLevel = (zcNone, zcFastest, zcDefault, zcMax);

  {** TZStreamRec ***********************************************************}

  TZStreamRec = packed record
    next_in: PChar; // next input byte
    avail_in: Longint; // number of bytes available at next_in
    total_in: Longint; // total nb of input bytes read so far
    next_out: PChar; // next output byte should be put here
    avail_out: Longint; // remaining free space at next_out
    total_out: Longint; // total nb of bytes output so far
    msg: PChar; // last error message, NULL if no error
    state: Pointer; // not visible by applications
    zalloc: TZAlloc; // used to allocate the internal state
    zfree: TZFree; // used to free the internal state
    opaque: Pointer; // private data object passed to zalloc and zfree
    data_type: Integer; // best guess about the data type: ascii or binary
    adler: Longint; // adler32 value of the uncompressed data
    reserved: Longint; // reserved for future use
  end;

{** zlib public routines ****************************************************}

procedure ZCompress(const inBuffer: Pointer; inSize: Integer; outBuffer: Pointer; out outSize: Integer; Level: TZCompressionLevel = zcDefault);
procedure ZDecompress(const inBuffer: Pointer; inSize: Integer; outBuffer: Pointer; out outSize: Integer; outEstimate: Integer = 0);

{** export routines ********************************************************}

function adler32(adler: Longint; const buf: PChar; len: Integer): Longint;
function deflateInit_(var strm: TZStreamRec; Level: Integer; version: PChar; recsize: Integer): Integer;
function DeflateInit2_(var strm: TZStreamRec; Level: Integer; method: Integer; windowBits: Integer; memLevel: Integer; strategy: Integer; version: PChar; recsize: Integer): Integer;
function deflate(var strm: TZStreamRec; flush: Integer): Integer;
function deflateEnd(var strm: TZStreamRec): Integer;
function inflateInit_(var strm: TZStreamRec; version: PChar; recsize: Integer): Integer;
function inflateInit2_(var strm: TZStreamRec; windowBits: Integer; version: PChar; recsize: Integer): Integer;
function inflate(var strm: TZStreamRec; flush: Integer): Integer;
function inflateEnd(var strm: TZStreamRec): Integer;
function inflateReset(var strm: TZStreamRec): Integer;

implementation

{** link zlib 1.2.3 **************************************************************}
{** bcc32 -c -6 -O2 -Ve -X -pr -a8 -b -d -k- -vi -tWM -r -RT- -ff *.c **}

{$L adler32.obj}
{$L deflate.obj}
{$L infback.obj}
{$L inffast.obj}
{$L inflate.obj}
{$L inftrees.obj}
{$L trees.obj}
{$L compress.obj}
{$L crc32.obj}

{*****************************************************************************
*  note: do not reorder the above -- doing so will result in external        *
*  functions being undefined                                                 *
*****************************************************************************}

const
  {** flush constants *******************************************************}

  Z_NO_FLUSH = 0;
  Z_PARTIAL_FLUSH = 1;
  Z_SYNC_FLUSH = 2;
  Z_FULL_FLUSH = 3;
  Z_FINISH = 4;

  {** return codes **********************************************************}

  Z_OK = 0;
  Z_STREAM_END = 1;
  Z_NEED_DICT = 2;
  Z_ERRNO = (-1);
  Z_STREAM_ERROR = (-2);
  Z_DATA_ERROR = (-3);
  Z_MEM_ERROR = (-4);
  Z_BUF_ERROR = (-5);
  Z_VERSION_ERROR = (-6);

  {** compression Levels ****************************************************}

  Z_NO_COMPRESSION = 0;
  Z_BEST_SPEED = 1;
  Z_BEST_COMPRESSION = 9;
  Z_DEFAULT_COMPRESSION = (-1);

  {** compression strategies ************************************************}

  Z_FILTERED = 1;
  Z_HUFFMAN_ONLY = 2;
  Z_DEFAULT_STRATEGY = 0;

  {** data types ************************************************************}

  Z_BINARY = 0;
  Z_ASCII = 1;
  Z_UNKNOWN = 2;

  {** compression methods ***************************************************}

  Z_DEFLATED = 8;

  {** return code messages **************************************************}

  _z_errmsg: array[0..9] of PChar = (
    'need dictionary', // Z_NEED_DICT(2)
    'stream end', // Z_STREAM_END(1)
    '', // Z_OK(0)
    'file error', // Z_ERRNO (-1)
    'stream error', // Z_STREAM_ERROR(-2)
    'data error', // Z_DATA_ERROR(-3)
    'insufficient memory', // Z_MEM_ERROR(-4)
    'buffer error', // Z_BUF_ERROR(-5)
    'incompatible version', // Z_VERSION_ERROR(-6)
    ''
    );

  ZLevels: array[TZCompressionLevel] of Shortint = (
    Z_NO_COMPRESSION,
    Z_BEST_SPEED,
    Z_DEFAULT_COMPRESSION,
    Z_BEST_COMPRESSION
    );

{** deflate routines ********************************************************}

function deflateInit_(var strm: TZStreamRec; Level: Integer; version: PChar; recsize: Integer): Integer; external;
function DeflateInit2_(var strm: TZStreamRec; Level: Integer; method: Integer; windowBits: Integer; memLevel: Integer; strategy: Integer; version: PChar; recsize: Integer): Integer; external;
function deflate(var strm: TZStreamRec; flush: Integer): Integer; external;
function deflateEnd(var strm: TZStreamRec): Integer; external;

{** inflate routines ********************************************************}

function inflateInit_(var strm: TZStreamRec; version: PChar; recsize: Integer): Integer; external;
function inflateInit2_(var strm: TZStreamRec; windowBits: Integer; version: PChar; recsize: Integer): Integer; external;
function inflate(var strm: TZStreamRec; flush: Integer): Integer; external;
function inflateEnd(var strm: TZStreamRec): Integer; external;
function inflateReset(var strm: TZStreamRec): Integer; external;

{** utility routines  *******************************************************}

function adler32; external;

{** zlib function implementations *******************************************}

function zcalloc(opaque: Pointer; items, size: Integer): Pointer;
begin
  Result := GlobalAllocPtr(GPTR, items * size);
end;

procedure zcfree(opaque, block: Pointer);
begin
  GlobalFreePtr(block);
end;

{** c function implementations **********************************************}

procedure _memset(p: Pointer; b: Byte; Count: Integer); cdecl;
begin
  FillChar(p^, Count, b);
end;

procedure _memcpy(Dest, Source: Pointer; Count: Integer); cdecl;
begin
  Move(Source^, Dest^, Count);
end;

{** custom zlib routines ****************************************************}

function DeflateInit(var stream: TZStreamRec; Level: Integer): Integer;
begin
  Result := deflateInit_(stream, Level, ZLIB_VERSION, SizeOf(TZStreamRec));
end;

function InflateInit(var stream: TZStreamRec): Integer;
begin
  Result := inflateInit_(stream, ZLIB_VERSION, SizeOf(TZStreamRec));
end;

{****************************************************************************}

procedure ZCompress(const inBuffer: Pointer; inSize: Integer; outBuffer: Pointer; out outSize: Integer; Level: TZCompressionLevel);
const
  Delta = 256;
var
  ZStream: TZStreamRec;
begin
  FillChar(ZStream, SizeOf(TZStreamRec), 0);
  outSize := ((inSize + (inSize div 10) + 12) + 255) and not 255;
  try
    ZStream.next_in := inBuffer;
    ZStream.avail_in := inSize;
    ZStream.next_out := outBuffer;
    ZStream.avail_out := outSize;
    DeflateInit(ZStream, -1 {ZLevels[Level]});
    try
      while deflate(ZStream, Z_FINISH) <> Z_STREAM_END do
      begin
        Inc(outSize, Delta);
        ZStream.next_out := PChar(Integer(outBuffer) + ZStream.total_out);
        ZStream.avail_out := Delta;
      end;
    finally
      deflateEnd(ZStream);
    end;
    outSize := ZStream.total_out;
  except
    outSize := 0;
    raise;
  end;
end;

procedure ZDecompress(const inBuffer: Pointer; inSize: Integer; outBuffer: Pointer; out outSize: Integer; outEstimate: Integer);
var
  ZStream: TZStreamRec;
  Delta: Integer;
begin
  FillChar(ZStream, SizeOf(TZStreamRec), 0);
  Delta := (inSize + 255) and not 255;
  if outEstimate = 0 then
    outSize := Delta
  else
    outSize := outEstimate;
  try
    ZStream.next_in := inBuffer;
    ZStream.avail_in := inSize;
    ZStream.next_out := outBuffer;
    ZStream.avail_out := outSize;
    InflateInit(ZStream);
    try
      while inflate(ZStream, Z_NO_FLUSH) <> Z_STREAM_END do
      begin
        Inc(outSize, Delta);
        ZStream.next_out := PChar(Integer(outBuffer) + ZStream.total_out);
        ZStream.avail_out := Delta;
      end;
    finally
      inflateEnd(ZStream);
    end;
    outSize := ZStream.total_out;
  except
    outSize := 0;
    raise;
  end;
end;

end.