feat: added mozjpeg encoder

Cargo.toml

@@ -19,19 +19,24 @@ codegen-units = 1
 opt-level = "z"
 
 [features]
-default = ["resize", "quantization", "threads"]
+default = ["resize", "quantization", "mozjpeg", "threads"]
 
 # Enables utilization of threads
-threads = ["imagequant?/threads"]
+threads = ["imagequant?/threads", "mozjpeg?/parallel"]
 
 # Enables resize operation
 resize = ["dep:fast_image_resize"]
 # Enables quantize operation
 quantization = ["dep:imagequant", "dep:rgb"]
 
+# Enables mozjpeg codec
+mozjpeg = ["dep:mozjpeg"]
+
 [dependencies]
 zune-core = "0.4.12"
 zune-image = { version = "0.4.15", default-features = false }
 fast_image_resize = { version = "3.0.4", optional = true }
 imagequant = { version = "4.3.0", default-features = false, optional = true }
 rgb = { version = "0.8.37", optional = true }
+mozjpeg = { version = "0.10.7", default-features = false, features = ["with_simd"], optional = true }
+log = "0.4.21"

src/codecs/mod.rs

@@ -0,0 +1,2 @@
+#[cfg(feature = "mozjpeg")]
+pub mod mozjpeg;

src/codecs/mozjpeg/mod.rs

