lz4-sys-1.9.4/.cargo_vcs_info.json0000644000000001450000000000100123740ustar { "git": { "sha1": "0abc0a52af1f6010f9a57640b1dc8eb8d2d697aa" }, "path_in_vcs": "lz4-sys" }lz4-sys-1.9.4/CHANGELOG.md000064400000000000000000000002611046102023000127740ustar 000000000000001.7.5: * Change version number 1.0.1+1.7.5: * Update lz4 to v1.7.5 #18 (thanks to Roguelazer) 1.0.1+1.7.3: * Split out separate sys package #16 (thanks to Thijs Cadier) lz4-sys-1.9.4/Cargo.toml0000644000000015620000000000100103760ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] name = "lz4-sys" version = "1.9.4" authors = [ "Jens Heyens ", "Artem V. Navrotskiy ", "Patrick Marks ", ] build = "build.rs" links = "lz4" description = "Rust LZ4 sys package." license = "MIT" repository = "https://github.com/10xGenomics/lz4-rs" [dependencies.libc] version = "0.2.44" [build-dependencies.cc] version = "1.0.25" lz4-sys-1.9.4/Cargo.toml.orig0000644000000006010000000000100113260ustar [package] name = "lz4-sys" license = "MIT" links = "lz4" version = "1.9.4" authors = [ "Jens Heyens ", "Artem V. Navrotskiy ", "Patrick Marks "] build = "build.rs" description = "Rust LZ4 sys package." repository = "https://github.com/10xGenomics/lz4-rs" [dependencies] libc = "0.2.44" [build-dependencies] cc = "1.0.25" lz4-sys-1.9.4/Cargo.toml.orig000064400000000000000000000006011046102023000140500ustar 00000000000000[package] name = "lz4-sys" license = "MIT" links = "lz4" version = "1.9.4" authors = [ "Jens Heyens ", "Artem V. Navrotskiy ", "Patrick Marks "] build = "build.rs" description = "Rust LZ4 sys package." repository = "https://github.com/10xGenomics/lz4-rs" [dependencies] libc = "0.2.44" [build-dependencies] cc = "1.0.25" lz4-sys-1.9.4/build.rs000064400000000000000000000050251046102023000126330ustar 00000000000000extern crate cc; use std::error::Error; use std::path::PathBuf; use std::{env, fs, process}; fn main() { match run() { Ok(()) => (), Err(err) => { eprintln!("{}", err); process::exit(1); } } } fn run() -> Result<(), Box> { let mut compiler = cc::Build::new(); compiler .file("liblz4/lib/lz4.c") .file("liblz4/lib/lz4frame.c") .file("liblz4/lib/lz4hc.c") .file("liblz4/lib/xxhash.c") // We always compile the C with optimization, because otherwise it is 20x slower. .opt_level(3); let target = get_from_env("TARGET")?; if target.contains("windows") { if target == "i686-pc-windows-gnu" { // Disable auto-vectorization for 32-bit MinGW target. compiler.flag("-fno-tree-vectorize"); } if let Ok(value) = get_from_env("CRT_STATIC") { if value.to_uppercase() == "TRUE" { // Must supply the /MT compiler flag to use the multi-threaded, static VCRUNTIME library // when building on Windows. Cargo does not pass RUSTFLAGS to build scripts // (see: https://github.com/rust-lang/cargo/issues/4423) so we must use a custom env // variable "CRT_STATIC." compiler.static_crt(true); } } } compiler.compile("liblz4.a"); let src = env::current_dir()?.join("liblz4").join("lib"); let dst = PathBuf::from(env::var_os("OUT_DIR").ok_or("missing OUT_DIR environment variable")?); let include = dst.join("include"); fs::create_dir_all(&include) .map_err(|err| format!("creating directory {}: {}", include.display(), err))?; for e in fs::read_dir(&src)? { let e = e?; let utf8_file_name = e .file_name() .into_string() .map_err(|_| format!("unable to convert file name {:?} to UTF-8", e.file_name()))?; if utf8_file_name.ends_with(".h") { let from = e.path(); let to = include.join(e.file_name()); fs::copy(&from, &to).map_err(|err| { format!("copying {} to {}: {}", from.display(), to.display(), err) })?; } } println!("cargo:root={}", dst.display()); println!("cargo:include={}", include.display()); Ok(()) } /// Try to read environment variable as `String` fn get_from_env(variable: &str) -> Result { env::var(variable).map_err(|err| format!("reading {} environment variable: {}", variable, err)) } lz4-sys-1.9.4/src/lib.rs000064400000000000000000000436561046102023000131050ustar 00000000000000#![no_std] extern crate libc; #[cfg(not(all( target_arch = "wasm32", not(any(target_env = "wasi", target_os = "wasi")) )))] use libc::{c_void, c_char, c_uint, size_t, c_int}; #[cfg(all( target_arch = "wasm32", not(any(target_env = "wasi", target_os = "wasi")) ))] extern crate std; #[cfg(all( target_arch = "wasm32", not(any(target_env = "wasi", target_os = "wasi")) ))] use std::os::raw::{c_void, c_char, c_uint, c_int}; #[cfg(all( target_arch = "wasm32", not(any(target_env = "wasi", target_os = "wasi")) ))] #[allow(non_camel_case_types)] type size_t = usize; #[derive(Clone, Copy, Debug)] #[repr(C)] pub struct LZ4FCompressionContext(pub *mut c_void); unsafe impl Send for LZ4FCompressionContext {} #[derive(Clone, Copy, Debug)] #[repr(C)] pub struct LZ4FDecompressionContext(pub *mut c_void); unsafe impl Send for LZ4FDecompressionContext {} pub type LZ4FErrorCode = size_t; #[derive(Clone, Debug)] #[repr(u32)] pub enum BlockSize { Default = 0, // Default - 64KB Max64KB = 4, Max256KB = 5, Max1MB = 6, Max4MB = 7, } impl BlockSize { pub fn get_size(&self) -> usize { match self { &BlockSize::Default | &BlockSize::Max64KB => 64 * 1024, &BlockSize::Max256KB => 256 * 1024, &BlockSize::Max1MB => 1 * 1024 * 1024, &BlockSize::Max4MB => 4 * 1024 * 1024, } } } #[derive(Clone, Debug)] #[repr(u32)] pub enum BlockMode { Linked = 0, Independent, } #[derive(Clone, Debug)] #[repr(u32)] pub enum ContentChecksum { NoChecksum = 0, ChecksumEnabled, } #[derive(Debug)] #[repr(C)] pub struct LZ4FFrameInfo { pub block_size_id: BlockSize, pub block_mode: BlockMode, pub content_checksum_flag: ContentChecksum, pub reserved: [c_uint; 5], } #[derive(Debug)] #[repr(C)] pub struct LZ4FPreferences { pub frame_info: LZ4FFrameInfo, pub compression_level: c_uint, // 0 == default (fast mode); values above 16 count as 16 pub auto_flush: c_uint, // 1 == always flush : reduce need for tmp buffer pub favor_dec_speed: c_uint, // 1 == favor decompression speed over ratio, requires level 10+ pub reserved: [c_uint; 3], } #[derive(Debug)] #[repr(C)] pub struct LZ4FCompressOptions { pub stable_src: c_uint, /* 1 == src content will remain available on future calls * to LZ4F_compress(); avoid saving src content within tmp * buffer as future dictionary */ pub reserved: [c_uint; 3], } #[derive(Debug)] #[repr(C)] pub struct LZ4FDecompressOptions { pub stable_dst: c_uint, /* guarantee that decompressed data will still be there on next * function calls (avoid storage into tmp buffers) */ pub reserved: [c_uint; 3], } #[derive(Debug)] #[repr(C)] pub struct LZ4StreamEncode(c_void); #[derive(Debug)] #[repr(C)] pub struct LZ4StreamDecode(c_void); pub const LZ4F_VERSION: c_uint = 100; extern "C" { // int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize); #[allow(non_snake_case)] pub fn LZ4_compress_default (source: *const c_char, dest: *mut c_char, sourceSize: c_int, maxDestSize: c_int) -> c_int; // int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration); #[allow(non_snake_case)] pub fn LZ4_compress_fast (source: *const c_char, dest: *mut c_char, sourceSize: c_int, maxDestSize: c_int, acceleration: c_int) -> c_int; // int LZ4_compress_HC (const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel); #[allow(non_snake_case)] pub fn LZ4_compress_HC (src: *const c_char, dst: *mut c_char, srcSize: c_int, dstCapacity: c_int, compressionLevel: c_int) -> c_int; // int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize); #[allow(non_snake_case)] pub fn LZ4_decompress_safe (source: *const c_char, dest: *mut c_char, compressedSize: c_int, maxDecompressedSize: c_int) -> c_int; // unsigned LZ4F_isError(LZ4F_errorCode_t code); pub fn LZ4F_isError(code: size_t) -> c_uint; // const char* LZ4F_getErrorName(LZ4F_errorCode_t code); pub fn LZ4F_getErrorName(code: size_t) -> *const c_char; // LZ4F_createCompressionContext() : // The first thing to do is to create a compressionContext object, which will be used in all // compression operations. // This is achieved using LZ4F_createCompressionContext(), which takes as argument a version // and an LZ4F_preferences_t structure. // The version provided MUST be LZ4F_VERSION. It is intended to track potential version // differences between different binaries. // The function will provide a pointer to a fully allocated LZ4F_compressionContext_t object. // If the result LZ4F_errorCode_t is not zero, there was an error during context creation. // Object can release its memory using LZ4F_freeCompressionContext(); // // LZ4F_errorCode_t LZ4F_createCompressionContext( // LZ4F_compressionContext_t* LZ4F_compressionContextPtr, // unsigned version); pub fn LZ4F_createCompressionContext(ctx: &mut LZ4FCompressionContext, version: c_uint) -> LZ4FErrorCode; // LZ4F_errorCode_t LZ4F_freeCompressionContext( // LZ4F_compressionContext_t LZ4F_compressionContext); pub fn LZ4F_freeCompressionContext(ctx: LZ4FCompressionContext) -> LZ4FErrorCode; // LZ4F_compressBegin() : // will write the frame header into dstBuffer. // dstBuffer must be large enough to accommodate a header (dstMaxSize). Maximum header // size is 19 bytes. // The LZ4F_preferences_t structure is optional : you can provide NULL as argument, all // preferences will then be set to default. // The result of the function is the number of bytes written into dstBuffer for the header // or an error code (can be tested using LZ4F_isError()) // // size_t LZ4F_compressBegin(LZ4F_compressionContext_t compressionContext, // void* dstBuffer, // size_t dstMaxSize, // const LZ4F_preferences_t* preferencesPtr); pub fn LZ4F_compressBegin(ctx: LZ4FCompressionContext, dstBuffer: *mut u8, dstMaxSize: size_t, preferencesPtr: *const LZ4FPreferences) -> LZ4FErrorCode; // LZ4F_compressBound() : // Provides the minimum size of Dst buffer given srcSize to handle worst case situations. // preferencesPtr is optional : you can provide NULL as argument, all preferences will then // be set to default. // Note that different preferences will produce in different results. // // size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr); pub fn LZ4F_compressBound(srcSize: size_t, preferencesPtr: *const LZ4FPreferences) -> LZ4FErrorCode; // LZ4F_compressUpdate() // LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary. // The most important rule is that dstBuffer MUST be large enough (dstMaxSize) to ensure // compression completion even in worst case. // If this condition is not respected, LZ4F_compress() will fail (result is an errorCode) // You can get the minimum value of dstMaxSize by using LZ4F_compressBound() // The LZ4F_compressOptions_t structure is optional : you can provide NULL as argument. // The result of the function is the number of bytes written into dstBuffer : it can be zero, // meaning input data was just buffered. // The function outputs an error code if it fails (can be tested using LZ4F_isError()) // // size_t LZ4F_compressUpdate(LZ4F_compressionContext_t compressionContext, // void* dstBuffer, // size_t dstMaxSize, // const void* srcBuffer, // size_t srcSize, // const LZ4F_compressOptions_t* compressOptionsPtr); pub fn LZ4F_compressUpdate(ctx: LZ4FCompressionContext, dstBuffer: *mut u8, dstMaxSize: size_t, srcBuffer: *const u8, srcSize: size_t, compressOptionsPtr: *const LZ4FCompressOptions) -> size_t; // LZ4F_flush() // Should you need to create compressed data immediately, without waiting for a block // to be be filled, you can call LZ4_flush(), which will immediately compress any remaining // data buffered within compressionContext. // The LZ4F_compressOptions_t structure is optional : you can provide NULL as argument. // The result of the function is the number of bytes written into dstBuffer // (it can be zero, this means there was no data left within compressionContext) // The function outputs an error code if it fails (can be tested using LZ4F_isError()) // // size_t LZ4F_flush(LZ4F_compressionContext_t compressionContext, // void* dstBuffer, // size_t dstMaxSize, // const LZ4F_compressOptions_t* compressOptionsPtr); pub fn LZ4F_flush(ctx: LZ4FCompressionContext, dstBuffer: *mut u8, dstMaxSize: size_t, compressOptionsPtr: *const LZ4FCompressOptions) -> LZ4FErrorCode; // LZ4F_compressEnd() // When you want to properly finish the compressed frame, just call LZ4F_compressEnd(). // It will flush whatever data remained within compressionContext (like LZ4_flush()) // but also properly finalize the frame, with an endMark and a checksum. // The result of the function is the number of bytes written into dstBuffer // (necessarily >= 4 (endMark size)) // The function outputs an error code if it fails (can be tested using LZ4F_isError()) // The LZ4F_compressOptions_t structure is optional : you can provide NULL as argument. // compressionContext can then be used again, starting with LZ4F_compressBegin(). // // size_t LZ4F_compressEnd(LZ4F_compressionContext_t compressionContext, // void* dstBuffer, // size_t dstMaxSize, // const LZ4F_compressOptions_t* compressOptionsPtr); pub fn LZ4F_compressEnd(ctx: LZ4FCompressionContext, dstBuffer: *mut u8, dstMaxSize: size_t, compressOptionsPtr: *const LZ4FCompressOptions) -> LZ4FErrorCode; // LZ4F_createDecompressionContext() : // The first thing to do is to create a decompressionContext object, which will be used // in all decompression operations. // This is achieved using LZ4F_createDecompressionContext(). // The version provided MUST be LZ4F_VERSION. It is intended to track potential version // differences between different binaries. // The function will provide a pointer to a fully allocated and initialized // LZ4F_decompressionContext_t object. // If the result LZ4F_errorCode_t is not OK_NoError, there was an error during // context creation. // Object can release its memory using LZ4F_freeDecompressionContext(); // // LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_decompressionContext_t* ctxPtr, // unsigned version); pub fn LZ4F_createDecompressionContext(ctx: &mut LZ4FDecompressionContext, version: c_uint) -> LZ4FErrorCode; // LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_decompressionContext_t ctx); pub fn LZ4F_freeDecompressionContext(ctx: LZ4FDecompressionContext) -> LZ4FErrorCode; // LZ4F_getFrameInfo() // This function decodes frame header information, such as blockSize. // It is optional : you could start by calling directly LZ4F_decompress() instead. // The objective is to extract header information without starting decompression, typically // for allocation purposes. // LZ4F_getFrameInfo() can also be used *after* starting decompression, on a // valid LZ4F_decompressionContext_t. // The number of bytes read from srcBuffer will be provided within *srcSizePtr // (necessarily <= original value). // You are expected to resume decompression from where it stopped (srcBuffer + *srcSizePtr) // The function result is an hint of how many srcSize bytes LZ4F_decompress() expects for // next call, or an error code which can be tested using LZ4F_isError(). // // size_t LZ4F_getFrameInfo(LZ4F_decompressionContext_t ctx, // LZ4F_frameInfo_t* frameInfoPtr, // const void* srcBuffer, size_t* srcSizePtr); pub fn LZ4F_getFrameInfo(ctx: LZ4FDecompressionContext, frameInfoPtr: &mut LZ4FFrameInfo, srcBuffer: *const u8, srcSizePtr: &mut size_t) -> LZ4FErrorCode; // LZ4F_decompress() // Call this function repetitively to regenerate data compressed within srcBuffer. // The function will attempt to decode *srcSizePtr bytes from srcBuffer, into dstBuffer of // maximum size *dstSizePtr. // // The number of bytes regenerated into dstBuffer will be provided within *dstSizePtr // (necessarily <= original value). // // The number of bytes read from srcBuffer will be provided within *srcSizePtr // (necessarily <= original value). // If number of bytes read is < number of bytes provided, then decompression operation // is not completed. It typically happens when dstBuffer is not large enough to contain // all decoded data. // LZ4F_decompress() must be called again, starting from where it stopped // (srcBuffer + *srcSizePtr) // The function will check this condition, and refuse to continue if it is not respected. // // dstBuffer is supposed to be flushed between each call to the function, since its content // will be overwritten. // dst arguments can be changed at will with each consecutive call to the function. // // The function result is an hint of how many srcSize bytes LZ4F_decompress() expects for // next call. // Schematically, it's the size of the current (or remaining) compressed block + header of // next block. // Respecting the hint provides some boost to performance, since it does skip intermediate // buffers. // This is just a hint, you can always provide any srcSize you want. // When a frame is fully decoded, the function result will be 0. (no more data expected) // If decompression failed, function result is an error code, which can be tested // using LZ4F_isError(). // // size_t LZ4F_decompress(LZ4F_decompressionContext_t ctx, // void* dstBuffer, size_t* dstSizePtr, // const void* srcBuffer, size_t* srcSizePtr, // const LZ4F_decompressOptions_t* optionsPtr); pub fn LZ4F_decompress(ctx: LZ4FDecompressionContext, dstBuffer: *mut u8, dstSizePtr: &mut size_t, srcBuffer: *const u8, srcSizePtr: &mut size_t, optionsPtr: *const LZ4FDecompressOptions) -> LZ4FErrorCode; // int LZ4_versionNumber(void) pub fn LZ4_versionNumber() -> c_int; // int LZ4_compressBound(int isize) pub fn LZ4_compressBound(size: c_int) -> c_int; // LZ4_stream_t* LZ4_createStream(void) pub fn LZ4_createStream() -> *mut LZ4StreamEncode; // int LZ4_compress_continue(LZ4_stream_t* LZ4_streamPtr, // const char* source, // char* dest, // int inputSize) pub fn LZ4_compress_continue(LZ4_stream: *mut LZ4StreamEncode, source: *const u8, dest: *mut u8, input_size: c_int) -> c_int; // int LZ4_freeStream(LZ4_stream_t* LZ4_streamPtr) pub fn LZ4_freeStream(LZ4_stream: *mut LZ4StreamEncode) -> c_int; // LZ4_streamDecode_t* LZ4_createStreamDecode(void) pub fn LZ4_createStreamDecode() -> *mut LZ4StreamDecode; // int LZ4_decompress_safe_continue(LZ4_streamDecode_t* LZ4_streamDecode, // const char* source, // char* dest, // int compressedSize, // int maxDecompressedSize) pub fn LZ4_decompress_safe_continue(LZ4_stream: *mut LZ4StreamDecode, source: *const u8, dest: *mut u8, compressed_size: c_int, max_decompressed_size: c_int) -> c_int; // int LZ4_freeStreamDecode(LZ4_streamDecode_t* LZ4_stream) pub fn LZ4_freeStreamDecode(LZ4_stream: *mut LZ4StreamDecode) -> c_int; // LZ4F_resetDecompressionContext() // In case of an error, the context is left in "undefined" state. // In which case, it's necessary to reset it, before re-using it. // This method can also be used to abruptly stop any unfinished decompression, // and start a new one using same context resources. pub fn LZ4F_resetDecompressionContext(ctx: LZ4FDecompressionContext); } #[test] fn test_version_number() { unsafe { LZ4_versionNumber(); } }