Pascal (Lazarus/Delphi)

Streaming Compression

See more Compression Examples

Compress and decompress using a stream. Pascal (Lazarus/Delphi)

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.FileAccess,
  Chilkat.Task,
  Chilkat.Stream,
  Chilkat.Compression;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  fac: TFileAccess;
  compress: TCompression;
  streamC: TStream;
  streamD: TStream;
  bFilesEqual: Boolean;
  streamA: TStream;
  task: TTask;
  decompressedText: string;

begin
  success := False;

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

  fac := TFileAccess.Create;
  compress := TCompression.Create;
  compress.Algorithm := 'deflate';

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

  //  Compress from source to sink.
  success := compress.CompressStream(streamC);
  if (success <> True) then
    begin
      WriteLn(compress.LastErrorText);
      Exit;
    end;

  WriteLn('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.
  WriteLn('Original size = ' + fac.FileSize(streamC.SourceFile));
  WriteLn('Compressed size = ' + fac.FileSize(streamC.SinkFile));

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

  //  Decompress from source to sink.
  success := compress.DecompressStream(streamD);
  if (success <> True) then
    begin
      WriteLn(compress.LastErrorText);
      Exit;
    end;

  WriteLn('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 <> True) then
    begin
      WriteLn('The output file is not equal to the input file!');
    end
  else
    begin
      WriteLn('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 := TStream.Create;

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

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

  //  Read decompressed data from streamA:

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

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

  //  Did streamA succeed in reading the entire file?
  if (task.TaskSuccess <> True) then
    begin
      WriteLn('async decompress failed:');
      WriteLn(task.ResultErrorText);
      success := False;
    end;

  WriteLn('The async decompress was successful.');


  fac.Free;
  compress.Free;
  streamC.Free;
  streamD.Free;
  streamA.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.