(Tcl) Streaming Compression

Compress and decompress using a stream.

Chilkat Tcl Extension Downloads Chilkat Tcl Extension Downloads

load ./chilkat.dll

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

set fac [new_CkFileAccess]

set compress [new_CkCompression]

CkCompression_put_Algorithm $compress "deflate"

set streamC [new_CkStream]

# 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_put_SourceFile $streamC "qa_data/hamlet.xml"
CkStream_put_SinkFile $streamC "qa_output/hamlet_compressed.dat"

# Compress from source to sink.
set success [CkCompression_CompressStream $compress $streamC]
if {$success != 1} then {
    puts [CkCompression_lastErrorText $compress]
    delete_CkFileAccess $fac
    delete_CkCompression $compress
    delete_CkStream $streamC
    exit
}

puts "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.
puts "Original size = [CkFileAccess_FileSize $fac [CkStream_sourceFile $streamC]]"
puts "Compressed size = [CkFileAccess_FileSize $fac [CkStream_sinkFile $streamC]]"

# Now do file-to-file decompression
set streamD [new_CkStream]

CkStream_put_SourceFile $streamD "qa_output/hamlet_compressed.dat"
CkStream_put_SinkFile $streamD "qa_output/hamlet_restored.xml"

# Decompress from source to sink.
set success [CkCompression_DecompressStream $compress $streamD]
if {$success != 1} then {
    puts [CkCompression_lastErrorText $compress]
    delete_CkFileAccess $fac
    delete_CkCompression $compress
    delete_CkStream $streamC
    delete_CkStream $streamD
    exit
}

puts "File-to-file deflate decompression successful."

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

set bFilesEqual [CkFileAccess_FileContentsEqual $fac [CkStream_sourceFile $streamC] [CkStream_sinkFile $streamD]]
if {$bFilesEqual != 1} then {
    puts "The output file is not equal to the input file!"
} else {
    puts "The file was successfully compressed and decompressed."
}

# ---------------------------------------------------------------------
# Now let's decompress again, but this time w/ the application reading
# the decompressed data directly from a stream.
set streamA [new_CkStream]

CkStream_put_SourceFile $streamA "qa_output/hamlet_compressed.dat"

# Start decompressing in a background thread.
# task is a CkTask
set task [CkCompression_DecompressStreamAsync $compress $streamA]
set success [CkTask_Run $task]

# Read decompressed data from streamA:

while {[CkStream_get_EndOfStream $streamA] != 1} {
    if {[CkStream_get_DataAvailable $streamA] == 1} then {
        set decompressedText [CkStream_readString $streamA]
        puts "$decompressedText"
    }

}

# 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_get_Finished $task] != 1} {
    CkTask_SleepMs $task 20
}

# The decompressor may have finished, but it is possible that data
# remains to be flushed.  
if {[CkStream_get_DataAvailable $streamA] == 1} then {
    set decompressedText [CkStream_readString $streamA]
    puts "$decompressedText"
}

# Did streamA succeed in reading the entire file?
if {[CkTask_get_TaskSuccess $task] != 1} then {
    puts "async decompress failed:"
    puts [CkTask_resultErrorText $task]
    set success 0
}

puts "The async decompress was successful."

delete_CkFileAccess $fac
delete_CkCompression $compress
delete_CkStream $streamC
delete_CkStream $streamD
delete_CkStream $streamA