From 1b6a04ca5504955c571d1c97504fb45ea0befee4 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Mon, 8 Jan 2024 01:21:28 +0400 Subject: Initial vendor packages Signed-off-by: Valentin Popov --- vendor/tiff/src/encoder/compression/deflate.rs | 83 ++++++++ vendor/tiff/src/encoder/compression/lzw.rs | 47 +++++ vendor/tiff/src/encoder/compression/mod.rs | 60 ++++++ vendor/tiff/src/encoder/compression/packbits.rs | 214 +++++++++++++++++++++ .../tiff/src/encoder/compression/uncompressed.rs | 37 ++++ 5 files changed, 441 insertions(+) create mode 100644 vendor/tiff/src/encoder/compression/deflate.rs create mode 100644 vendor/tiff/src/encoder/compression/lzw.rs create mode 100644 vendor/tiff/src/encoder/compression/mod.rs create mode 100644 vendor/tiff/src/encoder/compression/packbits.rs create mode 100644 vendor/tiff/src/encoder/compression/uncompressed.rs (limited to 'vendor/tiff/src/encoder/compression') diff --git a/vendor/tiff/src/encoder/compression/deflate.rs b/vendor/tiff/src/encoder/compression/deflate.rs new file mode 100644 index 0000000..5e7a261 --- /dev/null +++ b/vendor/tiff/src/encoder/compression/deflate.rs @@ -0,0 +1,83 @@ +use crate::{encoder::compression::*, tags::CompressionMethod}; +use flate2::{write::ZlibEncoder, Compression as FlateCompression}; +use std::io::Write; + +/// The Deflate algorithm used to compress image data in TIFF files. +#[derive(Debug, Clone, Copy)] +pub struct Deflate { + level: FlateCompression, +} + +/// The level of compression used by the Deflate algorithm. +/// It allows trading compression ratio for compression speed. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +#[non_exhaustive] +pub enum DeflateLevel { + /// The fastest possible compression mode. + Fast = 1, + /// The conserative choice between speed and ratio. + Balanced = 6, + /// The best compression available with Deflate. + Best = 9, +} + +impl Default for DeflateLevel { + fn default() -> Self { + DeflateLevel::Balanced + } +} + +impl Deflate { + /// Create a new deflate compressor with a specific level of compression. + pub fn with_level(level: DeflateLevel) -> Self { + Self { + level: FlateCompression::new(level as u32), + } + } +} + +impl Default for Deflate { + fn default() -> Self { + Self::with_level(DeflateLevel::default()) + } +} + +impl Compression for Deflate { + const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::Deflate; + + fn get_algorithm(&self) -> Compressor { + Compressor::Deflate(self.clone()) + } +} + +impl CompressionAlgorithm for Deflate { + fn write_to(&mut self, writer: &mut W, bytes: &[u8]) -> Result { + let mut encoder = ZlibEncoder::new(writer, self.level); + encoder.write_all(bytes)?; + encoder.try_finish()?; + Ok(encoder.total_out()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::encoder::compression::tests::TEST_DATA; + use std::io::Cursor; + + #[test] + fn test_deflate() { + const EXPECTED_COMPRESSED_DATA: [u8; 64] = [ + 0x78, 0x9C, 0x15, 0xC7, 0xD1, 0x0D, 0x80, 0x20, 0x0C, 0x04, 0xD0, 0x55, 0x6E, 0x02, + 0xA7, 0x71, 0x81, 0xA6, 0x41, 0xDA, 0x28, 0xD4, 0xF4, 0xD0, 0xF9, 0x81, 0xE4, 0xFD, + 0xBC, 0xD3, 0x9C, 0x58, 0x04, 0x1C, 0xE9, 0xBD, 0xE2, 0x8A, 0x84, 0x5A, 0xD1, 0x7B, + 0xE7, 0x97, 0xF4, 0xF8, 0x08, 0x8D, 0xF6, 0x66, 0x21, 0x3D, 0x3A, 0xE4, 0xA9, 0x91, + 0x3E, 0xAC, 0xF1, 0x98, 0xB9, 0x70, 0x17, 0x13, + ]; + + let mut compressed_data = Vec::::new(); + let mut writer = Cursor::new(&mut compressed_data); + Deflate::default().write_to(&mut writer, TEST_DATA).unwrap(); + assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice()); + } +} diff --git a/vendor/tiff/src/encoder/compression/lzw.rs b/vendor/tiff/src/encoder/compression/lzw.rs new file mode 100644 index 0000000..0e0f2aa --- /dev/null +++ b/vendor/tiff/src/encoder/compression/lzw.rs @@ -0,0 +1,47 @@ +use crate::{encoder::compression::*, tags::CompressionMethod}; +use std::io::Write; +use weezl::encode::Encoder as LZWEncoder; + +/// The LZW algorithm used to compress image data in TIFF files. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct Lzw; + +impl Compression for Lzw { + const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::LZW; + + fn get_algorithm(&self) -> Compressor { + Compressor::Lzw(*self) + } +} + +impl CompressionAlgorithm for Lzw { + fn write_to(&mut self, writer: &mut W, bytes: &[u8]) -> Result { + let mut encoder = LZWEncoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8); + let result = encoder.into_stream(writer).encode_all(bytes); + let byte_count = result.bytes_written as u64; + result.status.map(|_| byte_count) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::encoder::compression::tests::TEST_DATA; + use std::io::Cursor; + + #[test] + fn test_lzw() { + const EXPECTED_COMPRESSED_DATA: [u8; 63] = [ + 0x80, 0x15, 0x0D, 0x06, 0x93, 0x98, 0x82, 0x08, 0x20, 0x30, 0x88, 0x0E, 0x67, 0x43, + 0x91, 0xA4, 0xDC, 0x67, 0x10, 0x19, 0x8D, 0xE7, 0x21, 0x01, 0x8C, 0xD0, 0x65, 0x31, + 0x9A, 0xE1, 0xD1, 0x03, 0xB1, 0x86, 0x1A, 0x6F, 0x3A, 0xC1, 0x4C, 0x66, 0xF3, 0x69, + 0xC0, 0xE4, 0x65, 0x39, 0x9C, 0xCD, 0x26, 0xF3, 0x74, 0x20, 0xD8, 0x67, 0x89, 0x9A, + 0x4E, 0x86, 0x83, 0x69, 0xCC, 0x5D, 0x01, + ]; + + let mut compressed_data = Vec::::new(); + let mut writer = Cursor::new(&mut compressed_data); + Lzw::default().write_to(&mut writer, TEST_DATA).unwrap(); + assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice()); + } +} diff --git a/vendor/tiff/src/encoder/compression/mod.rs b/vendor/tiff/src/encoder/compression/mod.rs new file mode 100644 index 0000000..04baef3 --- /dev/null +++ b/vendor/tiff/src/encoder/compression/mod.rs @@ -0,0 +1,60 @@ +use crate::tags::CompressionMethod; +use std::io::{self, Write}; + +mod deflate; +mod lzw; +mod packbits; +mod uncompressed; + +pub use self::deflate::{Deflate, DeflateLevel}; +pub use self::lzw::Lzw; +pub use self::packbits::Packbits; +pub use self::uncompressed::Uncompressed; + +/// An algorithm used for compression +pub trait CompressionAlgorithm { + /// The algorithm writes data directly into the writer. + /// It returns the total number of bytes written. + fn write_to(&mut self, writer: &mut W, bytes: &[u8]) -> Result; +} + +/// An algorithm used for compression with associated enums and optional configurations. +pub trait Compression: CompressionAlgorithm { + /// The corresponding tag to the algorithm. + const COMPRESSION_METHOD: CompressionMethod; + + /// Method to optain a type that can store each variant of comression algorithm. + fn get_algorithm(&self) -> Compressor; +} + +/// An enum to store each compression algorithm. +pub enum Compressor { + Uncompressed(Uncompressed), + Lzw(Lzw), + Deflate(Deflate), + Packbits(Packbits), +} + +impl Default for Compressor { + /// The default compression strategy does not apply any compression. + fn default() -> Self { + Compressor::Uncompressed(Uncompressed::default()) + } +} + +impl CompressionAlgorithm for Compressor { + fn write_to(&mut self, writer: &mut W, bytes: &[u8]) -> Result { + match self { + Compressor::Uncompressed(algorithm) => algorithm.write_to(writer, bytes), + Compressor::Lzw(algorithm) => algorithm.write_to(writer, bytes), + Compressor::Deflate(algorithm) => algorithm.write_to(writer, bytes), + Compressor::Packbits(algorithm) => algorithm.write_to(writer, bytes), + } + } +} + +#[cfg(test)] +mod tests { + pub const TEST_DATA: &'static [u8] = + b"This is a string for checking various compression algorithms."; +} diff --git a/vendor/tiff/src/encoder/compression/packbits.rs b/vendor/tiff/src/encoder/compression/packbits.rs new file mode 100644 index 0000000..7ba3833 --- /dev/null +++ b/vendor/tiff/src/encoder/compression/packbits.rs @@ -0,0 +1,214 @@ +use crate::{encoder::compression::*, tags::CompressionMethod}; +use std::io::{BufWriter, Error, ErrorKind, Write}; + +/// Compressor that uses the Packbits[^note] algorithm to compress bytes. +/// +/// [^note]: PackBits is often ineffective on continuous tone images, +/// including many grayscale images. In such cases, it is better +/// to leave the image uncompressed. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct Packbits; + +impl Compression for Packbits { + const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::PackBits; + + fn get_algorithm(&self) -> Compressor { + Compressor::Packbits(*self) + } +} + +impl CompressionAlgorithm for Packbits { + fn write_to(&mut self, writer: &mut W, bytes: &[u8]) -> Result { + // Inspired by https://github.com/skirridsystems/packbits + + const MIN_REPT: u8 = 3; // Minimum run to compress between differ blocks + const MAX_BYTES: u8 = 128; // Maximum number of bytes that can be encoded in a header byte + + // Encoding for header byte based on number of bytes represented. + fn encode_diff(n: u8) -> u8 { + n - 1 + } + fn encode_rept(n: u8) -> u8 { + let var = 256 - (n - 1) as u16; + var as u8 + } + + fn write_u8(writer: &mut W, byte: u8) -> Result { + writer.write(&[byte]).map(|byte_count| byte_count as u64) + } + + let mut bufwriter = BufWriter::new(writer); + let mut bytes_written = 0u64; // The number of bytes written into the writer + let mut offset: Option = None; // The index of the first byte written into the writer + + let mut src_index: usize = 0; // Index of the current byte + let mut src_count = bytes.len(); //The number of bytes remaining to be compressed + + let mut in_run = false; // Indication whether counting of similar bytes is performed + let mut run_index = 0u8; // Distance into pending bytes that a run starts + + let mut bytes_pending = 0u8; // Bytes looked at but not yet output + let mut pending_index = 0usize; // Index of the first pending byte + + let mut curr_byte: u8; // Byte currently being considered + let mut last_byte: u8; // Previous byte + + // Need at least one byte to compress + if src_count == 0 { + return Err(Error::new(ErrorKind::WriteZero, "write zero")); + } + + // Prime compressor with first character. + last_byte = bytes[src_index]; + src_index += 1; + bytes_pending += 1; + + while src_count - 1 != 0 { + src_count -= 1; + curr_byte = bytes[src_index]; + src_index += 1; + bytes_pending += 1; + + if in_run { + if (curr_byte != last_byte) || (bytes_pending > MAX_BYTES) { + offset.get_or_insert(write_u8(&mut bufwriter, encode_rept(bytes_pending - 1))?); + write_u8(&mut bufwriter, last_byte)?; + bytes_written += 2; + + bytes_pending = 1; + pending_index = src_index - 1; + run_index = 0; + in_run = false; + } + } else { + if bytes_pending > MAX_BYTES { + // We have as much differing data as we can output in one chunk. + // Output MAX_BYTES leaving one byte. + offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?); + bufwriter.write(&bytes[pending_index..pending_index + MAX_BYTES as usize])?; + bytes_written += 1 + MAX_BYTES as u64; + + pending_index += MAX_BYTES as usize; + bytes_pending -= MAX_BYTES; + run_index = bytes_pending - 1; // A run could start here + } else if curr_byte == last_byte { + if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) { + // This is a worthwhile run + if run_index != 0 { + // Flush differing data out of input buffer + offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?); + bufwriter + .write(&bytes[pending_index..pending_index + run_index as usize])?; + bytes_written += 1 + run_index as u64; + } + bytes_pending -= run_index; // Length of run + in_run = true; + } + } else { + run_index = bytes_pending - 1; // A run could start here + } + } + last_byte = curr_byte; + } + + // Output the remainder + if in_run { + bytes_written += 2; + offset.get_or_insert(write_u8(&mut bufwriter, encode_rept(bytes_pending))?); + write_u8(&mut bufwriter, last_byte)?; + } else { + bytes_written += 1 + bytes_pending as u64; + offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(bytes_pending))?); + bufwriter.write(&bytes[pending_index..pending_index + bytes_pending as usize])?; + } + + bufwriter.flush()?; + Ok(bytes_written) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::encoder::compression::tests::TEST_DATA; + use std::io::Cursor; + + #[test] + fn test_packbits_single_byte() { + // compress single byte + const UNCOMPRESSED_DATA: [u8; 1] = [0x3F]; + const EXPECTED_COMPRESSED_DATA: [u8; 2] = [0x00, 0x3F]; + + let mut compressed_data = Vec::::new(); + let mut writer = Cursor::new(&mut compressed_data); + Packbits::default() + .write_to(&mut writer, &UNCOMPRESSED_DATA) + .unwrap(); + assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA); + } + + #[test] + fn test_packbits_rept() { + // compress buffer with repetitive sequence + const UNCOMPRESSED_DATA: &'static [u8] = + b"This strrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrring hangs."; + const EXPECTED_COMPRESSED_DATA: &'static [u8] = b"\x06This st\xD1r\x09ing hangs."; + + let mut compressed_data = Vec::::new(); + let mut writer = Cursor::new(&mut compressed_data); + Packbits::default() + .write_to(&mut writer, UNCOMPRESSED_DATA) + .unwrap(); + assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA); + } + + #[test] + fn test_packbits_large_rept_nonrept() { + // compress buffer with large repetitive and non-repetitive sequence + let mut data = b"This st".to_vec(); + for _i in 0..158 { + data.push(b'r'); + } + data.extend_from_slice(b"ing hangs."); + for i in 0..158 { + data.push(i); + } + + const EXPECTED_COMPRESSED_DATA: [u8; 182] = [ + 0x06, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x74, 0x81, 0x72, 0xE3, 0x72, 0x7F, 0x69, + 0x6E, 0x67, 0x20, 0x68, 0x61, 0x6E, 0x67, 0x73, 0x2E, 0x00, 0x01, 0x02, 0x03, 0x04, + 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, + 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, + 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, + 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, + 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, + 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, + 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, + 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, + 0x75, 0x27, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, + 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, + ]; + + let mut compressed_data = Vec::::new(); + let mut writer = Cursor::new(&mut compressed_data); + Packbits::default() + .write_to(&mut writer, data.as_slice()) + .unwrap(); + assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA); + } + + #[test] + fn test_packbits() { + // compress teststring + const EXPECTED_COMPRESSED_DATA: &'static [u8] = + b"\x3CThis is a string for checking various compression algorithms."; + + let mut compressed_data = Vec::::new(); + let mut writer = Cursor::new(&mut compressed_data); + Packbits::default() + .write_to(&mut writer, TEST_DATA) + .unwrap(); + assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA); + } +} diff --git a/vendor/tiff/src/encoder/compression/uncompressed.rs b/vendor/tiff/src/encoder/compression/uncompressed.rs new file mode 100644 index 0000000..900426f --- /dev/null +++ b/vendor/tiff/src/encoder/compression/uncompressed.rs @@ -0,0 +1,37 @@ +use crate::{encoder::compression::*, tags::CompressionMethod}; +use std::io::Write; + +/// The default algorithm which does not compress at all. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct Uncompressed; + +impl Compression for Uncompressed { + const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::None; + + fn get_algorithm(&self) -> Compressor { + Compressor::Uncompressed(*self) + } +} + +impl CompressionAlgorithm for Uncompressed { + fn write_to(&mut self, writer: &mut W, bytes: &[u8]) -> Result { + writer.write(bytes).map(|byte_count| byte_count as u64) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::encoder::compression::tests::TEST_DATA; + use std::io::Cursor; + + #[test] + fn test_no_compression() { + let mut compressed_data = Vec::::new(); + let mut writer = Cursor::new(&mut compressed_data); + Uncompressed::default() + .write_to(&mut writer, TEST_DATA) + .unwrap(); + assert_eq!(TEST_DATA, compressed_data); + } +} -- cgit v1.2.3