Delphi DLL Requires Chilkat v11.0.0+

Decompress Large Text File in Blocks

See more Compression Examples

Decompresses a large text file in blocks, and compares the restored (decompressed) file with the original to make sure it's correct. Delphi DLL

var
success: Boolean;
compress: HCkCompression;
fac: HCkFileAccess;
originalPath: PWideChar;
facSrc: HCkFileAccess;
facDest: HCkFileAccess;
blockSize: Integer;
numBlocks: Integer;
restoredPath: PWideChar;
decompressedStr: PWideChar;
compressedBytes: HCkByteData;
i: Integer;
bEqualContents: Boolean;

begin
success := False;

//  This example requires the Chilkat API to have been previously unlocked.
//  See Global Unlock Sample for sample code.

//  First, let's compress a text file.
//  We'll then decompress in blocks, and compare the decompressed with the original file.

//  Compress a text file:
compress := CkCompression_Create();
CkCompression_putAlgorithm(compress,'deflate');

success := CkCompression_CompressFile(compress,'qa_data/hamlet.xml','qa_data/hamlet_compressed.dat');
if (success = False) then
  begin
    Memo1.Lines.Add(CkCompression__lastErrorText(compress));
    Exit;
  end;

fac := CkFileAccess_Create();

//  Examine the uncompressed and compressed sizes:
originalPath := 'qa_data/hamlet.xml';
//  Note: The FileSize method returns a signed 32-bit integer.  If the file is potentially larger than 2GB, call FileSizeStr instead to return
//  the size of the file as a string, then convert to an integer value.
Memo1.Lines.Add('uncompressed size: ' + IntToStr(CkFileAccess_FileSize(fac,originalPath)));
Memo1.Lines.Add('compressed size: ' + IntToStr(CkFileAccess_FileSize(fac,'qa_data/hamlet_compressed.dat')));

//  Decompress in blocks..
facSrc := CkFileAccess_Create();
facDest := CkFileAccess_Create();

CkFileAccess_OpenForRead(facSrc,'qa_data/hamlet_compressed.dat');

//  If we compress in 32K chunks, find out how many blocks there will be.
blockSize := 32768;
numBlocks := CkFileAccess_GetNumBlocks(facSrc,blockSize);

//  Open an output file for the decompressed data.
restoredPath := 'qa_output/hamlet_restored.xml';
success := CkFileAccess_OpenForWrite(facDest,restoredPath);
if (success = False) then
  begin
    Memo1.Lines.Add(CkFileAccess__lastErrorText(facDest));
    Exit;
  end;

compressedBytes := CkByteData_Create();

//  Assuming numBlocks > 1
CkCompression_putFirstChunk(compress,True);
CkCompression_putLastChunk(compress,False);

i := 0;
while i < numBlocks do
  begin
    success := CkFileAccess_ReadBlock(facSrc,i,blockSize,compressedBytes);
    decompressedStr := CkCompression__decompressString(compress,compressedBytes);

    CkFileAccess_AppendText(facDest,decompressedStr,'utf-8');

    i := i + 1;

    CkCompression_putFirstChunk(compress,False);
    if (i = (numBlocks - 1)) then
      begin
        CkCompression_putLastChunk(compress,True);
      end;
  end;

CkFileAccess_FileClose(facSrc);
CkFileAccess_FileClose(facDest);

//  Examine the size of the restored file.
Memo1.Lines.Add('restored size: ' + IntToStr(CkFileAccess_FileSize(fac,restoredPath)));

//  Compare the contents of the original with the restored.
bEqualContents := CkFileAccess_FileContentsEqual(fac,restoredPath,originalPath);
Memo1.Lines.Add('Contents Equal: ' + IntToStr(Ord(bEqualContents)));

CkCompression_Dispose(compress);
CkFileAccess_Dispose(fac);
CkFileAccess_Dispose(facSrc);
CkFileAccess_Dispose(facDest);
CkByteData_Dispose(compressedBytes);