lvkzlibutils.pas

单独打包出来

      if zs.avail_in = 0 then
      begin
        zs.next_in := InputBuffer.Pointer;
        zs.avail_in := SourceStream.Read(InputBuffer.Pointer^,
          InputBuffer.Size);
      end;

      errorCode := inflate(zs, Z_SYNC_FLUSH);

      if (errorCode <> Z_STREAM_END) and (errorCode <> Z_OK) then
        zLibCheckDecompress(errorCode);

      if (zs.avail_out = 0) or (errorCode = Z_STREAM_END) then
      begin
        DestinationStream.WriteBuffer(OutputBuffer.Pointer^, zs.next_out -
          OutputBuffer.Pointer);
        zs.next_out := OutputBuffer.Pointer;
        zs.avail_out := OutputBuffer.Size;
      end;
    until errorCode = Z_STREAM_END;
  finally
    Cleanup;
  end;
end;

procedure zLibCompress(const SourceFileName, DestinationFileName: string;
  const CompressionLevel: Integer; const BufferSize: Cardinal;
  const WriteHeader: Boolean);
var
  SourceStream      : TStream;
  DestinationStream : TStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TFileStream.Create(SourceFileName, fmOpenRead or
      fmShareDenyWrite);
    DestinationStream := TFileStream.Create(DestinationFileName, fmCreate);

    zLibCompress(SourceStream, DestinationStream, CompressionLevel, BufferSize,
      WriteHeader);
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

procedure zLibDecompress(const SourceFileName, DestinationFileName: string;
  const BufferSize: Cardinal; const ReadHeader: Boolean);
var
  SourceStream      : TStream;
  DestinationStream : TStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TFileStream.Create(SourceFileName, fmOpenRead or
      fmShareDenyWrite);
    DestinationStream := TFileStream.Create(DestinationFileName, fmCreate);

    zLibDecompress(SourceStream, DestinationStream, BufferSize, ReadHeader);
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

procedure zLibCompress(const SourceStream, DestinationStream: TStream;
  const CompressionLevel: Integer; const BufferSize: Cardinal;
  const WriteHeader: Boolean);
begin
  Assert(Assigned(SourceStream));
  Assert(Assigned(DestinationStream));

  SourceStream.Position := 0;
  CompressStream(SourceStream, DestinationStream, CompressionLevel,
    BufferSize, WriteHeader);
end;

procedure zLibDecompress(const SourceStream, DestinationStream: TStream;
  const BufferSize: Cardinal; const ReadHeader: Boolean);
begin
  Assert(Assigned(SourceStream));
  Assert(Assigned(DestinationStream));

  SourceStream.Position := 0;
  DecompressStream(SourceStream, DestinationStream, BufferSize, ReadHeader);
end;

function zLibCompress(const Input: string;
  const CompressionLevel: Integer; const BufferSize: Cardinal;
  const WriteHeader: Boolean): string;
var
  SourceStream      : TStringStream;
  DestinationStream : TStringStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TStringStream.Create(Input);
    DestinationStream := TStringStream.Create('');

    zLibCompress(SourceStream, DestinationStream, CompressionLevel, BufferSize,
      WriteHeader);

    Result := DestinationStream.DataString;
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

function zLibDecompress(const Input: string;
  const BufferSize: Cardinal; const ReadHeader: Boolean): string;
var
  SourceStream      : TStringStream;
  DestinationStream : TStringStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TStringStream.Create(Input);
    DestinationStream := TStringStream.Create('');

    zLibDecompress(SourceStream, DestinationStream, BufferSize, ReadHeader);

    Result := DestinationStream.DataString;
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

function zLibCompress(const Input: ISafeMem; const CompressionLevel: Integer;
  const BufferSize: Cardinal; const WriteHeader: Boolean): ISafeMem;
begin
  Assert(Assigned(Input));

  Result := AllocateSafeMem(0);
  zLibCompress(Input.Stream, Result.Stream, CompressionLevel, BufferSize,
    WriteHeader);
  Result.Stream.Position := 0;
end;

function zLibDecompress(const Input: ISafeMem;
  const BufferSize: Cardinal=DEFAULT_BUFFER_SIZE;
  const ReadHeader: Boolean=DEFAULT_READ_HEADER): ISafeMem;
begin
  Assert(Assigned(Input));

  Result := AllocateSafeMem(0);
  zLibDecompress(Input.Stream, Result.Stream, BufferSize, ReadHeader);
  Result.Stream.Position := 0;
end;

procedure gZipCompress(const SourceFileName, DestinationFileName: string;
  const CompressionLevel: Integer; const BufferSize: Cardinal);
var
  SourceStream      : TStream;
  DestinationStream : TStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TFileStream.Create(SourceFileName, fmOpenRead or
      fmShareDenyWrite);
    DestinationStream := TFileStream.Create(DestinationFileName, fmCreate);

    gZipCompress(SourceStream, DestinationStream, CompressionLevel, BufferSize);
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

