#![allow(clippy::missing_safety_doc)]
use crate::ZEX_VERSION;
use crate::core::decoder::{DecompressOptions, decompress, decompress_with_options};
use crate::core::encoder::{CompressOptions, compress};
use crate::format::header::CompressionMode;
use alloc::vec::Vec;
use core::ffi::{c_char, c_int, c_void};
use core::ptr;
use core::slice;
pub const ZEXC_OK: c_int = 0;
pub const ZEXC_ERROR: c_int = -1;
pub const ZEXC_ERR_NULL: c_int = -2;
pub const ZEXC_ERR_PARAM: c_int = -3;
pub const ZEXC_ERR_NOMEM: c_int = -4;
pub const ZEXC_ERR_DATA: c_int = -5;
#[unsafe(no_mangle)]
pub extern "C" fn zexc_version() -> *const c_char {
static VER: &str = concat!(env!("CARGO_PKG_VERSION"), "\0");
VER.as_ptr() as *const c_char
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn zexc_free(p: *mut c_void, len: usize) {
if p.is_null() {
return;
}
let _ = unsafe { Vec::from_raw_parts(p as *mut u8, len, len) };
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn zexc_compress(
src: *const u8,
src_len: usize,
out: *mut *mut u8,
out_len: *mut usize,
level: c_int,
mode: c_int,
) -> c_int {
if out.is_null() || out_len.is_null() {
return ZEXC_ERR_NULL;
}
if src.is_null() && src_len != 0 {
return ZEXC_ERR_NULL;
}
let input = if src_len == 0 {
&[][..]
} else {
unsafe { slice::from_raw_parts(src, src_len) }
};
let lvl = if level <= 0 {
3
} else {
(level as u8).clamp(1, 22)
};
let m = match mode {
0 => CompressionMode::Turbo,
2 => CompressionMode::Max,
_ => CompressionMode::Balanced,
};
let opts = CompressOptions::default().mode(m).level(lvl).threads(false);
match compress(input, &opts) {
Ok(mut buf) => {
buf.shrink_to_fit();
let len = buf.len();
let ptr = buf.as_mut_ptr();
core::mem::forget(buf);
unsafe {
*out = ptr;
*out_len = len;
}
ZEXC_OK
}
Err(_) => ZEXC_ERROR,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn zexc_decompress(
src: *const u8,
src_len: usize,
out: *mut *mut u8,
out_len: *mut usize,
) -> c_int {
if out.is_null() || out_len.is_null() {
return ZEXC_ERR_NULL;
}
if src.is_null() || src_len == 0 {
return ZEXC_ERR_NULL;
}
let input = unsafe { slice::from_raw_parts(src, src_len) };
match decompress(input) {
Ok(mut buf) => {
buf.shrink_to_fit();
let len = buf.len();
let ptr = buf.as_mut_ptr();
core::mem::forget(buf);
unsafe {
*out = ptr;
*out_len = len;
}
ZEXC_OK
}
Err(crate::Error::CorruptBlock(_))
| Err(crate::Error::Decompression(_))
| Err(crate::Error::InvalidHeader(_))
| Err(crate::Error::ChecksumMismatch { .. }) => ZEXC_ERR_DATA,
Err(_) => ZEXC_ERROR,
}
}
#[unsafe(no_mangle)]
pub extern "C" fn zexc_compress_bound(src_len: usize) -> usize {
src_len
.saturating_add(src_len / 128)
.saturating_add(1024)
.saturating_add(64)
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn zexc_decompress_into(
src: *const u8,
src_len: usize,
dst: *mut u8,
dst_cap: usize,
) -> isize {
if src.is_null() || src_len == 0 {
return ZEXC_ERR_NULL as isize;
}
let input = unsafe { slice::from_raw_parts(src, src_len) };
let plain = match decompress_with_options(input, &DecompressOptions::default()) {
Ok(p) => p,
Err(_) => return ZEXC_ERR_DATA as isize,
};
if dst.is_null() {
return plain.len() as isize;
}
if plain.len() > dst_cap {
return ZEXC_ERR_NOMEM as isize;
}
unsafe {
ptr::copy_nonoverlapping(plain.as_ptr(), dst, plain.len());
}
plain.len() as isize
}
#[allow(dead_code)]
fn _ver() -> &'static str {
ZEX_VERSION
}