diff --git a/Cargo.toml b/Cargo.toml index 5963d62c..053d2f30 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,6 +23,9 @@ sha1 = {version = "0.10.1", optional = true } time = { version = "0.3.7", features = ["formatting", "macros" ], optional = true } zstd = { version = "0.10.0", optional = true } +[target.'cfg(any(target_arch = "mips", target_arch = "powerpc"))'.dependencies] +crossbeam-utils = "0.8.8" + [dev-dependencies] bencher = "0.1.5" getrandom = "0.2.5" diff --git a/src/read.rs b/src/read.rs index 233c96e7..b591dccb 100644 --- a/src/read.rs +++ b/src/read.rs @@ -691,6 +691,7 @@ pub(crate) fn central_header_to_zip_file( #[allow(deprecated)] CompressionMethod::from_u16(compression_method) }, + compression_level: None, last_modified_time: DateTime::from_msdos(last_mod_date, last_mod_time), crc32, compressed_size: compressed_size as u64, @@ -1086,6 +1087,7 @@ pub fn read_zipfile_from_stream<'a, R: io::Read>( encrypted, using_data_descriptor, compression_method, + compression_level: None, last_modified_time: DateTime::from_msdos(last_mod_date, last_mod_time), crc32, compressed_size: compressed_size as u64, diff --git a/src/types.rs b/src/types.rs index bbeb5c1a..ff4e2409 100644 --- a/src/types.rs +++ b/src/types.rs @@ -2,8 +2,37 @@ #[cfg(doc)] use {crate::read::ZipFile, crate::write::FileOptions}; +#[cfg(not(any(target_arch = "mips", target_arch = "powerpc")))] use std::sync::atomic; +#[cfg(any(target_arch = "mips", target_arch = "powerpc"))] +mod atomic { + use crossbeam_utils::sync::ShardedLock; + pub use std::sync::atomic::Ordering; + + #[derive(Debug, Default)] + pub struct AtomicU64 { + value: ShardedLock, + } + + impl AtomicU64 { + pub fn new(v: u64) -> Self { + Self { + value: ShardedLock::new(v), + } + } + pub fn get_mut(&mut self) -> &mut u64 { + self.value.get_mut().unwrap() + } + pub fn load(&self, _: Ordering) -> u64 { + *self.value.read().unwrap() + } + pub fn store(&self, value: u64, _: Ordering) { + *self.value.write().unwrap() = value; + } + } +} + #[cfg(feature = "time")] use time::{error::ComponentRange, Date, Month, OffsetDateTime, PrimitiveDateTime, Time}; @@ -265,6 +294,8 @@ pub struct ZipFileData { pub using_data_descriptor: bool, /// Compression method used to store the file pub compression_method: crate::compression::CompressionMethod, + /// Compression level to store the file + pub compression_level: Option, /// Last modified time. This will only have a 2 second precision. pub last_modified_time: DateTime, /// CRC32 checksum @@ -396,6 +427,7 @@ mod test { encrypted: false, using_data_descriptor: false, compression_method: crate::compression::CompressionMethod::Stored, + compression_level: None, last_modified_time: DateTime::default(), crc32: 0, compressed_size: 0, diff --git a/src/write.rs b/src/write.rs index bdb5498e..457839bc 100644 --- a/src/write.rs +++ b/src/write.rs @@ -11,6 +11,7 @@ use std::default::Default; use std::io; use std::io::prelude::*; use std::mem; +use std::ops::RangeInclusive; #[cfg(any( feature = "deflate", @@ -103,6 +104,7 @@ struct ZipRawValues { #[derive(Copy, Clone)] pub struct FileOptions { compression_method: CompressionMethod, + compression_level: Option, last_modified_time: DateTime, permissions: Option, large_file: bool, @@ -124,6 +126,7 @@ impl FileOptions { feature = "deflate-zlib" )))] compression_method: CompressionMethod::Stored, + compression_level: None, #[cfg(feature = "time")] last_modified_time: DateTime::from_time(OffsetDateTime::now_utc()).unwrap_or_default(), #[cfg(not(feature = "time"))] @@ -143,6 +146,21 @@ impl FileOptions { self } + /// Set the compression level for the new file + /// + /// `None` value specifies default compression level. + /// + /// Range of values depends on compression method: + /// * `Deflated`: 0 - 9. Default is 6 + /// * `Bzip2`: 0 - 9. Default is 6 + /// * `Zstd`: -7 - 22, with zero being mapped to default level. Default is 3 + /// * others: only `None` is allowed + #[must_use] + pub fn compression_level(mut self, level: Option) -> FileOptions { + self.compression_level = level; + self + } + /// Set the last modified time /// /// The default is the current timestamp if the 'time' feature is enabled, and 1980-01-01 @@ -340,6 +358,7 @@ impl ZipWriter { encrypted: false, using_data_descriptor: false, compression_method: options.compression_method, + compression_level: options.compression_level, last_modified_time: options.last_modified_time, crc32: raw_values.crc32, compressed_size: raw_values.compressed_size, @@ -375,7 +394,7 @@ impl ZipWriter { // Implicitly calling [`ZipWriter::end_extra_data`] for empty files. self.end_extra_data()?; } - self.inner.switch_to(CompressionMethod::Stored)?; + self.inner.switch_to(CompressionMethod::Stored, None)?; let writer = self.inner.get_plain(); if !self.writing_raw { @@ -410,7 +429,8 @@ impl ZipWriter { } *options.permissions.as_mut().unwrap() |= 0o100000; self.start_entry(name, options, None)?; - self.inner.switch_to(options.compression_method)?; + self.inner + .switch_to(options.compression_method, options.compression_level)?; self.writing_to_file = true; Ok(()) } @@ -587,7 +607,8 @@ impl ZipWriter { writer.write_u16::(extra_field_length)?; writer.seek(io::SeekFrom::Start(header_end))?; - self.inner.switch_to(file.compression_method)?; + self.inner + .switch_to(file.compression_method, file.compression_level)?; } self.writing_to_extra_field = false; @@ -803,7 +824,11 @@ impl Drop for ZipWriter { } impl GenericZipWriter { - fn switch_to(&mut self, compression: CompressionMethod) -> ZipResult<()> { + fn switch_to( + &mut self, + compression: CompressionMethod, + compression_level: Option, + ) -> ZipResult<()> { match self.current_compression() { Some(method) if method == compression => return Ok(()), None => { @@ -840,7 +865,15 @@ impl GenericZipWriter { *self = { #[allow(deprecated)] match compression { - CompressionMethod::Stored => GenericZipWriter::Storer(bare), + CompressionMethod::Stored => { + if let Some(_) = compression_level { + return Err(ZipError::UnsupportedArchive( + "Unsupported compression level", + )); + } + + GenericZipWriter::Storer(bare) + } #[cfg(any( feature = "deflate", feature = "deflate-miniz", @@ -848,21 +881,50 @@ impl GenericZipWriter { ))] CompressionMethod::Deflated => GenericZipWriter::Deflater(DeflateEncoder::new( bare, - flate2::Compression::default(), + flate2::Compression::new( + clamp_opt( + compression_level + .unwrap_or(flate2::Compression::default().level() as i32), + deflate_compression_level_range(), + ) + .ok_or(ZipError::UnsupportedArchive( + "Unsupported compression level", + ))? as u32, + ), )), #[cfg(feature = "bzip2")] - CompressionMethod::Bzip2 => { - GenericZipWriter::Bzip2(BzEncoder::new(bare, bzip2::Compression::default())) - } + CompressionMethod::Bzip2 => GenericZipWriter::Bzip2(BzEncoder::new( + bare, + bzip2::Compression::new( + clamp_opt( + compression_level + .unwrap_or(bzip2::Compression::default().level() as i32), + bzip2_compression_level_range(), + ) + .ok_or(ZipError::UnsupportedArchive( + "Unsupported compression level", + ))? as u32, + ), + )), CompressionMethod::AES => { return Err(ZipError::UnsupportedArchive( "AES compression is not supported for writing", )) } #[cfg(feature = "zstd")] - CompressionMethod::Zstd => { - GenericZipWriter::Zstd(ZstdEncoder::new(bare, 0).unwrap()) - } + CompressionMethod::Zstd => GenericZipWriter::Zstd( + ZstdEncoder::new( + bare, + clamp_opt( + compression_level.unwrap_or(zstd::DEFAULT_COMPRESSION_LEVEL), + zstd::compression_level_range().clone(), + ) + .ok_or(ZipError::UnsupportedArchive( + "Unsupported compression level", + ))?, + ) + .unwrap(), + ), CompressionMethod::Unsupported(..) => { return Err(ZipError::UnsupportedArchive("Unsupported compression")) } @@ -925,6 +987,26 @@ impl GenericZipWriter { } } +fn deflate_compression_level_range() -> RangeInclusive { + let min = flate2::Compression::none().level() as i32; + let max = flate2::Compression::best().level() as i32; + min..=max +} + +fn bzip2_compression_level_range() -> RangeInclusive { + let min = bzip2::Compression::none().level() as i32; + let max = bzip2::Compression::best().level() as i32; + min..=max +} + +fn clamp_opt(value: T, range: RangeInclusive) -> Option { + if range.contains(&value) { + Some(value) + } else { + None + } +} + fn write_local_file_header(writer: &mut T, file: &ZipFileData) -> ZipResult<()> { // local file header signature writer.write_u32::(spec::LOCAL_FILE_HEADER_SIGNATURE)?; @@ -1258,6 +1340,7 @@ mod test { let mut writer = ZipWriter::new(io::Cursor::new(Vec::new())); let options = FileOptions { compression_method: CompressionMethod::Stored, + compression_level: None, last_modified_time: DateTime::default(), permissions: Some(33188), large_file: false,