fix: moved encoders to separate modules

src/codecs/avif/encoder/mod.rs

@@ -0,0 +1,115 @@
+use ravif::Img;
+use rgb::FromSlice;
+use zune_core::{bit_depth::BitDepth, colorspace::ColorSpace};
+use zune_image::{
+ codecs::ImageFormat,
+ errors::{ImageErrors, ImgEncodeErrors},
+ traits::EncoderTrait,
+};
+
+/// Advanced options for AVIF encoding
+pub struct AvifOptions {
+ quality: f32,
+ alpha_quality: Option<f32>,
+ speed: u8,
+ color_space: ravif::ColorSpace,
+ alpha_color_mode: ravif::AlphaColorMode,
+}
+
+/// A AVIF encoder
+pub struct AvifEncoder {
+ options: AvifOptions,
+}
+
+impl Default for AvifOptions {
+ fn default() -> Self {
+ Self {
+ quality: 50.,
+ alpha_quality: None,
+ speed: 6,
+ color_space: ravif::ColorSpace::YCbCr,
+ alpha_color_mode: ravif::AlphaColorMode::UnassociatedClean,
+ }
+ }
+}
+
+impl Default for AvifEncoder {
+ fn default() -> Self {
+ Self {
+ options: Default::default(),
+ }
+ }
+}
+
+impl AvifEncoder {
+ /// Create a new encoder
+ pub fn new() -> AvifEncoder {
+ AvifEncoder::default()
+ }
+
+ /// Create a new encoder with specified options
+ pub fn new_with_options(options: AvifOptions) -> AvifEncoder {
+ AvifEncoder { options }
+ }
+}
+
+impl EncoderTrait for AvifEncoder {
+ fn name(&self) -> &'static str {
+ "avif"
+ }
+
+ fn encode_inner(&mut self, image: &zune_image::image::Image) -> Result<Vec<u8>, ImageErrors> {
+ let (width, height) = image.dimensions();
+ let data = &image.flatten_to_u8()[0];
+
+ let encoder = ravif::Encoder::new()
+ .with_quality(self.options.quality)
+ .with_alpha_quality(self.options.alpha_quality.unwrap_or(self.options.quality))
+ .with_speed(self.options.speed)
+ .with_internal_color_space(self.options.color_space)
+ .with_alpha_color_mode(self.options.alpha_color_mode);
+
+ match image.colorspace() {
+ ColorSpace::RGB => {
+ let img = Img::new(data.as_slice().as_rgb(), width, height);
+ let result = encoder
+ .encode_rgb(img)
+ .map_err(|e| ImgEncodeErrors::ImageEncodeErrors(e.to_string()))?;
+
+ Ok(result.avif_file)
+ }
+ ColorSpace::RGBA => {
+ let img = Img::new(data.as_slice().as_rgba(), width, height);
+ let result = encoder
+ .encode_rgba(img)
+ .map_err(|e| ImgEncodeErrors::ImageEncodeErrors(e.to_string()))?;
+
+ Ok(result.avif_file)
+ }
+ cs => Err(ImageErrors::EncodeErrors(
+ ImgEncodeErrors::UnsupportedColorspace(cs, self.supported_colorspaces()),
+ )),
+ }
+ }
+
+ fn supported_colorspaces(&self) -> &'static [ColorSpace] {
+ &[ColorSpace::RGB, ColorSpace::RGBA]
+ }
+
+ fn format(&self) -> ImageFormat {
+ ImageFormat::Unknown
+ }
+
+ fn supported_bit_depth(&self) -> &'static [BitDepth] {
+ &[BitDepth::Eight]
+ }
+
+ fn default_depth(&self, depth: BitDepth) -> BitDepth {
+ match depth {
+ _ => BitDepth::Eight,
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests;

src/codecs/avif/mod.rs

@@ -1,115 +1,3 @@
-use ravif::Img;
-use rgb::FromSlice;
-use zune_core::{bit_depth::BitDepth, colorspace::ColorSpace};
-use zune_image::{
- codecs::ImageFormat,
- errors::{ImageErrors, ImgEncodeErrors},
- traits::EncoderTrait,
-};
+mod encoder;
 
-/// Advanced options for AVIF encoding
-pub struct AvifOptions {
- quality: f32,
- alpha_quality: Option<f32>,
- speed: u8,
- color_space: ravif::ColorSpace,
- alpha_color_mode: ravif::AlphaColorMode,
-}
-
-/// A AVIF encoder
-pub struct AvifEncoder {
- options: AvifOptions,
-}
-
-impl Default for AvifOptions {
- fn default() -> Self {
- Self {
- quality: 50.,
- alpha_quality: None,
- speed: 6,
- color_space: ravif::ColorSpace::YCbCr,
- alpha_color_mode: ravif::AlphaColorMode::UnassociatedClean,
- }
- }
-}
-
-impl Default for AvifEncoder {
- fn default() -> Self {
- Self {
- options: Default::default(),
- }
- }
-}
-
-impl AvifEncoder {
- /// Create a new encoder
- pub fn new() -> AvifEncoder {
- AvifEncoder::default()
- }
-
- /// Create a new encoder with specified options
- pub fn new_with_options(options: AvifOptions) -> AvifEncoder {
- AvifEncoder { options }
- }
-}
-
-impl EncoderTrait for AvifEncoder {
- fn name(&self) -> &'static str {
- "avif"
- }
-
- fn encode_inner(&mut self, image: &zune_image::image::Image) -> Result<Vec<u8>, ImageErrors> {
- let (width, height) = image.dimensions();
- let data = &image.flatten_to_u8()[0];
-
- let encoder = ravif::Encoder::new()
- .with_quality(self.options.quality)
- .with_alpha_quality(self.options.alpha_quality.unwrap_or(self.options.quality))
- .with_speed(self.options.speed)
- .with_internal_color_space(self.options.color_space)
- .with_alpha_color_mode(self.options.alpha_color_mode);
-
- match image.colorspace() {
- ColorSpace::RGB => {
- let img = Img::new(data.as_slice().as_rgb(), width, height);
- let result = encoder
- .encode_rgb(img)
- .map_err(|e| ImgEncodeErrors::ImageEncodeErrors(e.to_string()))?;
-
- Ok(result.avif_file)
- }
- ColorSpace::RGBA => {
- let img = Img::new(data.as_slice().as_rgba(), width, height);
- let result = encoder
- .encode_rgba(img)
- .map_err(|e| ImgEncodeErrors::ImageEncodeErrors(e.to_string()))?;
-
- Ok(result.avif_file)
- }
- cs => Err(ImageErrors::EncodeErrors(
- ImgEncodeErrors::UnsupportedColorspace(cs, self.supported_colorspaces()),
- )),
- }
- }
-
- fn supported_colorspaces(&self) -> &'static [ColorSpace] {
- &[ColorSpace::RGB, ColorSpace::RGBA]
- }
-
- fn format(&self) -> ImageFormat {
- ImageFormat::Unknown
- }
-
- fn supported_bit_depth(&self) -> &'static [BitDepth] {
- &[BitDepth::Eight]
- }
-
- fn default_depth(&self, depth: BitDepth) -> BitDepth {
- match depth {
- _ => BitDepth::Eight,
- }
- }
-}
-
-#[cfg(test)]
-mod tests;
+pub use encoder::*;