84bbec0666
* Update and optimize dependencies These changes update the dependencies to their latest versions, fixing some known issues that prevented doing so in the first place. In addition, the direct dependency on byteorder was dropped in favor of stdlib functions that have been stabilized for some time in Rust, and the transitive dependency on chrono, pulled by stderrlog, was also dropped, which had been affected by security issues and improperly maintained in the past: - https://github.com/cardoe/stderrlog-rs/issues/31 - https://www.reddit.com/r/rust/comments/ts84n4/chrono_or_time_03/ * Run rustfmt * Bump MSRV to 1.56.1 Updating to this patch version should not be cumbersome for end-users, and it is required by a transitive dependency. * Bump MSRV to 1.57.0 os_str_bytes requires it. * Add initial support for changing Zopfli iterations PR https://github.com/shssoichiro/oxipng/pull/445 did some dependency updates, which included using the latest zopfli version. The latest version of this crate exposes new options in its API that allow users to choose the desired number of Zopfli compression iterations, which may greatly affect execution time. In fact, other optimizers such as zopflipng dynamically select this number depending on the input file size (see: https://github.com/shssoichiro/oxipng/issues/414). As a first step towards making OxiPNG deal with Zopfli better, let's add the necessary options for libraries to be able to choose the number of iterations. This number is still fixed to 15 as before when using the CLI. * Fix Clippy lint Co-authored-by: Josh Holmer <jholmer.in@gmail.com>
103 lines
3 KiB
Rust
103 lines
3 KiB
Rust
use crate::atomicmin::AtomicMin;
|
|
use crate::error::PngError;
|
|
use crate::Deadline;
|
|
use crate::PngResult;
|
|
use indexmap::IndexSet;
|
|
|
|
#[cfg(feature = "zopfli")]
|
|
use std::num::NonZeroU8;
|
|
|
|
#[doc(hidden)]
|
|
pub mod miniz_stream;
|
|
|
|
#[cfg(feature = "libdeflater")]
|
|
mod deflater;
|
|
#[cfg(feature = "libdeflater")]
|
|
pub use deflater::deflate as libdeflater_deflate;
|
|
|
|
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
|
|
pub mod cfzlib;
|
|
|
|
#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
|
|
pub mod cfzlib {
|
|
pub fn is_supported() -> bool {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// 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
|
|
#[doc(hidden)]
|
|
pub fn deflate(
|
|
data: &[u8],
|
|
zc: u8,
|
|
zs: u8,
|
|
zw: u8,
|
|
max_size: &AtomicMin,
|
|
deadline: &Deadline,
|
|
) -> PngResult<Vec<u8>> {
|
|
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
|
|
{
|
|
if cfzlib::is_supported() {
|
|
return cfzlib::cfzlib_deflate(data, zc, zs, zw, max_size, deadline);
|
|
}
|
|
}
|
|
|
|
miniz_stream::compress_to_vec_oxipng(data, zc, zw.into(), zs.into(), max_size, deadline)
|
|
}
|
|
|
|
#[cfg(feature = "zopfli")]
|
|
pub fn zopfli_deflate(data: &[u8], iterations: NonZeroU8) -> PngResult<Vec<u8>> {
|
|
use std::cmp::max;
|
|
|
|
let mut output = Vec::with_capacity(max(1024, data.len() / 20));
|
|
let options = zopfli::Options {
|
|
iteration_count: iterations,
|
|
..Default::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, Debug, PartialEq, Eq)]
|
|
/// DEFLATE algorithms supported by oxipng
|
|
pub enum Deflaters {
|
|
/// Use the Zlib/Miniz DEFLATE implementation
|
|
Zlib {
|
|
/// Which zlib compression levels to try on the file (1-9)
|
|
///
|
|
/// Default: `9`
|
|
compression: IndexSet<u8>,
|
|
/// Which zlib compression strategies to try on the file (0-3)
|
|
///
|
|
/// Default: `0-3`
|
|
strategies: IndexSet<u8>,
|
|
/// Window size to use when compressing the file, as `2^window` bytes.
|
|
///
|
|
/// Doesn't affect compression but may affect speed and memory usage.
|
|
/// 8-15 are valid values.
|
|
///
|
|
/// Default: `15`
|
|
window: u8,
|
|
},
|
|
#[cfg(feature = "zopfli")]
|
|
/// Use the better but slower Zopfli implementation
|
|
Zopfli {
|
|
/// The number of compression iterations to do. 15 iterations are fine
|
|
/// for small files, but bigger files will need to be compressed with
|
|
/// less iterations, or else they will be too slow.
|
|
iterations: NonZeroU8,
|
|
},
|
|
#[cfg(feature = "libdeflater")]
|
|
/// Use libdeflater.
|
|
Libdeflater,
|
|
}
|