Tiff crate internal compression types hidden in public interface

Author: sunipkm

src/codecs/tiff.rs

@@ -10,7 +10,7 @@ use std::marker::PhantomData;
 use std::mem;
 
 use tiff::decoder::{Decoder, DecodingResult};
-use tiff::encoder::Compression;
+use tiff::encoder::{Compression, DeflateLevel};
 use tiff::tags::Tag;
 
 use crate::color::{ColorType, ExtendedColorType};
@@ -367,6 +367,60 @@ pub struct TiffEncoder<W> {
     comp: Compression,
 }
 
+/// Compression types supported by the TIFF format
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum CompressionType {
+    /// No compression
+    Uncompressed,
+    /// LZW compression
+    Lzw,
+    /// Deflate compression
+    Deflate(TiffDeflateLevel),
+    /// Bit packing compression
+    Packbits,
+}
+
+impl Default for CompressionType {
+    fn default() -> Self {
+        CompressionType::Deflate(Default::default())
+    }
+}
+
+/// 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, Default)]
+#[non_exhaustive]
+pub enum TiffDeflateLevel {
+    /// The fastest possible compression mode.
+    Fast = 1,
+    /// The conserative choice between speed and ratio.
+    #[default]
+    Balanced = 6,
+    /// The best compression available with Deflate.
+    Best = 9,
+}
+
+impl TiffDeflateLevel {
+    fn into_tiff(self: TiffDeflateLevel) -> DeflateLevel {
+        match self {
+            TiffDeflateLevel::Fast => DeflateLevel::Fast,
+            TiffDeflateLevel::Balanced => DeflateLevel::Balanced,
+            TiffDeflateLevel::Best => DeflateLevel::Best,
+        }
+    }
+}
+
+impl CompressionType {
+    fn into_tiff(self: CompressionType) -> Compression {
+        match self {
+            CompressionType::Uncompressed => Compression::Uncompressed,
+            CompressionType::Lzw => Compression::Lzw,
+            CompressionType::Deflate(lvl) => Compression::Deflate(lvl.into_tiff()),
+            CompressionType::Packbits => Compression::Packbits,
+        }
+    }
+}
+
 fn cmyk_to_rgb(cmyk: &[u8]) -> [u8; 3] {
     let c = f32::from(cmyk[0]);
     let m = f32::from(cmyk[1]);
@@ -450,18 +504,24 @@ fn u8_slice_as_u16(buf: &[u8]) -> ImageResult<DtypeContainer<u16>> {
 impl<W: Write + Seek> TiffEncoder<W> {
     /// Create a new encoder that writes its output to `w`
     pub fn new(w: W) -> TiffEncoder<W> {
+        let comp = CompressionType::default().into_tiff();
+        TiffEncoder { w, comp }
+    }
+
+    /// Create a new encoder that writes its output to `w` with `CompressionType` `compression`.
+    ///
+    /// It is best to view the options as a _hint_ to the implementation on the smallest or fastest
+    /// option for encoding a particular image. That is, using options that map directly to a TIFF
+    /// image parameter will use this parameter where possible. But variants that have no direct
+    /// mapping may be interpreted differently in minor versions. The exact output is expressly
+    /// __not__ part of the SemVer stability guarantee.
+    pub fn new_with_compression(w: W, comp: CompressionType) -> Self {
         TiffEncoder {
             w,
-            comp: Compression::default(),
+            comp: comp.into_tiff(),
         }
     }
 
-    /// Set the image compression setting
-    pub fn with_compression(mut self, comp: Compression) -> Self {
-        self.comp = comp;
-        self
-    }
-
     /// Encodes the image `image` that has dimensions `width` and `height` and `ColorType` `c`.
     ///
     /// 16-bit types assume the buffer is native endian.

tests/reference_images.rs

@@ -42,7 +42,7 @@ where
 #[cfg(feature = "tiff")]
 #[test]
 fn compress_deflate() {
-    use image::codecs::tiff::TiffEncoder;
+    use image::codecs::tiff::{CompressionType, TiffDeflateLevel, TiffEncoder};
 
     process_images(IMAGE_DIR, Some("tiff"), |base, path, _| {
         println!("compress_images {}", path.display());
@@ -64,8 +64,9 @@ fn compress_deflate() {
         out_path.push("deflate");
         std::fs::create_dir_all(&out_path).unwrap();
         out_path.push(path.file_name().unwrap());
-        let encoder = TiffEncoder::new(fs::File::create(&out_path).unwrap()).with_compression(
-            tiff::encoder::Compression::Deflate(tiff::encoder::DeflateLevel::Balanced),
+        let encoder = TiffEncoder::new_with_compression(
+            fs::File::create(&out_path).unwrap(),
+            CompressionType::Deflate(TiffDeflateLevel::Balanced),
         );
         img.write_with_encoder(encoder).unwrap();
     })
@@ -74,7 +75,7 @@ fn compress_deflate() {
 #[cfg(feature = "tiff")]
 #[test]
 fn compress_lzw() {
-    use image::codecs::tiff::TiffEncoder;
+    use image::codecs::tiff::{CompressionType, TiffEncoder};
 
     process_images(IMAGE_DIR, Some("tiff"), |base, path, _| {
         println!("compress_images {}", path.display());
@@ -96,8 +97,10 @@ fn compress_lzw() {
         out_path.push("lzw");
         std::fs::create_dir_all(&out_path).unwrap();
         out_path.push(path.file_name().unwrap());
-        let encoder = TiffEncoder::new(fs::File::create(&out_path).unwrap())
-            .with_compression(tiff::encoder::Compression::Lzw);
+        let encoder = TiffEncoder::new_with_compression(
+            fs::File::create(&out_path).unwrap(),
+            CompressionType::Lzw,
+        );
         img.write_with_encoder(encoder).unwrap();
     })
 }