(Delphi DLL) Decompress Large Text File in Blocks

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

Note: This example requires Chilkat v11.0.0 or greater.

Chilkat for Delphi Downloads Chilkat non-ActiveX DLL for Delphi Chilkat ActiveX DLL for Delphi * The examples here use the non-ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, FileAccess, CkByteData, Compression;

...

procedure TForm1.Button1Click(Sender: TObject);
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);

end;