From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Fri, 19 Jul 2024 16:37:58 +0400 Subject: Deleted vendor folder --- vendor/tiff/src/encoder/colortype.rs | 245 -------- 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 -- vendor/tiff/src/encoder/mod.rs | 681 --------------------- vendor/tiff/src/encoder/tiff_value.rs | 523 ---------------- vendor/tiff/src/encoder/writer.rs | 188 ------ 9 files changed, 2078 deletions(-) delete mode 100644 vendor/tiff/src/encoder/colortype.rs delete mode 100644 vendor/tiff/src/encoder/compression/deflate.rs delete mode 100644 vendor/tiff/src/encoder/compression/lzw.rs delete mode 100644 vendor/tiff/src/encoder/compression/mod.rs delete mode 100644 vendor/tiff/src/encoder/compression/packbits.rs delete mode 100644 vendor/tiff/src/encoder/compression/uncompressed.rs delete mode 100644 vendor/tiff/src/encoder/mod.rs delete mode 100644 vendor/tiff/src/encoder/tiff_value.rs delete mode 100644 vendor/tiff/src/encoder/writer.rs (limited to 'vendor/tiff/src/encoder') diff --git a/vendor/tiff/src/encoder/colortype.rs b/vendor/tiff/src/encoder/colortype.rs deleted file mode 100644 index 1946daf..0000000 --- a/vendor/tiff/src/encoder/colortype.rs +++ /dev/null @@ -1,245 +0,0 @@ -use crate::tags::{PhotometricInterpretation, SampleFormat}; - -/// Trait for different colortypes that can be encoded. -pub trait ColorType { - /// The type of each sample of this colortype - type Inner: super::TiffValue; - /// The value of the tiff tag `PhotometricInterpretation` - const TIFF_VALUE: PhotometricInterpretation; - /// The value of the tiff tag `BitsPerSample` - const BITS_PER_SAMPLE: &'static [u16]; - /// The value of the tiff tag `SampleFormat` - const SAMPLE_FORMAT: &'static [SampleFormat]; -} - -pub struct Gray8; -impl ColorType for Gray8 { - type Inner = u8; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[8]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint]; -} - -pub struct GrayI8; -impl ColorType for GrayI8 { - type Inner = i8; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[8]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int]; -} - -pub struct Gray16; -impl ColorType for Gray16 { - type Inner = u16; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[16]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint]; -} - -pub struct GrayI16; -impl ColorType for GrayI16 { - type Inner = i16; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[16]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int]; -} - -pub struct Gray32; -impl ColorType for Gray32 { - type Inner = u32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint]; -} - -pub struct GrayI32; -impl ColorType for GrayI32 { - type Inner = i32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int]; -} - -pub struct Gray32Float; -impl ColorType for Gray32Float { - type Inner = f32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP]; -} - -pub struct Gray64; -impl ColorType for Gray64 { - type Inner = u64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint]; -} - -pub struct GrayI64; -impl ColorType for GrayI64 { - type Inner = i64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int]; -} - -pub struct Gray64Float; -impl ColorType for Gray64Float { - type Inner = f64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero; - const BITS_PER_SAMPLE: &'static [u16] = &[64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP]; -} - -pub struct RGB8; -impl ColorType for RGB8 { - type Inner = u8; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3]; -} - -pub struct RGB16; -impl ColorType for RGB16 { - type Inner = u16; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3]; -} - -pub struct RGB32; -impl ColorType for RGB32 { - type Inner = u32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3]; -} - -pub struct RGB32Float; -impl ColorType for RGB32Float { - type Inner = f32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 3]; -} - -pub struct RGB64; -impl ColorType for RGB64 { - type Inner = u64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3]; -} - -pub struct RGB64Float; -impl ColorType for RGB64Float { - type Inner = f64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 3]; -} - -pub struct RGBA8; -impl ColorType for RGBA8 { - type Inner = u8; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8, 8]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct RGBA16; -impl ColorType for RGBA16 { - type Inner = u16; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16, 16]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct RGBA32; -impl ColorType for RGBA32 { - type Inner = u32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct RGBA32Float; -impl ColorType for RGBA32Float { - type Inner = f32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4]; -} - -pub struct RGBA64; -impl ColorType for RGBA64 { - type Inner = u64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct RGBA64Float; -impl ColorType for RGBA64Float { - type Inner = f64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB; - const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4]; -} - -pub struct CMYK8; -impl ColorType for CMYK8 { - type Inner = u8; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK; - const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8, 8]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct CMYK16; -impl ColorType for CMYK16 { - type Inner = u16; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK; - const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16, 16]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct CMYK32; -impl ColorType for CMYK32 { - type Inner = u32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK; - const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct CMYK32Float; -impl ColorType for CMYK32Float { - type Inner = f32; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK; - const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4]; -} - -pub struct CMYK64; -impl ColorType for CMYK64 { - type Inner = u64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK; - const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4]; -} - -pub struct CMYK64Float; -impl ColorType for CMYK64Float { - type Inner = f64; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK; - const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4]; -} - -pub struct YCbCr8; -impl ColorType for YCbCr8 { - type Inner = u8; - const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::YCbCr; - const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8]; - const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3]; -} diff --git a/vendor/tiff/src/encoder/compression/deflate.rs b/vendor/tiff/src/encoder/compression/deflate.rs deleted file mode 100644 index 5e7a261..0000000 --- a/vendor/tiff/src/encoder/compression/deflate.rs +++ /dev/null @@ -1,83 +0,0 @@ -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 deleted file mode 100644 index 0e0f2aa..0000000 --- a/vendor/tiff/src/encoder/compression/lzw.rs +++ /dev/null @@ -1,47 +0,0 @@ -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 deleted file mode 100644 index 04baef3..0000000 --- a/vendor/tiff/src/encoder/compression/mod.rs +++ /dev/null @@ -1,60 +0,0 @@ -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 deleted file mode 100644 index 7ba3833..0000000 --- a/vendor/tiff/src/encoder/compression/packbits.rs +++ /dev/null @@ -1,214 +0,0 @@ -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 deleted file mode 100644 index 900426f..0000000 --- a/vendor/tiff/src/encoder/compression/uncompressed.rs +++ /dev/null @@ -1,37 +0,0 @@ -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); - } -} diff --git a/vendor/tiff/src/encoder/mod.rs b/vendor/tiff/src/encoder/mod.rs deleted file mode 100644 index 6e39c93..0000000 --- a/vendor/tiff/src/encoder/mod.rs +++ /dev/null @@ -1,681 +0,0 @@ -pub use tiff_value::*; - -use std::{ - cmp, - collections::BTreeMap, - convert::{TryFrom, TryInto}, - io::{self, Seek, Write}, - marker::PhantomData, - mem, - num::TryFromIntError, -}; - -use crate::{ - error::TiffResult, - tags::{CompressionMethod, ResolutionUnit, Tag}, - TiffError, TiffFormatError, -}; - -pub mod colortype; -pub mod compression; -mod tiff_value; -mod writer; - -use self::colortype::*; -use self::compression::*; -use self::writer::*; - -/// Encoder for Tiff and BigTiff files. -/// -/// With this type you can get a `DirectoryEncoder` or a `ImageEncoder` -/// to encode Tiff/BigTiff ifd directories with images. -/// -/// See `DirectoryEncoder` and `ImageEncoder`. -/// -/// # Examples -/// ``` -/// # extern crate tiff; -/// # fn main() { -/// # let mut file = std::io::Cursor::new(Vec::new()); -/// # let image_data = vec![0; 100*100*3]; -/// use tiff::encoder::*; -/// -/// // create a standard Tiff file -/// let mut tiff = TiffEncoder::new(&mut file).unwrap(); -/// tiff.write_image::(100, 100, &image_data).unwrap(); -/// -/// // create a BigTiff file -/// let mut bigtiff = TiffEncoder::new_big(&mut file).unwrap(); -/// bigtiff.write_image::(100, 100, &image_data).unwrap(); -/// -/// # } -/// ``` -pub struct TiffEncoder { - writer: TiffWriter, - kind: PhantomData, -} - -/// Constructor functions to create standard Tiff files. -impl TiffEncoder { - /// Creates a new encoder for standard Tiff files. - /// - /// To create BigTiff files, use [`new_big`][TiffEncoder::new_big] or - /// [`new_generic`][TiffEncoder::new_generic]. - pub fn new(writer: W) -> TiffResult> { - TiffEncoder::new_generic(writer) - } -} - -/// Constructor functions to create BigTiff files. -impl TiffEncoder { - /// Creates a new encoder for BigTiff files. - /// - /// To create standard Tiff files, use [`new`][TiffEncoder::new] or - /// [`new_generic`][TiffEncoder::new_generic]. - pub fn new_big(writer: W) -> TiffResult { - TiffEncoder::new_generic(writer) - } -} - -/// Generic functions that are available for both Tiff and BigTiff encoders. -impl TiffEncoder { - /// Creates a new Tiff or BigTiff encoder, inferred from the return type. - pub fn new_generic(writer: W) -> TiffResult { - let mut encoder = TiffEncoder { - writer: TiffWriter::new(writer), - kind: PhantomData, - }; - - K::write_header(&mut encoder.writer)?; - - Ok(encoder) - } - - /// Create a [`DirectoryEncoder`] to encode an ifd directory. - pub fn new_directory(&mut self) -> TiffResult> { - DirectoryEncoder::new(&mut self.writer) - } - - /// Create an [`ImageEncoder`] to encode an image one slice at a time. - pub fn new_image( - &mut self, - width: u32, - height: u32, - ) -> TiffResult> { - let encoder = DirectoryEncoder::new(&mut self.writer)?; - ImageEncoder::new(encoder, width, height) - } - - /// Create an [`ImageEncoder`] to encode an image one slice at a time. - pub fn new_image_with_compression( - &mut self, - width: u32, - height: u32, - compression: D, - ) -> TiffResult> { - let encoder = DirectoryEncoder::new(&mut self.writer)?; - ImageEncoder::with_compression(encoder, width, height, compression) - } - - /// Convenience function to write an entire image from memory. - pub fn write_image( - &mut self, - width: u32, - height: u32, - data: &[C::Inner], - ) -> TiffResult<()> - where - [C::Inner]: TiffValue, - { - let encoder = DirectoryEncoder::new(&mut self.writer)?; - let image: ImageEncoder = ImageEncoder::new(encoder, width, height)?; - image.write_data(data) - } - - /// Convenience function to write an entire image from memory with a given compression. - pub fn write_image_with_compression( - &mut self, - width: u32, - height: u32, - compression: D, - data: &[C::Inner], - ) -> TiffResult<()> - where - [C::Inner]: TiffValue, - { - let encoder = DirectoryEncoder::new(&mut self.writer)?; - let image: ImageEncoder = - ImageEncoder::with_compression(encoder, width, height, compression)?; - image.write_data(data) - } -} - -/// Low level interface to encode ifd directories. -/// -/// You should call `finish` on this when you are finished with it. -/// Encoding can silently fail while this is dropping. -pub struct DirectoryEncoder<'a, W: 'a + Write + Seek, K: TiffKind> { - writer: &'a mut TiffWriter, - dropped: bool, - // We use BTreeMap to make sure tags are written in correct order - ifd_pointer_pos: u64, - ifd: BTreeMap>, -} - -impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> { - fn new(writer: &'a mut TiffWriter) -> TiffResult { - // the previous word is the IFD offset position - let ifd_pointer_pos = writer.offset() - mem::size_of::() as u64; - writer.pad_word_boundary()?; // TODO: Do we need to adjust this for BigTiff? - Ok(DirectoryEncoder { - writer, - dropped: false, - ifd_pointer_pos, - ifd: BTreeMap::new(), - }) - } - - /// Write a single ifd tag. - pub fn write_tag(&mut self, tag: Tag, value: T) -> TiffResult<()> { - let mut bytes = Vec::with_capacity(value.bytes()); - { - let mut writer = TiffWriter::new(&mut bytes); - value.write(&mut writer)?; - } - - self.ifd.insert( - tag.to_u16(), - DirectoryEntry { - data_type: ::FIELD_TYPE.to_u16(), - count: value.count().try_into()?, - data: bytes, - }, - ); - - Ok(()) - } - - fn write_directory(&mut self) -> TiffResult { - // Start by writing out all values - for &mut DirectoryEntry { - data: ref mut bytes, - .. - } in self.ifd.values_mut() - { - let data_bytes = mem::size_of::(); - - if bytes.len() > data_bytes { - let offset = self.writer.offset(); - self.writer.write_bytes(bytes)?; - *bytes = vec![0; data_bytes]; - let mut writer = TiffWriter::new(bytes as &mut [u8]); - K::write_offset(&mut writer, offset)?; - } else { - while bytes.len() < data_bytes { - bytes.push(0); - } - } - } - - let offset = self.writer.offset(); - - K::write_entry_count(&mut self.writer, self.ifd.len())?; - for ( - tag, - &DirectoryEntry { - data_type: ref field_type, - ref count, - data: ref offset, - }, - ) in self.ifd.iter() - { - self.writer.write_u16(*tag)?; - self.writer.write_u16(*field_type)?; - (*count).write(&mut self.writer)?; - self.writer.write_bytes(offset)?; - } - - Ok(offset) - } - - /// Write some data to the tiff file, the offset of the data is returned. - /// - /// This could be used to write tiff strips. - pub fn write_data(&mut self, value: T) -> TiffResult { - let offset = self.writer.offset(); - value.write(&mut self.writer)?; - Ok(offset) - } - - /// Provides the number of bytes written by the underlying TiffWriter during the last call. - fn last_written(&self) -> u64 { - self.writer.last_written() - } - - fn finish_internal(&mut self) -> TiffResult<()> { - let ifd_pointer = self.write_directory()?; - let curr_pos = self.writer.offset(); - - self.writer.goto_offset(self.ifd_pointer_pos)?; - K::write_offset(&mut self.writer, ifd_pointer)?; - self.writer.goto_offset(curr_pos)?; - K::write_offset(&mut self.writer, 0)?; - - self.dropped = true; - - Ok(()) - } - - /// Write out the ifd directory. - pub fn finish(mut self) -> TiffResult<()> { - self.finish_internal() - } -} - -impl<'a, W: Write + Seek, K: TiffKind> Drop for DirectoryEncoder<'a, W, K> { - fn drop(&mut self) { - if !self.dropped { - let _ = self.finish_internal(); - } - } -} - -/// Type to encode images strip by strip. -/// -/// You should call `finish` on this when you are finished with it. -/// Encoding can silently fail while this is dropping. -/// -/// # Examples -/// ``` -/// # extern crate tiff; -/// # fn main() { -/// # let mut file = std::io::Cursor::new(Vec::new()); -/// # let image_data = vec![0; 100*100*3]; -/// use tiff::encoder::*; -/// use tiff::tags::Tag; -/// -/// let mut tiff = TiffEncoder::new(&mut file).unwrap(); -/// let mut image = tiff.new_image::(100, 100).unwrap(); -/// -/// // You can encode tags here -/// image.encoder().write_tag(Tag::Artist, "Image-tiff").unwrap(); -/// -/// // Strip size can be configured before writing data -/// image.rows_per_strip(2).unwrap(); -/// -/// let mut idx = 0; -/// while image.next_strip_sample_count() > 0 { -/// let sample_count = image.next_strip_sample_count() as usize; -/// image.write_strip(&image_data[idx..idx+sample_count]).unwrap(); -/// idx += sample_count; -/// } -/// image.finish().unwrap(); -/// # } -/// ``` -/// You can also call write_data function wich will encode by strip and finish -pub struct ImageEncoder< - 'a, - W: 'a + Write + Seek, - C: ColorType, - K: TiffKind, - D: Compression = Uncompressed, -> { - encoder: DirectoryEncoder<'a, W, K>, - strip_idx: u64, - strip_count: u64, - row_samples: u64, - width: u32, - height: u32, - rows_per_strip: u64, - strip_offsets: Vec, - strip_byte_count: Vec, - dropped: bool, - compression: D, - _phantom: ::std::marker::PhantomData, -} - -impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression> - ImageEncoder<'a, W, T, K, D> -{ - fn new(encoder: DirectoryEncoder<'a, W, K>, width: u32, height: u32) -> TiffResult - where - D: Default, - { - Self::with_compression(encoder, width, height, D::default()) - } - - fn with_compression( - mut encoder: DirectoryEncoder<'a, W, K>, - width: u32, - height: u32, - compression: D, - ) -> TiffResult { - if width == 0 || height == 0 { - return Err(TiffError::FormatError(TiffFormatError::InvalidDimensions( - width, height, - ))); - } - - let row_samples = u64::from(width) * u64::try_from(::BITS_PER_SAMPLE.len())?; - let row_bytes = row_samples * u64::from(::BYTE_LEN); - - // Limit the strip size to prevent potential memory and security issues. - // Also keep the multiple strip handling 'oiled' - let rows_per_strip = { - match D::COMPRESSION_METHOD { - CompressionMethod::PackBits => 1, // Each row must be packed separately. Do not compress across row boundaries - _ => (1_000_000 + row_bytes - 1) / row_bytes, - } - }; - - let strip_count = (u64::from(height) + rows_per_strip - 1) / rows_per_strip; - - encoder.write_tag(Tag::ImageWidth, width)?; - encoder.write_tag(Tag::ImageLength, height)?; - encoder.write_tag(Tag::Compression, D::COMPRESSION_METHOD.to_u16())?; - - encoder.write_tag(Tag::BitsPerSample, ::BITS_PER_SAMPLE)?; - let sample_format: Vec<_> = ::SAMPLE_FORMAT.iter().map(|s| s.to_u16()).collect(); - encoder.write_tag(Tag::SampleFormat, &sample_format[..])?; - encoder.write_tag(Tag::PhotometricInterpretation, ::TIFF_VALUE.to_u16())?; - - encoder.write_tag(Tag::RowsPerStrip, u32::try_from(rows_per_strip)?)?; - - encoder.write_tag( - Tag::SamplesPerPixel, - u16::try_from(::BITS_PER_SAMPLE.len())?, - )?; - encoder.write_tag(Tag::XResolution, Rational { n: 1, d: 1 })?; - encoder.write_tag(Tag::YResolution, Rational { n: 1, d: 1 })?; - encoder.write_tag(Tag::ResolutionUnit, ResolutionUnit::None.to_u16())?; - - Ok(ImageEncoder { - encoder, - strip_count, - strip_idx: 0, - row_samples, - rows_per_strip, - width, - height, - strip_offsets: Vec::new(), - strip_byte_count: Vec::new(), - dropped: false, - compression: compression, - _phantom: ::std::marker::PhantomData, - }) - } - - /// Number of samples the next strip should have. - pub fn next_strip_sample_count(&self) -> u64 { - if self.strip_idx >= self.strip_count { - return 0; - } - - let raw_start_row = self.strip_idx * self.rows_per_strip; - let start_row = cmp::min(u64::from(self.height), raw_start_row); - let end_row = cmp::min(u64::from(self.height), raw_start_row + self.rows_per_strip); - - (end_row - start_row) * self.row_samples - } - - /// Write a single strip. - pub fn write_strip(&mut self, value: &[T::Inner]) -> TiffResult<()> - where - [T::Inner]: TiffValue, - { - let samples = self.next_strip_sample_count(); - if u64::try_from(value.len())? != samples { - return Err(io::Error::new( - io::ErrorKind::InvalidData, - "Slice is wrong size for strip", - ) - .into()); - } - - // Write the (possible compressed) data to the encoder. - let offset = self.encoder.write_data(value)?; - let byte_count = self.encoder.last_written() as usize; - - self.strip_offsets.push(K::convert_offset(offset)?); - self.strip_byte_count.push(byte_count.try_into()?); - - self.strip_idx += 1; - Ok(()) - } - - /// Write strips from data - pub fn write_data(mut self, data: &[T::Inner]) -> TiffResult<()> - where - [T::Inner]: TiffValue, - { - let num_pix = usize::try_from(self.width)? - .checked_mul(usize::try_from(self.height)?) - .ok_or_else(|| { - io::Error::new( - io::ErrorKind::InvalidInput, - "Image width * height exceeds usize", - ) - })?; - if data.len() < num_pix { - return Err(io::Error::new( - io::ErrorKind::InvalidData, - "Input data slice is undersized for provided dimensions", - ) - .into()); - } - - self.encoder - .writer - .set_compression(self.compression.get_algorithm()); - - let mut idx = 0; - while self.next_strip_sample_count() > 0 { - let sample_count = usize::try_from(self.next_strip_sample_count())?; - self.write_strip(&data[idx..idx + sample_count])?; - idx += sample_count; - } - - self.encoder.writer.reset_compression(); - self.finish()?; - Ok(()) - } - - /// Set image resolution - pub fn resolution(&mut self, unit: ResolutionUnit, value: Rational) { - self.encoder - .write_tag(Tag::ResolutionUnit, unit.to_u16()) - .unwrap(); - self.encoder - .write_tag(Tag::XResolution, value.clone()) - .unwrap(); - self.encoder.write_tag(Tag::YResolution, value).unwrap(); - } - - /// Set image resolution unit - pub fn resolution_unit(&mut self, unit: ResolutionUnit) { - self.encoder - .write_tag(Tag::ResolutionUnit, unit.to_u16()) - .unwrap(); - } - - /// Set image x-resolution - pub fn x_resolution(&mut self, value: Rational) { - self.encoder.write_tag(Tag::XResolution, value).unwrap(); - } - - /// Set image y-resolution - pub fn y_resolution(&mut self, value: Rational) { - self.encoder.write_tag(Tag::YResolution, value).unwrap(); - } - - /// Set image number of lines per strip - /// - /// This function needs to be called before any calls to `write_data` or - /// `write_strip` and will return an error otherwise. - pub fn rows_per_strip(&mut self, value: u32) -> TiffResult<()> { - if self.strip_idx != 0 { - return Err(io::Error::new( - io::ErrorKind::InvalidInput, - "Cannot change strip size after data was written", - ) - .into()); - } - // Write tag as 32 bits - self.encoder.write_tag(Tag::RowsPerStrip, value)?; - - let value: u64 = value as u64; - self.strip_count = (self.height as u64 + value - 1) / value; - self.rows_per_strip = value; - - Ok(()) - } - - fn finish_internal(&mut self) -> TiffResult<()> { - self.encoder - .write_tag(Tag::StripOffsets, K::convert_slice(&self.strip_offsets))?; - self.encoder.write_tag( - Tag::StripByteCounts, - K::convert_slice(&self.strip_byte_count), - )?; - self.dropped = true; - - self.encoder.finish_internal() - } - - /// Get a reference of the underlying `DirectoryEncoder` - pub fn encoder(&mut self) -> &mut DirectoryEncoder<'a, W, K> { - &mut self.encoder - } - - /// Write out image and ifd directory. - pub fn finish(mut self) -> TiffResult<()> { - self.finish_internal() - } -} - -impl<'a, W: Write + Seek, C: ColorType, K: TiffKind, D: Compression> Drop - for ImageEncoder<'a, W, C, K, D> -{ - fn drop(&mut self) { - if !self.dropped { - let _ = self.finish_internal(); - } - } -} - -struct DirectoryEntry { - data_type: u16, - count: S, - data: Vec, -} - -/// Trait to abstract over Tiff/BigTiff differences. -/// -/// Implemented for [`TiffKindStandard`] and [`TiffKindBig`]. -pub trait TiffKind { - /// The type of offset fields, `u32` for normal Tiff, `u64` for BigTiff. - type OffsetType: TryFrom + Into + TiffValue; - - /// Needed for the `convert_slice` method. - type OffsetArrayType: ?Sized + TiffValue; - - /// Write the (Big)Tiff header. - fn write_header(writer: &mut TiffWriter) -> TiffResult<()>; - - /// Convert a file offset to `Self::OffsetType`. - /// - /// This returns an error for normal Tiff if the offset is larger than `u32::MAX`. - fn convert_offset(offset: u64) -> TiffResult; - - /// Write an offset value to the given writer. - /// - /// Like `convert_offset`, this errors if `offset > u32::MAX` for normal Tiff. - fn write_offset(writer: &mut TiffWriter, offset: u64) -> TiffResult<()>; - - /// Write the IFD entry count field with the given `count` value. - /// - /// The entry count field is an `u16` for normal Tiff and `u64` for BigTiff. Errors - /// if the given `usize` is larger than the representable values. - fn write_entry_count(writer: &mut TiffWriter, count: usize) -> TiffResult<()>; - - /// Internal helper method for satisfying Rust's type checker. - /// - /// The `TiffValue` trait is implemented for both primitive values (e.g. `u8`, `u32`) and - /// slices of primitive values (e.g. `[u8]`, `[u32]`). However, this is not represented in - /// the type system, so there is no guarantee that that for all `T: TiffValue` there is also - /// an implementation of `TiffValue` for `[T]`. This method works around that problem by - /// providing a conversion from `[T]` to some value that implements `TiffValue`, thereby - /// making all slices of `OffsetType` usable with `write_tag` and similar methods. - /// - /// Implementations of this trait should always set `OffsetArrayType` to `[OffsetType]`. - fn convert_slice(slice: &[Self::OffsetType]) -> &Self::OffsetArrayType; -} - -/// Create a standard Tiff file. -pub struct TiffKindStandard; - -impl TiffKind for TiffKindStandard { - type OffsetType = u32; - type OffsetArrayType = [u32]; - - fn write_header(writer: &mut TiffWriter) -> TiffResult<()> { - write_tiff_header(writer)?; - // blank the IFD offset location - writer.write_u32(0)?; - - Ok(()) - } - - fn convert_offset(offset: u64) -> TiffResult { - Ok(Self::OffsetType::try_from(offset)?) - } - - fn write_offset(writer: &mut TiffWriter, offset: u64) -> TiffResult<()> { - writer.write_u32(u32::try_from(offset)?)?; - Ok(()) - } - - fn write_entry_count(writer: &mut TiffWriter, count: usize) -> TiffResult<()> { - writer.write_u16(u16::try_from(count)?)?; - - Ok(()) - } - - fn convert_slice(slice: &[Self::OffsetType]) -> &Self::OffsetArrayType { - slice - } -} - -/// Create a BigTiff file. -pub struct TiffKindBig; - -impl TiffKind for TiffKindBig { - type OffsetType = u64; - type OffsetArrayType = [u64]; - - fn write_header(writer: &mut TiffWriter) -> TiffResult<()> { - write_bigtiff_header(writer)?; - // blank the IFD offset location - writer.write_u64(0)?; - - Ok(()) - } - - fn convert_offset(offset: u64) -> TiffResult { - Ok(offset) - } - - fn write_offset(writer: &mut TiffWriter, offset: u64) -> TiffResult<()> { - writer.write_u64(offset)?; - Ok(()) - } - - fn write_entry_count(writer: &mut TiffWriter, count: usize) -> TiffResult<()> { - writer.write_u64(u64::try_from(count)?)?; - Ok(()) - } - - fn convert_slice(slice: &[Self::OffsetType]) -> &Self::OffsetArrayType { - slice - } -} diff --git a/vendor/tiff/src/encoder/tiff_value.rs b/vendor/tiff/src/encoder/tiff_value.rs deleted file mode 100644 index 43653f4..0000000 --- a/vendor/tiff/src/encoder/tiff_value.rs +++ /dev/null @@ -1,523 +0,0 @@ -use std::{borrow::Cow, io::Write, slice::from_ref}; - -use crate::{bytecast, tags::Type, TiffError, TiffFormatError, TiffResult}; - -use super::writer::TiffWriter; - -/// Trait for types that can be encoded in a tiff file -pub trait TiffValue { - const BYTE_LEN: u8; - const FIELD_TYPE: Type; - fn count(&self) -> usize; - fn bytes(&self) -> usize { - self.count() * usize::from(Self::BYTE_LEN) - } - - /// Access this value as an contiguous sequence of bytes. - /// If their is no trivial representation, allocate it on the heap. - fn data(&self) -> Cow<[u8]>; - - /// Write this value to a TiffWriter. - /// While the default implementation will work in all cases, it may require unnecessary allocations. - /// The written bytes of any custom implementation MUST be the same as yielded by `self.data()`. - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_bytes(&self.data())?; - Ok(()) - } -} - -impl TiffValue for [u8] { - const BYTE_LEN: u8 = 1; - const FIELD_TYPE: Type = Type::BYTE; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(self) - } -} - -impl TiffValue for [i8] { - const BYTE_LEN: u8 = 1; - const FIELD_TYPE: Type = Type::SBYTE; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i8_as_ne_bytes(self)) - } -} - -impl TiffValue for [u16] { - const BYTE_LEN: u8 = 2; - const FIELD_TYPE: Type = Type::SHORT; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u16_as_ne_bytes(self)) - } -} - -impl TiffValue for [i16] { - const BYTE_LEN: u8 = 2; - const FIELD_TYPE: Type = Type::SSHORT; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i16_as_ne_bytes(self)) - } -} - -impl TiffValue for [u32] { - const BYTE_LEN: u8 = 4; - const FIELD_TYPE: Type = Type::LONG; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u32_as_ne_bytes(self)) - } -} - -impl TiffValue for [i32] { - const BYTE_LEN: u8 = 4; - const FIELD_TYPE: Type = Type::SLONG; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i32_as_ne_bytes(self)) - } -} - -impl TiffValue for [u64] { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::LONG8; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u64_as_ne_bytes(self)) - } -} - -impl TiffValue for [i64] { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::SLONG8; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i64_as_ne_bytes(self)) - } -} - -impl TiffValue for [f32] { - const BYTE_LEN: u8 = 4; - const FIELD_TYPE: Type = Type::FLOAT; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - // We write using native endian so this should be safe - Cow::Borrowed(bytecast::f32_as_ne_bytes(self)) - } -} - -impl TiffValue for [f64] { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::DOUBLE; - - fn count(&self) -> usize { - self.len() - } - - fn data(&self) -> Cow<[u8]> { - // We write using native endian so this should be safe - Cow::Borrowed(bytecast::f64_as_ne_bytes(self)) - } -} - -impl TiffValue for u8 { - const BYTE_LEN: u8 = 1; - const FIELD_TYPE: Type = Type::BYTE; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_u8(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(from_ref(self)) - } -} - -impl TiffValue for i8 { - const BYTE_LEN: u8 = 1; - const FIELD_TYPE: Type = Type::SBYTE; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_i8(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i8_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for u16 { - const BYTE_LEN: u8 = 2; - const FIELD_TYPE: Type = Type::SHORT; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_u16(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u16_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for i16 { - const BYTE_LEN: u8 = 2; - const FIELD_TYPE: Type = Type::SSHORT; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_i16(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i16_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for u32 { - const BYTE_LEN: u8 = 4; - const FIELD_TYPE: Type = Type::LONG; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_u32(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for i32 { - const BYTE_LEN: u8 = 4; - const FIELD_TYPE: Type = Type::SLONG; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_i32(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i32_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for u64 { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::LONG8; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_u64(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for i64 { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::SLONG8; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_i64(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::i64_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for f32 { - const BYTE_LEN: u8 = 4; - const FIELD_TYPE: Type = Type::FLOAT; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_f32(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::f32_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for f64 { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::DOUBLE; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_f64(*self)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::f64_as_ne_bytes(from_ref(self))) - } -} - -impl TiffValue for Ifd { - const BYTE_LEN: u8 = 4; - const FIELD_TYPE: Type = Type::IFD; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_u32(self.0)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(&self.0))) - } -} - -impl TiffValue for Ifd8 { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::IFD8; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_u64(self.0)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(&self.0))) - } -} - -impl TiffValue for Rational { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::RATIONAL; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_u32(self.n)?; - writer.write_u32(self.d)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Owned({ - let first_dword = bytecast::u32_as_ne_bytes(from_ref(&self.n)); - let second_dword = bytecast::u32_as_ne_bytes(from_ref(&self.d)); - [first_dword, second_dword].concat() - }) - } -} - -impl TiffValue for SRational { - const BYTE_LEN: u8 = 8; - const FIELD_TYPE: Type = Type::SRATIONAL; - - fn count(&self) -> usize { - 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - writer.write_i32(self.n)?; - writer.write_i32(self.d)?; - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - Cow::Owned({ - let first_dword = bytecast::i32_as_ne_bytes(from_ref(&self.n)); - let second_dword = bytecast::i32_as_ne_bytes(from_ref(&self.d)); - [first_dword, second_dword].concat() - }) - } -} - -impl TiffValue for str { - const BYTE_LEN: u8 = 1; - const FIELD_TYPE: Type = Type::ASCII; - - fn count(&self) -> usize { - self.len() + 1 - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - if self.is_ascii() && !self.bytes().any(|b| b == 0) { - writer.write_bytes(self.as_bytes())?; - writer.write_u8(0)?; - Ok(()) - } else { - Err(TiffError::FormatError(TiffFormatError::InvalidTag)) - } - } - - fn data(&self) -> Cow<[u8]> { - Cow::Owned({ - if self.is_ascii() && !self.bytes().any(|b| b == 0) { - let bytes: &[u8] = self.as_bytes(); - [bytes, &[0]].concat() - } else { - vec![] - } - }) - } -} - -impl<'a, T: TiffValue + ?Sized> TiffValue for &'a T { - const BYTE_LEN: u8 = T::BYTE_LEN; - const FIELD_TYPE: Type = T::FIELD_TYPE; - - fn count(&self) -> usize { - (*self).count() - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - (*self).write(writer) - } - - fn data(&self) -> Cow<[u8]> { - T::data(self) - } -} - -macro_rules! impl_tiff_value_for_contiguous_sequence { - ($inner_type:ty; $bytes:expr; $field_type:expr) => { - impl $crate::encoder::TiffValue for [$inner_type] { - const BYTE_LEN: u8 = $bytes; - const FIELD_TYPE: Type = $field_type; - - fn count(&self) -> usize { - self.len() - } - - fn write(&self, writer: &mut TiffWriter) -> TiffResult<()> { - for x in self { - x.write(writer)?; - } - Ok(()) - } - - fn data(&self) -> Cow<[u8]> { - let mut buf: Vec = Vec::with_capacity(Self::BYTE_LEN as usize * self.len()); - for x in self { - buf.extend_from_slice(&x.data()); - } - Cow::Owned(buf) - } - } - }; -} - -impl_tiff_value_for_contiguous_sequence!(Ifd; 4; Type::IFD); -impl_tiff_value_for_contiguous_sequence!(Ifd8; 8; Type::IFD8); -impl_tiff_value_for_contiguous_sequence!(Rational; 8; Type::RATIONAL); -impl_tiff_value_for_contiguous_sequence!(SRational; 8; Type::SRATIONAL); - -/// Type to represent tiff values of type `IFD` -#[derive(Clone)] -pub struct Ifd(pub u32); - -/// Type to represent tiff values of type `IFD8` -#[derive(Clone)] -pub struct Ifd8(pub u64); - -/// Type to represent tiff values of type `RATIONAL` -#[derive(Clone)] -pub struct Rational { - pub n: u32, - pub d: u32, -} - -/// Type to represent tiff values of type `SRATIONAL` -#[derive(Clone)] -pub struct SRational { - pub n: i32, - pub d: i32, -} diff --git a/vendor/tiff/src/encoder/writer.rs b/vendor/tiff/src/encoder/writer.rs deleted file mode 100644 index c5139e9..0000000 --- a/vendor/tiff/src/encoder/writer.rs +++ /dev/null @@ -1,188 +0,0 @@ -use crate::encoder::compression::*; -use crate::error::TiffResult; -use std::io::{self, Seek, SeekFrom, Write}; - -pub fn write_tiff_header(writer: &mut TiffWriter) -> TiffResult<()> { - #[cfg(target_endian = "little")] - let boi: u8 = 0x49; - #[cfg(not(target_endian = "little"))] - let boi: u8 = 0x4d; - - writer.writer.write_all(&[boi, boi])?; - writer.writer.write_all(&42u16.to_ne_bytes())?; - writer.offset += 4; - - Ok(()) -} - -/// Writes a BigTiff header, excluding the IFD offset field. -/// -/// Writes the byte order, version number, offset byte size, and zero constant fields. Does -// _not_ write the offset to the first IFD, this should be done by the caller. -pub fn write_bigtiff_header(writer: &mut TiffWriter) -> TiffResult<()> { - #[cfg(target_endian = "little")] - let boi: u8 = 0x49; - #[cfg(not(target_endian = "little"))] - let boi: u8 = 0x4d; - - // byte order indication - writer.writer.write_all(&[boi, boi])?; - // version number - writer.writer.write_all(&43u16.to_ne_bytes())?; - // bytesize of offsets (pointer size) - writer.writer.write_all(&8u16.to_ne_bytes())?; - // always 0 - writer.writer.write_all(&0u16.to_ne_bytes())?; - - // we wrote 8 bytes, so set the internal offset accordingly - writer.offset += 8; - - Ok(()) -} - -pub struct TiffWriter { - writer: W, - offset: u64, - byte_count: u64, - compressor: Compressor, -} - -impl TiffWriter { - pub fn new(writer: W) -> Self { - Self { - writer, - offset: 0, - byte_count: 0, - compressor: Compressor::default(), - } - } - - pub fn set_compression(&mut self, compressor: Compressor) { - self.compressor = compressor; - } - - pub fn reset_compression(&mut self) { - self.compressor = Compressor::default(); - } - - pub fn offset(&self) -> u64 { - self.offset - } - - pub fn last_written(&self) -> u64 { - self.byte_count - } - - pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), io::Error> { - self.byte_count = self.compressor.write_to(&mut self.writer, bytes)?; - self.offset += self.byte_count; - Ok(()) - } - - pub fn write_u8(&mut self, n: u8) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - Ok(()) - } - - pub fn write_i8(&mut self, n: i8) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - Ok(()) - } - - pub fn write_u16(&mut self, n: u16) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn write_i16(&mut self, n: i16) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn write_u32(&mut self, n: u32) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn write_i32(&mut self, n: i32) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn write_u64(&mut self, n: u64) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn write_i64(&mut self, n: i64) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &n.to_ne_bytes())?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn write_f32(&mut self, n: f32) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &u32::to_ne_bytes(n.to_bits()))?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn write_f64(&mut self, n: f64) -> Result<(), io::Error> { - self.byte_count = self - .compressor - .write_to(&mut self.writer, &u64::to_ne_bytes(n.to_bits()))?; - self.offset += self.byte_count; - - Ok(()) - } - - pub fn pad_word_boundary(&mut self) -> Result<(), io::Error> { - if self.offset % 4 != 0 { - let padding = [0, 0, 0]; - let padd_len = 4 - (self.offset % 4); - self.writer.write_all(&padding[..padd_len as usize])?; - self.offset += padd_len; - } - - Ok(()) - } -} - -impl TiffWriter { - pub fn goto_offset(&mut self, offset: u64) -> Result<(), io::Error> { - self.offset = offset; - self.writer.seek(SeekFrom::Start(offset as u64))?; - Ok(()) - } -} -- cgit v1.2.3