Delphi ActiveX

Streaming Compression

See more Compression Examples

Compress and decompress using a stream. Delphi ActiveX

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

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Integer;
fac: TCkFileAccess;
compress: TChilkatCompression;
streamC: TChilkatStream;
streamD: TChilkatStream;
bFilesEqual: Integer;
streamA: TChilkatStream;
task: IChilkatTask;
decompressedText: WideString;

begin
success := 0;

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

fac := TCkFileAccess.Create(Self);
compress := TChilkatCompression.Create(Self);
compress.Algorithm := 'deflate';

streamC := TChilkatStream.Create(Self);

// 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..)
streamC.SourceFile := 'qa_data/hamlet.xml';
streamC.SinkFile := 'qa_output/hamlet_compressed.dat';

// Compress from source to sink.
success := compress.CompressStream(streamC.ControlInterface);
if (success <> 1) then
  begin
    Memo1.Lines.Add(compress.LastErrorText);
    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(fac.FileSize(streamC.SourceFile)));
Memo1.Lines.Add('Compressed size = ' + IntToStr(fac.FileSize(streamC.SinkFile)));

// Now do file-to-file decompression
streamD := TChilkatStream.Create(Self);
streamD.SourceFile := 'qa_output/hamlet_compressed.dat';
streamD.SinkFile := 'qa_output/hamlet_restored.xml';

// Decompress from source to sink.
success := compress.DecompressStream(streamD.ControlInterface);
if (success <> 1) then
  begin
    Memo1.Lines.Add(compress.LastErrorText);
    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 := fac.FileContentsEqual(streamC.SourceFile,streamD.SinkFile);
if (bFilesEqual <> 1) 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 := TChilkatStream.Create(Self);

streamA.SourceFile := 'qa_output/hamlet_compressed.dat';

// Start decompressing in a background thread.
task := compress.DecompressStreamAsync(streamA.ControlInterface);
success := task.Run();

// Read decompressed data from streamA:

while (streamA.EndOfStream <> 1) do
  begin
    if (streamA.DataAvailable = 1) then
      begin
        decompressedText := streamA.ReadString();
        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 (task.Finished <> 1) do
  begin
    task.SleepMs(20);
  end;

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

// Did streamA succeed in reading the entire file?
if (task.TaskSuccess <> 1) then
  begin
    Memo1.Lines.Add('async decompress failed:');
    Memo1.Lines.Add(task.ResultErrorText);
    success := 0;
  end;

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