Delphi DLL

Streaming Compression

See more Compression Examples

Compress and decompress using a stream. Delphi DLL

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

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Boolean;
fac: HCkFileAccess;
compress: HCkCompression;
streamC: HCkStream;
streamD: HCkStream;
bFilesEqual: Boolean;
streamA: HCkStream;
task: HCkTask;
decompressedText: PWideChar;

begin
success := False;

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

fac := CkFileAccess_Create();
compress := CkCompression_Create();
CkCompression_putAlgorithm(compress,'deflate');

streamC := CkStream_Create();

// This example sets the source and sink of the stream to files.
// A stream can have use other streams as a source or sink,
// or the application can itself be the source/sink by directly
// reading or writing a stream.  (See below for an example of this..)
CkStream_putSourceFile(streamC,'qa_data/hamlet.xml');
CkStream_putSinkFile(streamC,'qa_output/hamlet_compressed.dat');

// Compress from source to sink.
success := CkCompression_CompressStream(compress,streamC);
if (success <> True) then
  begin
    Memo1.Lines.Add(CkCompression__lastErrorText(compress));
    Exit;
  end;

Memo1.Lines.Add('File-to-file deflate compression successful.');
// 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('Original size = ' + IntToStr(CkFileAccess_FileSize(fac,CkStream__sourceFile(streamC))));
Memo1.Lines.Add('Compressed size = ' + IntToStr(CkFileAccess_FileSize(fac,CkStream__sinkFile(streamC))));

// Now do file-to-file decompression
streamD := CkStream_Create();
CkStream_putSourceFile(streamD,'qa_output/hamlet_compressed.dat');
CkStream_putSinkFile(streamD,'qa_output/hamlet_restored.xml');

// Decompress from source to sink.
success := CkCompression_DecompressStream(compress,streamD);
if (success <> True) then
  begin
    Memo1.Lines.Add(CkCompression__lastErrorText(compress));
    Exit;
  end;

Memo1.Lines.Add('File-to-file deflate decompression successful.');

// Let's double-check to see that the files are equal in size and content:

bFilesEqual := CkFileAccess_FileContentsEqual(fac,CkStream__sourceFile(streamC),CkStream__sinkFile(streamD));
if (bFilesEqual <> True) then
  begin
    Memo1.Lines.Add('The output file is not equal to the input file!');
  end
else
  begin
    Memo1.Lines.Add('The file was successfully compressed and decompressed.');
  end;

// ---------------------------------------------------------------------
// Now let's decompress again, but this time w/ the application reading
// the decompressed data directly from a stream.
streamA := CkStream_Create();

CkStream_putSourceFile(streamA,'qa_output/hamlet_compressed.dat');

// Start decompressing in a background thread.
task := CkCompression_DecompressStreamAsync(compress,streamA);
success := CkTask_Run(task);

// Read decompressed data from streamA:

while (CkStream_getEndOfStream(streamA) <> True) do
  begin
    if (CkStream_getDataAvailable(streamA) = True) then
      begin
        decompressedText := CkStream__readString(streamA);
        Memo1.Lines.Add(decompressedText);
      end;
  end;

// Let's make sure the background task finished and that the decompress was successful.
// It should already be the case that the task is finished.
while (CkTask_getFinished(task) <> True) do
  begin
    CkTask_SleepMs(task,20);
  end;

// The decompressor may have finished, but it is possible that data
// remains to be flushed.  
if (CkStream_getDataAvailable(streamA) = True) then
  begin
    decompressedText := CkStream__readString(streamA);
    Memo1.Lines.Add(decompressedText);
  end;

// Did streamA succeed in reading the entire file?
if (CkTask_getTaskSuccess(task) <> True) then
  begin
    Memo1.Lines.Add('async decompress failed:');
    Memo1.Lines.Add(CkTask__resultErrorText(task));
    success := False;
  end;

Memo1.Lines.Add('The async decompress was successful.');

CkFileAccess_Dispose(fac);
CkCompression_Dispose(compress);
CkStream_Dispose(streamC);
CkStream_Dispose(streamD);
CkStream_Dispose(streamA);

end;