lz4-rs: Rust LZ4 Bindings

To decompress LZ4 frames, use the LZ4F_decompressionContext.

Workflow:

1. Create a context using LZ4F_createDecompressionContext with LZ4F_VERSION.
2. (Optional) Use LZ4F_getFrameInfo to decode header information (like block size) without starting decompression.
3. Decompress data using LZ4F_decompress. This function returns a hint of how many bytes are expected in the next call. When it returns 0, the frame is fully decoded.
4. Free the context with LZ4F_freeDecompressionContext.

// 1. Create context
let mut ctx = LZ4FDecompressionContext(std::ptr::null_mut());
unsafe { LZ4F_createDecompressionContext(&mut ctx, LZ4F_VERSION) };

// 2. Decompress
// dst_size and src_size are updated by the function
let result = unsafe { LZ4F_decompress(ctx, dst_buffer, &mut dst_size, src_buffer, &mut src_size, &options) };

if result == 0 { /* Frame fully decoded */ }

// 3. Cleanup
unsafe { LZ4F_freeDecompressionContext(ctx) };

The Frame API is used for compressing data into a formal LZ4 frame format, which includes headers and checksums. This is suitable for streaming data or creating files.

Workflow:

1. Create a context using LZ4F_createCompressionContext with LZ4F_VERSION.
2. Initialize the frame with LZ4F_compressBegin (writes the header).
3. Feed data using LZ4F_compressUpdate (can be called repeatedly).
4. Optionally use LZ4F_flush to compress buffered data without finishing the frame.
5. Finalize the frame with LZ4F_compressEnd (writes end mark and checksum).
6. Free the context with LZ4F_freeCompressionContext.

// 1. Create context
let mut ctx = LZ4FCompressionContext(std::ptr::null_mut());
let res = unsafe { LZ4F_createCompressionContext(&mut ctx, LZ4F_VERSION) };

// 2. Begin frame (writes header to dst_buffer)
let header_size = unsafe { LZ4F_compressBegin(ctx, dst_buffer, dst_max_size, &preferences) };

// 3. Update (compress data blocks)
let bytes_written = unsafe { LZ4F_compressUpdate(ctx, dst_buffer, dst_max_size, src_buffer, src_size, &options) };

// 4. End frame (finalizes frame, flushes, and writes end mark)
let end_size = unsafe { LZ4F_compressEnd(ctx, dst_buffer, dst_max_size, &options) };

// 5. Cleanup
unsafe { LZ4F_freeCompressionContext(ctx) };

You can perform lossless compression using EncoderBuilder and decompression using Decoder.

Compression

Use EncoderBuilder::new() to configure compression settings (such as compression level) before calling .build(destination) to create an encoder. After writing data to the encoder, call .finish() to finalize the compression process and retrieve the result.

Decompression

Use Decoder::new(source) to create a decoder from a source (such as a File). The decoder implements Read, allowing you to use standard I/O utilities like io::copy to decompress data into a destination.

extern crate lz4;

use std::fs::File;
use std::io::{self, Result};
use std::path::{Path};
use lz4::{Decoder, EncoderBuilder};

fn compress(source: &Path, destination: &Path) -> Result<()> {
    let mut input_file = File::open(source)?;
    let output_file = File::create(destination)?;
    
    // Build an encoder with a specific compression level
    let mut encoder = EncoderBuilder::new()
        .level(4)
        .build(output_file)?;
    
    io::copy(&mut input_file, &mut encoder)?;
    
    // Finalize the compression
    let (_output, result) = encoder.finish();
    result
}

fn decompress(source: &Path, destination: &Path) -> Result<()> {
    let input_file = File::open(source)?;
    
    // Create a decoder from the input file
    let mut decoder = Decoder::new(input_file)?;
    let mut output_file = File::create(destination)?;
    
    io::copy(&mut decoder, &mut output_file)?;

    Ok(())
}