Rust高性能压缩库miniz_oxide_c_api的使用，提供跨平台DEFLATE压缩算法的轻量级Rust实现

miniz_oxide是一个纯Rust实现的miniz DEFLATE/zlib编码器/解码器替代品，不使用任何unsafe代码。它可以在no_std环境下构建，但需要使用alloc和collections crate。

主要特性

• 纯Rust实现，不使用unsafe代码
• 支持no_std环境
• 提供C API接口
• 轻量级DEFLATE压缩算法实现
• MIT许可证

版本要求

miniz_oxide 0.8.x需要至少Rust 1.56.0版本 miniz_oxide 0.7.x需要至少Rust 1.50.0版本

示例代码

use miniz_oxide::deflate::compress_to_vec;
use miniz_oxide::inflate::decompress_to_vec;

fn main() {
    // 原始数据
    let data = b"Hello, this is some test data to compress";
    
    // 压缩数据
    let compressed = compress_to_vec(data, 6);
    println!("Compressed size: {}", compressed.len());
    
    // 解压数据
    let decompressed = decompress_to_vec(&compressed).unwrap();
    assert_eq!(data, decompressed.as_slice());
    println!("Decompressed matches original!");
}

C API使用示例

miniz_oxide_c_api提供了C语言接口，可以用于C/C++项目中：

#include "miniz.h"  // 使用miniz_oxide_c_api提供的头文件

int main() {
    // 初始化压缩器
    tdefl_compressor *compressor = tdefl_compressor_alloc();
    
    const char *input = "Test data to compress";
    size_t input_size = strlen(input);
    
    // 预估最大输出大小
    size_t max_output_size = tdefl_compress_bound(input_size);
    void *output = malloc(max_output_size);
    
    // 压缩数据
    size_t compressed_size = max_output_size;
    tdefl_status status = tdefl_compress(compressor, input, &input_size, 
                                        output, &compressed_size, 
                                        TDEFL_WRITE_ZLIB_HEADER | TDEFL_DEFAULT_MAX_PROBES);
    
    if (status == TDEFL_STATUS_DONE) {
        printf("Compressed from %zu to %zu bytes\n", input_size, compressed_size);
    }
    
    // 释放资源
    free(output);
    tdefl_compressor_free(compressor);
    return 0;
}

构建和测试

# 运行测试
$ cargo test

# 运行基准测试
$ cargo bench --features=benching

在C/C++项目中使用

链接由build.sh生成的libminiz_oxide_c_api.a静态库，并使用miniz_oxide_c_api提供的miniz.h头文件。

许可证

该库(不包括用于测试的miniz C代码)采用MIT许可证。基于miniz C库的部分采用MIT许可证和非许可证双重许可。

完整示例demo

Rust完整示例

use miniz_oxide::deflate::{compress_to_vec, CompressionLevel};
use miniz_oxide::inflate::decompress_to_vec;

fn main() {
    // 原始数据
    let data = b"This is a longer text to demonstrate compression and decompression with miniz_oxide in Rust. It contains more data to show the compression ratio and performance.";
    
    // 压缩数据 - 使用默认压缩级别6
    let compressed_default = compress_to_vec(data, 6);
    println!("Default compression (level 6): {} -> {} bytes", data.len(), compressed_default.len());
    
    // 压缩数据 - 使用最快压缩级别1
    let compressed_fast = compress_to_vec(data, 1);
    println!("Fast compression (level 1): {} -> {} bytes", data.len(), compressed_fast.len());
    
    // 压缩数据 - 使用最佳压缩级别9
    let compressed_best = compress_to_vec(data, 9);
    println!("Best compression (level 9): {} -> {} bytes", data.len(), compressed_best.len());
    
    // 解压数据
    let decompressed = decompress_to_vec(&compressed_best).unwrap();
    assert_eq!(data, decompressed.as_slice());
    println!("Decompressed successfully, matches original data!");
    
    // 打印压缩比
    println!("Compression ratio (best): {:.2}%", 
        (compressed_best.len() as f32 / data.len() as f32) * 100.0);
}

C语言完整示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "miniz.h"  // miniz_oxide_c_api提供的头文件

int main() {
    // 初始化压缩器
    tdefl_compressor *compressor = tdefl_compressor_alloc();
    if (!compressor) {
        fprintf(stderr, "Failed to allocate compressor\n");
        return 1;
    }
    
    const char *input = "This is a sample text to demonstrate miniz_oxide C API compression and decompression functionality.";
    size_t input_size = strlen(input);
    
    // 预估最大输出大小并分配内存
    size_t max_output_size = tdefl_compress_bound(input_size);
    void *compressed_output = malloc(max_output_size);
    if (!compressed_output) {
        fprintf(stderr, "Memory allocation failed\n");
        tdefl_compressor_free(compressor);
        return 1;
    }
    
    // 压缩数据
    size_t compressed_size = max_output_size;
    tdefl_status status = tdefl_compress(
        compressor, 
        input, 
        &input_size,
        compressed_output, 
        &compressed_size,
        TDEFL_WRITE_ZLIB_HEADER | TDEFL_DEFAULT_MAX_PROBES
    );
    
    if (status != TDEFL_STATUS_DONE) {
        fprintf(stderr, "Compression failed with status: %d\n", status);
        free(compressed_output);
        tdefl_compressor_free(compressor);
        return 1;
    }
    
    printf("Original size: %zu, Compressed size: %zu\n", input_size, compressed_size);
    
    // 初始化解压器
    tinfl_decompressor *decompressor = tinfl_decompressor_alloc();
    if (!decompressor) {
        fprintf(stderr, "Failed to allocate decompressor\n");
        free(compressed_output);
        tdefl_compressor_free(compressor);
        return 1;
    }
    
    // 预估解压后大小并分配内存
    size_t decompressed_size = input_size;  // 我们知道原始大小
    void *decompressed_output = malloc(decompressed_size);
    if (!decompressed_output) {
        fprintf(stderr, "Memory allocation failed\n");
        free(compressed_output);
        tdefl_compressor_free(compressor);
        tinfl_decompressor_free(decompressor);
        return 1;
    }
    
    // 解压数据
    size_t in_bytes = compressed_size;
    size_t out_bytes = decompressed_size;
    tinfl_status decomp_status = tinfl_decompress(
        decompressor,
        compressed_output,
        &in_bytes,
        decompressed_output,
        &out_bytes,
        TINFL_FLAG_PARSE_ZLIB_HEADER
    );
    
    if (decomp_status != TINFL_STATUS_DONE) {
        fprintf(stderr, "Decompression failed with status: %d\n", decomp_status);
    } else {
        printf("Decompressed successfully. Original and decompressed data match: %s\n", 
               memcmp(input, decompressed_output, input_size) == 0 ? "true" : "false");
    }
    
    // 释放所有资源
    free(compressed_output);
    free(decompressed_output);
    tdefl_compressor_free(compressor);
    tinfl_decompressor_free(decompressor);
    
    return 0;
}