procedure gZipDecompress(const SourceFileName, DestinationFileName: string;
  const BufferSize: Cardinal);
var
  SourceStream      : TStream;
  DestinationStream : TStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TFileStream.Create(SourceFileName, fmOpenRead or
      fmShareDenyWrite);
    DestinationStream := TFileStream.Create(DestinationFileName, fmCreate);

    gZipDecompress(SourceStream, DestinationStream, BufferSize);
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

procedure gZipCompress(const SourceStream, DestinationStream: TStream;
  const CompressionLevel: Integer; const BufferSize: Cardinal);

  procedure WriteHeader;
  var
    Header  : TGZipHeader;
  begin
    ZeroMemory(@Header, SizeOf(Header));
    Header.ID1_2 := GZIP_SIGNATURE;
    Header.CM := GZIP_DEFLATED;

    DestinationStream.WriteBuffer(Header, SizeOf(Header));
  end;

  procedure WriteTrailer;
  var
    Trailer : TGZipTrailer;
  begin
    Trailer.CRC32 := CRC32Of(SourceStream);
    Trailer.ISIZE := SourceStream.Size;

    DestinationStream.WriteBuffer(Trailer, SizeOf(Trailer));
  end;

begin
  Assert(Assigned(SourceStream));
  Assert(Assigned(DestinationStream));

  SourceStream.Position := 0;

  WriteHeader;
  CompressStream(SourceStream, DestinationStream, CompressionLevel, BufferSize,
    False);
  WriteTrailer;
end;

procedure gZipDecompress(const SourceStream, DestinationStream: TStream;
  const BufferSize: Cardinal);
var
  Header        : TGZipHeader;
  SourceBuffer  : TStream;

  procedure SkipExtra;
  var
    XLEN  : UInt16;
  begin
    SourceBuffer.ReadBuffer(XLEN, SizeOf(XLEN));
    SourceBuffer.Position := SourceStream.Position + XLEN;
  end;

  procedure SkipASCIIZ;
  var
    b : UInt8;
  begin
    repeat
      SourceBuffer.ReadBuffer(b, 1);
    until b = 0;
  end;

  procedure SkipCRC16;
  var
    CRC16 : UInt16;
  begin
    SourceBuffer.ReadBuffer(CRC16, SizeOf(CRC16));
  end;

begin
  Assert(Assigned(SourceStream));
  Assert(Assigned(DestinationStream));

  SourceBuffer := TlvkBufferedStream.Create(SourceStream, False);
  try
    SourceBuffer.Position := 0;
    SourceBuffer.ReadBuffer(Header, SizeOf(Header));
    Assert(Header.ID1_2 = GZIP_SIGNATURE);
    Assert(Header.CM = GZIP_DEFLATED);
    if (Header.FLG and GZIP_FLAG_FEXTRA) <> 0 then
      SkipExtra;
    if (Header.FLG and GZIP_FLAG_FNAME) <> 0 then
      SkipASCIIZ;
    if (Header.FLG and GZIP_FLAG_FCOMMENT) <> 0 then
      SkipASCIIZ;
    if (Header.FLG and GZIP_FLAG_FHCRC) <> 0 then
      SkipCRC16;

    DecompressStream(SourceBuffer, DestinationStream, BufferSize, False);
  finally
    SourceBuffer.Free;
  end;
end;

function gZipCompress(const Input: string; const CompressionLevel: Integer;
  const BufferSize: Cardinal): string;
var
  SourceStream      : TStringStream;
  DestinationStream : TStringStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TStringStream.Create(Input);
    DestinationStream := TStringStream.Create('');

    gZipCompress(SourceStream, DestinationStream, CompressionLevel, BufferSize);

    Result := DestinationStream.DataString;
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

function gZipDecompress(const Input: string;
  const BufferSize: Cardinal): string;
var
  SourceStream      : TStringStream;
  DestinationStream : TStringStream;
begin
  SourceStream := nil;
  DestinationStream := nil;
  try
    SourceStream := TStringStream.Create(Input);
    DestinationStream := TStringStream.Create('');

    gZipDecompress(SourceStream, DestinationStream, BufferSize);

    Result := DestinationStream.DataString;
  finally
    DestinationStream.Free;
    SourceStream.Free;
  end;
end;

function gZipCompress(const Input: ISafeMem; const CompressionLevel: Integer;
  const BufferSize: Cardinal): ISafeMem;
begin
  Assert(Assigned(Input));

  Result := AllocateSafeMem(0);
  gZipCompress(Input.Stream, Result.Stream, CompressionLevel, BufferSize);
  Result.Stream.Position := 0;
end;

function gZipDecompress(const Input: ISafeMem;
  const BufferSize: Cardinal): ISafeMem;
begin
  Assert(Assigned(Input));

  Result := AllocateSafeMem(0);
  gZipDecompress(Input.Stream, Result.Stream, BufferSize);
  Result.Stream.Position := 0;
end;

end.