Perl

Streaming Compression

See more Compression Examples

Compress and decompress using a stream. Perl

use chilkat();

$success = 0;

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

$fac = chilkat::CkFileAccess->new();
$compress = chilkat::CkCompression->new();
$compress->put_Algorithm("deflate");

$streamC = chilkat::CkStream->new();

# 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->put_SourceFile("qa_data/hamlet.xml");
$streamC->put_SinkFile("qa_output/hamlet_compressed.dat");

# Compress from source to sink.
$success = $compress->CompressStream($streamC);
if ($success != 1) {
    print $compress->lastErrorText() . "\r\n";
    exit;
}

print "File-to-file deflate compression successful." . "\r\n";
# 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.
print "Original size = " . $fac->FileSize($streamC->sourceFile()) . "\r\n";
print "Compressed size = " . $fac->FileSize($streamC->sinkFile()) . "\r\n";

# Now do file-to-file decompression
$streamD = chilkat::CkStream->new();
$streamD->put_SourceFile("qa_output/hamlet_compressed.dat");
$streamD->put_SinkFile("qa_output/hamlet_restored.xml");

# Decompress from source to sink.
$success = $compress->DecompressStream($streamD);
if ($success != 1) {
    print $compress->lastErrorText() . "\r\n";
    exit;
}

print "File-to-file deflate decompression successful." . "\r\n";

# 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) {
    print "The output file is not equal to the input file!" . "\r\n";
}
else {
    print "The file was successfully compressed and decompressed." . "\r\n";
}

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

$streamA->put_SourceFile("qa_output/hamlet_compressed.dat");

# Start decompressing in a background thread.
# task is a Task
$task = $compress->DecompressStreamAsync($streamA);
$success = $task->Run();

# Read decompressed data from streamA:

while (($streamA->get_EndOfStream() != 1)) {
    if ($streamA->get_DataAvailable() == 1) {
        $decompressedText = $streamA->readString();
        print $decompressedText . "\r\n";
    }

}

# 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->get_Finished() != 1)) {
    $task->SleepMs(20);
}

# The decompressor may have finished, but it is possible that data
# remains to be flushed.  
if ($streamA->get_DataAvailable() == 1) {
    $decompressedText = $streamA->readString();
    print $decompressedText . "\r\n";
}

# Did streamA succeed in reading the entire file?
if ($task->get_TaskSuccess() != 1) {
    print "async decompress failed:" . "\r\n";
    print $task->resultErrorText() . "\r\n";
    $success = 0;
}

print "The async decompress was successful." . "\r\n";