@@ -0,0 +1,175 @@
+use std::mem;
+
+use mozjpeg::qtable::QTable;
+use zune_core::{bit_depth::BitDepth, colorspace::ColorSpace};
+use zune_image::{codecs::ImageFormat, errors::ImageErrors, image::Image, traits::EncoderTrait};
+
+pub struct MozJpegOptions {
+    quality: f32,
+    progressive: bool,
+    optimize_coding: bool,
+    smoothing: u8,
+    color_space: mozjpeg::ColorSpace,
+    trellis_multipass: bool,
+    chroma_subsample: Option<u8>,
+    luma_qtable: Option<&'static QTable>,
+    chroma_qtable: Option<&'static QTable>,
+}
+
+pub struct MozJpegEncoder {
+    options: MozJpegOptions,
+}
+
+impl Default for MozJpegOptions {
+    fn default() -> Self {
+        Self {
+            quality: 75.,
+            progressive: true,
+            optimize_coding: true,
+            smoothing: 0,
+            color_space: mozjpeg::ColorSpace::JCS_YCbCr,
+            trellis_multipass: false,
+            chroma_subsample: None,
+            luma_qtable: None,
+            chroma_qtable: None,
+        }
+    }
+}
+
+impl Default for MozJpegEncoder {
+    fn default() -> Self {
+        Self {
+            options: Default::default(),
+        }
+    }
+}
+
+impl MozJpegEncoder {
+    pub fn new() -> MozJpegEncoder {
+        MozJpegEncoder::default()
+    }
+
+    pub fn new_with_options(options: MozJpegOptions) -> MozJpegEncoder {
+        MozJpegEncoder { options }
+    }
+}
+
+impl EncoderTrait for MozJpegEncoder {
+    fn name(&self) -> &'static str {
+        "mozjpeg-encoder"
+    }
+
+    fn encode_inner(&mut self, image: &Image) -> Result<Vec<u8>, ImageErrors> {
+        let (width, height) = image.dimensions();
+        let data = &image.flatten_to_u8()[0];
+
+        std::panic::catch_unwind(|| -> Result<Vec<u8>, ImageErrors> {
+            let format = match image.colorspace() {
+                ColorSpace::RGB => mozjpeg::ColorSpace::JCS_RGB,
+                ColorSpace::RGBA => mozjpeg::ColorSpace::JCS_EXT_RGBA,
+                ColorSpace::YCbCr => mozjpeg::ColorSpace::JCS_YCbCr,
+                ColorSpace::Luma => mozjpeg::ColorSpace::JCS_GRAYSCALE,
+                ColorSpace::YCCK => mozjpeg::ColorSpace::JCS_YCCK,
+                ColorSpace::CMYK => mozjpeg::ColorSpace::JCS_CMYK,
+                ColorSpace::BGR => mozjpeg::ColorSpace::JCS_EXT_BGR,
+                ColorSpace::BGRA => mozjpeg::ColorSpace::JCS_EXT_BGRA,
+                ColorSpace::ARGB => mozjpeg::ColorSpace::JCS_EXT_ARGB,
+                ColorSpace::Unknown => mozjpeg::ColorSpace::JCS_UNKNOWN,
+                _ => mozjpeg::ColorSpace::JCS_UNKNOWN,
+            };
+
+            let mut comp = mozjpeg::Compress::new(format);
+
+            comp.set_size(width, height);
+            comp.set_quality(self.options.quality);
+
+            if self.options.progressive {
+                comp.set_progressive_mode();
+            }
+
+            comp.set_optimize_coding(self.options.optimize_coding);
+            comp.set_smoothing_factor(self.options.smoothing);
+            comp.set_color_space(match format {
+                mozjpeg::ColorSpace::JCS_GRAYSCALE => {
+                    log::warn!("Input colorspace is GRAYSCALE, using GRAYSCALE as output");
+
+                    mozjpeg::ColorSpace::JCS_GRAYSCALE
+                }
+                mozjpeg::ColorSpace::JCS_CMYK => {
+                    log::warn!("Input colorspace is CMYK, using CMYK as output");
+
+                    mozjpeg::ColorSpace::JCS_CMYK
+                }
+                mozjpeg::ColorSpace::JCS_YCCK => {
+                    log::warn!("Input colorspace is YCCK, using YCCK as output");
+
+                    mozjpeg::ColorSpace::JCS_YCCK
+                }
+
+                _ => self.options.color_space,
+            });
+            comp.set_use_scans_in_trellis(self.options.trellis_multipass);
+
+            if let Some(sb) = self.options.chroma_subsample {
+                comp.set_chroma_sampling_pixel_sizes((sb, sb), (sb, sb))
+            }
+
+            if let Some(qtable) = self.options.luma_qtable {
+                comp.set_luma_qtable(qtable)
+            }
+
+            if let Some(qtable) = self.options.chroma_qtable {
+                comp.set_chroma_qtable(qtable)
+            }
+
+            let mut comp = comp.start_compress(Vec::new())?;
+
+            comp.write_scanlines(&data)?;
+
+            Ok(comp.finish()?)
+        })
+        .map_err(|err| {
+            if let Ok(mut err) = err.downcast::<String>() {
+                ImageErrors::EncodeErrors(zune_image::errors::ImgEncodeErrors::Generic(mem::take(
+                    &mut *err,
+                )))
+            } else {
+                ImageErrors::EncodeErrors(zune_image::errors::ImgEncodeErrors::GenericStatic(
+                    "Unknown error occurred during encoding",
+                ))
+            }
+        })?
+    }
+
+    fn supported_colorspaces(&self) -> &'static [ColorSpace] {
+        &[
+            ColorSpace::Luma,
+            ColorSpace::RGBA,
+            ColorSpace::RGB,
+            ColorSpace::YCCK,
+            ColorSpace::CMYK,
+            ColorSpace::BGR,
+            ColorSpace::BGRA,
+            ColorSpace::ARGB,
+            ColorSpace::YCbCr,
+        ]
+    }
+
+    fn format(&self) -> zune_image::codecs::ImageFormat {
+        ImageFormat::JPEG
+    }
+
+    fn supported_bit_depth(&self) -> &'static [BitDepth] {
+        &[BitDepth::Eight, BitDepth::Sixteen]
+    }
+
+    fn default_depth(&self, depth: BitDepth) -> BitDepth {
+        match depth {
+            BitDepth::Sixteen | BitDepth::Float32 => BitDepth::Sixteen,
+            _ => BitDepth::Eight,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;