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;
}