Fixed JXL, improved orientation

Cargo.toml

@@ -12,26 +12,22 @@ pollster = "0.4.0"
 
 clap = { version = "4.5.34", features = ["derive"] }
 eframe = "0.31.1"
-# egui = "0.31.1"
-# egui_extras = { version = "0.31.1", features = ["all_loaders"] }
 env_logger = "0.11.7"
-iced = { version = "0.13.1", features = ["debug", "canvas", "tokio", "image"]}
 image = "0.25.6"
 
 itertools = "0.12"
 memmap2 = "0.9.5"
 minifb = "0.28.0"
-# pollster = "0.4.0"
 rexiv2 = "0.10.0"
 threadpool = "1.8.1"
-# rustc-hash.workspace = true
 tokio = { version = "1.44.1", features = ["sync"] }
 tracing-subscriber = "0.3"
 wgpu = "24.0.3"
-# winit = "0.30.9"
 zune-image = {version = "0.4.15", features = ["all"]}
 bytemuck = "1.22.0"
 libheif-rs = "1.1.0"
+jpegxl-rs = "0.11.2"
+
 [profile.release]
 opt-level = 3
 debug = false

benches/image_load.rs

@@ -17,6 +17,9 @@ use imflow::image::{
     ImflowImageBuffer, get_orientation, get_rating, image_to_rgba_buffer, load_available_images,
     load_image, load_thumbnail_exif, load_thumbnail_full,
 };
+use jpegxl_rs::Endianness;
+use jpegxl_rs::decode::{Data, PixelFormat, Pixels};
+use jpegxl_rs::decoder_builder;
 use zune_image::codecs::jpeg::JpegDecoder as ZuneJpegDecoder;
 use zune_image::codecs::qoi::zune_core::colorspace::ColorSpace;
 use zune_image::codecs::qoi::zune_core::options::DecoderOptions;
@@ -150,6 +153,47 @@ fn load_b(path: &PathBuf) -> ImflowImageBuffer {
         rating,
     }
 }
+
+fn load_jxl_single(path: &PathBuf) -> (jpegxl_rs::decode::Metadata, Vec<u8>) {
+    let file = read(path).unwrap();
+    use jpegxl_rs::ThreadsRunner;
+    let runner = ThreadsRunner::default();
+    let decoder = decoder_builder()
+        // .parallel_runner(&runner)
+        .pixel_format(PixelFormat {
+            num_channels: 4,
+            endianness: Endianness::Big,
+            align: 8,
+        })
+        .build()
+        .unwrap();
+
+    decoder.decode_with::<u8>(&file).unwrap()
+    // buffer = data;
+    // width = metadata.width as usize;
+    // height = metadata.height as usize;
+}
+
+fn load_jxl_multi(path: &PathBuf) -> (jpegxl_rs::decode::Metadata, Vec<u8>) {
+    let file = read(path).unwrap();
+    use jpegxl_rs::ThreadsRunner;
+    let runner = ThreadsRunner::default();
+    let decoder = decoder_builder()
+        .parallel_runner(&runner)
+        .pixel_format(PixelFormat {
+            num_channels: 4,
+            endianness: Endianness::Big,
+            align: 8,
+        })
+        .build()
+        .unwrap();
+
+    decoder.decode_with::<u8>(&file).unwrap()
+    // buffer = data;
+    // width = metadata.width as usize;
+    // height = metadata.height as usize;
+}
+
 // fn load_b(path: &PathBuf) -> ImflowImageBuffer {
 //     println!("path: {:?}", path);
 //     // let file = read(path.clone()).unwrap();
@@ -222,6 +266,29 @@ pub fn file_load_benchmark(c: &mut Criterion) {
     group.finish();
 }
 
+pub fn jxl_multithreading_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("jxl_multithreading");
+
+    group
+        .sample_size(10)
+        .measurement_time(Duration::from_millis(500))
+        .warm_up_time(Duration::from_millis(200));
+
+    let images = load_available_images("./test_images/jxl".into());
+    group.bench_function("single", |b| {
+        for image in images.iter().take(10) {
+            b.iter(|| load_jxl_single(image));
+        }
+    });
+    group.bench_function("multi", |b| {
+        for image in images.iter().take(10) {
+            b.iter(|| load_jxl_multi(image));
+        }
+    });
+
+    group.finish();
+}
 // criterion_group!(benches, thumbnail_load_benchmark);
-criterion_group!(benches, file_load_benchmark);
+// criterion_group!(benches, file_load_benchmark);
+criterion_group!(benches, jxl_multithreading_benchmark);
 criterion_main!(benches);

src/image.rs

@@ -1,8 +1,13 @@
-use iced::widget::image::Handle;
 use image::DynamicImage;
+use image::ImageDecoder;
 use image::RgbaImage;
 use image::imageops::FilterType;
 use image::metadata::Orientation;
+use jpegxl_rs::Endianness;
+use jpegxl_rs::decode::Data;
+use jpegxl_rs::decode::PixelFormat;
+use jpegxl_rs::decode::Pixels;
+use jpegxl_rs::decoder_builder;
 use libheif_rs::{HeifContext, LibHeif, RgbChroma};
 use rexiv2::Metadata;
 use zune_image::codecs::jpeg::JpegDecoder;
@@ -16,6 +21,7 @@ use std::fs::File;
 use std::fs::read;
 use std::io::BufReader;
 use std::io::Cursor;
+use std::io::Read;
 use std::mem;
 use std::path::PathBuf;
 use std::time::Instant;
