minilz4 0.2.0

Minimal interface for the LZ4 compression library frame format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use libc::{c_char, c_uint, c_void, size_t};

pub const LZ4F_VERSION: c_uint = 100;

#[derive(Clone, Copy, Debug)]
#[repr(u32)]
pub enum BlockSize {
    Default  = 0,
    Max64KB  = 4,
    Max256KB = 5,
    Max1MB   = 6,
    Max4MB   = 7,
}
impl BlockSize {
    pub fn bytes(&self) -> usize {
        match self {
            BlockSize::Default => 64 * 1024,
            BlockSize::Max64KB => 64 * 1024,
            BlockSize::Max256KB => 256 * 1024,
            BlockSize::Max1MB => 1024 * 1024,
            BlockSize::Max4MB => 4096 * 1024,
        }
    }
}

#[derive(Clone, Copy)]
#[repr(u32)]
pub enum BlockMode {
    Linked      = 0,
    Independent = 1,
}

#[derive(Clone, Copy)]
#[repr(u32)]
pub enum ContentChecksum {
    NoChecksum      = 0,
    ChecksumEnabled = 1,
}

#[repr(C)]
pub struct LZ4FFrameInfo {
    pub block_size_id:         BlockSize,
    pub block_mode:            BlockMode,
    pub content_checksum_flag: ContentChecksum,
    pub reserved:              [c_uint; 5],
}

#[repr(C)]
pub struct LZ4FPreferences {
    pub frame_info:        LZ4FFrameInfo,
    pub compression_level: c_uint,
    pub auto_flush:        c_uint,
    pub reserved:          [c_uint; 4],
}

#[repr(C)]
pub struct LZ4FCompressOptions {
    pub stable_src: c_uint,
    pub reserved:   [c_uint; 3],
}

#[repr(C)]
pub struct LZ4FDecompressOptions {
    pub stable_dst: c_uint,
    pub reserved:   [c_uint; 3],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct LZ4FCDict(pub *mut c_void);
unsafe impl Send for LZ4FCDict {}
unsafe impl Sync for LZ4FCDict {}

pub type LZ4FCompressionContextPtr = *mut c_void;
pub type LZ4FDecompressionContextPtr = *mut c_void;

pub type LZ4FErrorCode = size_t;

extern "C" {
    pub fn LZ4F_isError(code: size_t) -> c_uint;
    pub fn LZ4F_getErrorName(code: size_t) -> *const c_char;
    pub fn LZ4F_createCompressionContext(
        ctx: &mut LZ4FCompressionContextPtr, version: c_uint,
    ) -> LZ4FErrorCode;
    pub fn LZ4F_freeCompressionContext(ctx: LZ4FCompressionContextPtr) -> LZ4FErrorCode;
    pub fn LZ4F_compressBegin(
        ctx: LZ4FCompressionContextPtr, dstBuffer: *mut u8, dstMaxSize: size_t,
        preferencesPtr: *const LZ4FPreferences,
    ) -> LZ4FErrorCode;
    pub fn LZ4F_compressBound(
        srcSize: size_t, preferencesPtr: *const LZ4FPreferences,
    ) -> LZ4FErrorCode;
    pub fn LZ4F_compressUpdate(
        ctx: LZ4FCompressionContextPtr, dstBuffer: *mut u8, dstMaxSize: size_t,
        srcBuffer: *const u8, srcSize: size_t, compressOptionsPtr: *const LZ4FCompressOptions,
    ) -> size_t;
    pub fn LZ4F_flush(
        ctx: LZ4FCompressionContextPtr, dstBuffer: *mut u8, dstMaxSize: size_t,
        compressOptionsPtr: *const LZ4FCompressOptions,
    ) -> LZ4FErrorCode;
    pub fn LZ4F_compressEnd(
        ctx: LZ4FCompressionContextPtr, dstBuffer: *mut u8, dstMaxSize: size_t,
        compressOptionsPtr: *const LZ4FCompressOptions,
    ) -> LZ4FErrorCode;
    pub fn LZ4F_createDecompressionContext(
        ctx: &mut LZ4FDecompressionContextPtr, version: c_uint,
    ) -> LZ4FErrorCode;
    pub fn LZ4F_freeDecompressionContext(ctx: LZ4FDecompressionContextPtr) -> LZ4FErrorCode;
    pub fn LZ4F_decompress(
        ctx: LZ4FDecompressionContextPtr, dstBuffer: *mut u8, dstSizePtr: &mut size_t,
        srcBuffer: *const u8, srcSizePtr: &mut size_t, optionsPtr: *const LZ4FDecompressOptions,
    ) -> LZ4FErrorCode;
}