123 lines
3.9 KiB
Rust
123 lines
3.9 KiB
Rust
use atomicmin::AtomicMin;
|
|
use error::PngError;
|
|
use miniz_oxide;
|
|
use std::cmp::max;
|
|
use zopfli;
|
|
use PngResult;
|
|
|
|
#[doc(hidden)]
|
|
pub mod miniz_stream;
|
|
|
|
/// Decompress a data stream using the DEFLATE algorithm
|
|
pub fn inflate(data: &[u8]) -> PngResult<Vec<u8>> {
|
|
miniz_oxide::inflate::decompress_to_vec_zlib(data)
|
|
.map_err(|e| PngError::new(&format!("Error on decompress: {:?}", e)))
|
|
}
|
|
|
|
/// Compress a data stream using the DEFLATE algorithm
|
|
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
|
|
pub fn deflate(data: &[u8], zc: u8, zs: u8, zw: u8, max_size: &AtomicMin) -> PngResult<Vec<u8>> {
|
|
if is_cfzlib_supported() {
|
|
return cfzlib_deflate(data, zc, zs, zw, max_size);
|
|
}
|
|
|
|
miniz_stream::compress_to_vec_oxipng(data, zc, zw.into(), zs.into(), max_size)
|
|
}
|
|
|
|
/// Compress a data stream using the DEFLATE algorithm
|
|
#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
|
|
pub fn deflate(data: &[u8], zc: u8, zs: u8, zw: u8, max_size: &AtomicMin) -> PngResult<Vec<u8>> {
|
|
miniz_stream::compress_to_vec_oxipng(data, zc, zw.into(), zs.into(), max_size)
|
|
}
|
|
|
|
#[cfg(target_arch = "x86_64")]
|
|
fn is_cfzlib_supported() -> bool {
|
|
if is_x86_feature_detected!("sse4.2") && is_x86_feature_detected!("pclmulqdq") {
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
|
|
#[cfg(target_arch = "aarch64")]
|
|
fn is_cfzlib_supported() -> bool {
|
|
if is_arm_feature_detected!("neon") && is_arm_feature_detected!("crc") {
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
|
|
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
|
|
pub fn cfzlib_deflate(
|
|
data: &[u8],
|
|
level: u8,
|
|
strategy: u8,
|
|
window_bits: u8,
|
|
max_size: &AtomicMin,
|
|
) -> PngResult<Vec<u8>> {
|
|
use cloudflare_zlib_sys::*;
|
|
use std::mem;
|
|
|
|
assert!(data.len() < u32::max_value() as usize);
|
|
unsafe {
|
|
let mut stream = mem::zeroed();
|
|
if Z_OK != deflateInit2(
|
|
&mut stream,
|
|
level.into(),
|
|
Z_DEFLATED,
|
|
window_bits.into(),
|
|
MAX_MEM_LEVEL,
|
|
strategy.into(),
|
|
) {
|
|
return Err(PngError::new("deflateInit2"));
|
|
}
|
|
|
|
let upper_bound = deflateBound(&mut stream, data.len() as uLong) as usize;
|
|
let max_size = max_size.get().unwrap_or(upper_bound).min(upper_bound);
|
|
// it's important to have the capacity pre-allocated,
|
|
// as unsafe set_len is called later
|
|
let mut out = Vec::with_capacity(max_size);
|
|
|
|
stream.next_in = data.as_ptr() as *mut _;
|
|
stream.total_in = data.len() as uLong;
|
|
stream.avail_in = data.len() as uInt;
|
|
stream.next_out = out.as_mut_ptr();
|
|
stream.avail_out = out.capacity() as uInt;
|
|
match deflate(&mut stream, Z_FINISH) {
|
|
Z_STREAM_END => {}
|
|
Z_OK | Z_BUF_ERROR => {
|
|
deflateEnd(&mut stream);
|
|
return Err(PngError::DeflatedDataTooLong(stream.total_out as usize));
|
|
}
|
|
_ => {
|
|
deflateEnd(&mut stream);
|
|
return Err(PngError::new("deflate"));
|
|
}
|
|
}
|
|
if Z_OK != deflateEnd(&mut stream) {
|
|
return Err(PngError::new("deflateEnd"));
|
|
}
|
|
debug_assert!(stream.total_out as usize <= out.capacity());
|
|
out.set_len(stream.total_out as usize);
|
|
Ok(out)
|
|
}
|
|
}
|
|
|
|
pub fn zopfli_deflate(data: &[u8]) -> PngResult<Vec<u8>> {
|
|
let mut output = Vec::with_capacity(max(1024, data.len() / 20));
|
|
let options = zopfli::Options::default();
|
|
match zopfli::compress(&options, &zopfli::Format::Zlib, data, &mut output) {
|
|
Ok(_) => (),
|
|
Err(_) => return Err(PngError::new("Failed to compress in zopfli")),
|
|
};
|
|
output.shrink_to_fit();
|
|
Ok(output)
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
/// DEFLATE algorithms supported by oxipng
|
|
pub enum Deflaters {
|
|
/// Use the Zlib/Miniz DEFLATE implementation
|
|
Zlib,
|
|
/// Use the better but slower Zopfli implementation
|
|
Zopfli,
|
|
}
|