@@ -27,9 +33,9 @@ pub struct ImflowImageBuffer {
     pub rating: i32,
 }
 
-pub fn create_iced_handle(width: u32, height: u32, rgba: Vec<u8>) -> Handle {
+// pub fn create_iced_handle(width: u32, height: u32, rgba: Vec<u8>) -> Handle {
-    Handle::from_rgba(width, height, rgba)
+//     Handle::from_rgba(width, height, rgba)
-}
+// }
 
 pub fn get_rating(filename: &PathBuf) -> i32 {
     // // Use xmp-toolkit for video files
@@ -86,23 +92,49 @@ pub fn load_image(path: &PathBuf) -> ImflowImageBuffer {
         return img;
     }
 
-    if is_jxl(path) {}
-
-    let options = DecoderOptions::new_fast().jpeg_set_out_colorspace(ColorSpace::RGBA);
-
-    let mut buffer: Vec<u8>;
     let width: usize;
     let height: usize;
+    let rating = get_rating(path);
     if is_jxl(path) {
-        let file = BufReader::new(File::open(path).unwrap());
+        let file = read(path).unwrap();
-        let mut decoder = JxlDecoder::try_new(file, options).unwrap();
+        use jpegxl_rs::ThreadsRunner;
-        let image =
+        let runner = ThreadsRunner::default();
-            <JxlDecoder<std::io::BufReader<File>> as DecoderTrait<&[u8]>>::decode(&mut decoder)
+        let decoder = decoder_builder()
-                .unwrap();
+            .parallel_runner(&runner)
-        (width, height) = image.dimensions();
+            .pixel_format(PixelFormat {
-        buffer = (*image.flatten_to_u8().get(0).unwrap().clone()).to_vec();
+                num_channels: 4,
-        println!("buffer len: {} {} {}", buffer.len(), width, height);
+                endianness: Endianness::Big,
+                align: 8,
+            })
+            .build()
+            .unwrap();
+
+        let (metadata, buffer) = decoder.decode_with::<u8>(&file).unwrap();
+        width = metadata.width as usize;
+        height = metadata.height as usize;
+
+        let rgba_buffer = unsafe {
+            Vec::from_raw_parts(
+                buffer.as_ptr() as *mut u32,
+                buffer.len() / 4,
+                buffer.len() / 4,
+            )
+        };
+        std::mem::forget(buffer);
+
+        println!("Total loading time: {:?}", total_start.elapsed());
+
+        let rating = get_rating(path);
+
+        ImflowImageBuffer {
+            width,
+            height,
+            rgba_buffer,
+            rating,
+        }
     } else {
+        let mut buffer: Vec<u8>;
+        let options = DecoderOptions::new_fast().jpeg_set_out_colorspace(ColorSpace::RGBA);
         let file = read(path.clone()).unwrap();
         let mut decoder = JpegDecoder::new(&file);
         decoder.set_options(options);
@@ -113,37 +145,36 @@ pub fn load_image(path: &PathBuf) -> ImflowImageBuffer {
         height = info.height as usize;
         buffer = vec![0; width * height * 4];
         decoder.decode_into(buffer.as_mut_slice()).unwrap();
-    };
 
-    // TODO: Optimize rotation
+        let orientation_start = Instant::now();
-    // let orientation =
+        // TODO: Optimize rotation
-    //     Orientation::from_exif(get_orientation(path)).unwrap_or(Orientation::NoTransforms);
+        let orientation =
-    // let image = RgbaImage::from_raw(width as u32, height as u32, buffer).unwrap();
+            Orientation::from_exif(get_orientation(path)).unwrap_or(Orientation::NoTransforms);
-    // let mut dynamic_image = DynamicImage::from(image);
+        let image = RgbaImage::from_raw(width as u32, height as u32, buffer).unwrap();
-    // dynamic_image.apply_orientation(orientation);
+        let mut dynamic_image = DynamicImage::from(image);
-    // let mut buffer = dynamic_image.to_rgba8();
+        dynamic_image.apply_orientation(orientation);
-    // let (width, height) = swap_wh(width, height, orientation);
+        let buffer = dynamic_image.as_rgba8().unwrap();
+        let (width, height) = swap_wh(width, height, orientation);
+        let orientation_time = orientation_start.elapsed();
 
-    // Reinterpret to avoid copying
+        // Reinterpret to avoid copying
-    let buffer_u32 = unsafe {
+        let rgba_buffer = unsafe {
-        Vec::from_raw_parts(
+            Vec::from_raw_parts(
-            buffer.as_mut_ptr() as *mut u32,
+                buffer.as_ptr() as *mut u32,
-            buffer.len() / 4,
+                buffer.len() / 4,
-            buffer.len() / 4,
+                buffer.len() / 4,
-        )
+            )
-    };
+        };
-    std::mem::forget(buffer);
+        std::mem::forget(dynamic_image);
-
+        let total_time = total_start.elapsed();
-    let total_time = total_start.elapsed();
+        println!("Orientation time: {:?}", orientation_time);
-    println!("Total loading time: {:?}", total_time);
+        println!("Total loading time: {:?}", total_time);
-
+        ImflowImageBuffer {
-    let rating = get_rating(path);
+            width,
-
+            height,
-    ImflowImageBuffer {
+            rgba_buffer,
-        width,
+            rating,
-        height,
+        }
-        rgba_buffer: buffer_u32,
-        rating,
     }
 }