refactor: move image logic to utils

src/utils.rs

@@ -0,0 +1,151 @@
+use std::{
+    ffi::OsStr,
+    fs,
+    io::Write,
+    path::{Path, PathBuf},
+};
+
+use image::{DynamicImage, ImageDecoder, ImageReader, RgbaImage};
+use jpegxl_rs::image::ToDynamic;
+use rfd::FileDialog;
+
+pub fn load_image(path: impl AsRef<Path>) -> Result<RgbaImage, String> {
+    let path = path.as_ref();
+
+    let decoded_image = match path.extension().map(OsStr::to_string_lossy).as_deref() {
+        Some("jxl") => {
+            let data = match std::fs::read(path) {
+                Ok(d) => d,
+                Err(e) => {
+                    return Err(format!(
+                        "failed to read data from '{}': {e}",
+                        path.display()
+                    ));
+                }
+            };
+
+            match jpegxl_rs::decoder_builder()
+                .build()
+                .unwrap()
+                .decode_to_image(&data)
+            {
+                Ok(Some(decoded_image)) => decoded_image,
+                Ok(None) => {
+                    return Err(format!(
+                        "failed to convert jxl '{}' to DynamicImage",
+                        path.display()
+                    ));
+                }
+                Err(e) => {
+                    return Err(format!("failed to decode jxl '{}': {e}", path.display()));
+                }
+            }
+        }
+
+        _ => {
+            let reader = match ImageReader::open(path) {
+                Ok(r) => r,
+                Err(e) => {
+                    return Err(format!(
+                        "failed to create reader for '{}': {e}",
+                        path.display()
+                    ));
+                }
+            };
+
+            let mut decoder = match reader.into_decoder() {
+                Ok(d) => d,
+                Err(e) => {
+                    return Err(format!(
+                        "failed to create decoder for '{}': {e}",
+                        path.display()
+                    ));
+                }
+            };
+
+            let oreintation = match decoder.orientation() {
+                Ok(o) => o,
+                Err(e) => {
+                    return Err(format!(
+                        "failed to get oreintation of '{}': {e}",
+                        path.display()
+                    ));
+                }
+            };
+
+            let mut decoded_image = match DynamicImage::from_decoder(decoder) {
+                Ok(i) => i,
+                Err(e) => {
+                    return Err(format!("failed to decode image '{}': {e}", path.display()));
+                }
+            };
+
+            decoded_image.apply_orientation(oreintation);
+
+            decoded_image
+        }
+    };
+
+    Ok(decoded_image.into_rgba8())
+}
+pub fn pick_image() -> Result<PathBuf, String> {
+    let Some(path) = FileDialog::new()
+        .add_filter(
+            "image",
+            &[
+                "png", "PNG", "jpg", "JPG", "jpeg", "JPEG", "avif", "jxl", "bmp", "exr", "ff",
+                "gif", "hdr", "ico", "pnm", "qoi", "tga", "tiff", "webp",
+            ],
+        )
+        .pick_file()
+    else {
+        return Err("no path to open provided".into());
+    };
+
+    Ok(path)
+}
+
+#[must_use]
+pub fn save_image(image: Option<&RgbaImage>) -> Option<String> {
+    let Some(image) = image else {
+        return Some("no image to save".into());
+    };
+
+    let Some(path) = FileDialog::new().save_file() else {
+        return Some("no path to save provided".into());
+    };
+
+    let mut file = match fs::File::create(&path) {
+        Ok(f) => f,
+        Err(e) => return Some(format!("failed to create file '{}': {e}", path.display())),
+    };
+
+    match path.extension().map(OsStr::to_string_lossy).as_deref() {
+        Some("jxl") => {
+            let mut encoder = jpegxl_rs::encoder_builder()
+                .speed(jpegxl_rs::encode::EncoderSpeed::Glacier)
+                .lossless(true)
+                .build()
+                .unwrap();
+            let rgb_image = DynamicImage::from(image.to_owned()).into_rgb8();
+            let jxl =
+                match encoder.encode::<u8, u8>(&rgb_image, rgb_image.width(), rgb_image.height()) {
+                    Ok(j) => j,
+                    Err(e) => {
+                        return Some(format!("failed to encode jxl '{}': {e}", path.display()));
+                    }
+                };
+
+            if let Err(e) = file.write(&jxl.data) {
+                return Some(format!("failed to write jxl to '{}': {e}", path.display()));
+            };
+        }
+        _ => {
+            if let Err(e) = image.save(&path) {
+                return Some(format!("failed to save '{}': {e}", path.display()));
+            };
+        }
+    };
+
+    None
+}