Merge pull request #125 from awxkee/v703

awxkee · web-flow · commit ebd256f5fc11 · 2026-03-23T08:22:31.000Z
RGB F32 AVX improvements
diff --git a/app/src/main.rs b/app/src/main.rs
@@ -34,29 +34,29 @@ fn main() {
         .unwrap();
     // img.save("top_right.tga").unwrap();
     let dimensions = img.dimensions();
-    let transient = img.to_luma_alpha8();
+    let transient = img.to_rgb32f();
     let mut bytes = transient.to_vec();
 
     // img.resize_exact(dimensions.0 as u32 / 4, dimensions.1 as u32 / 4, image::imageops::FilterType::Lanczos3).save("resized.png").unwrap();
 
     let mut scaler = Scaler::new(ResamplingFunction::Lanczos3)
         .set_threading_policy(ThreadingPolicy::Single)
-        .set_workload_strategy(WorkloadStrategy::PreferQuality);
+        .set_workload_strategy(WorkloadStrategy::PreferSpeed);
     // scaler.set_workload_strategy(WorkloadStrategy::PreferSpeed);
 
     let mut t_size = ImageSize::new(dimensions.0 as usize, dimensions.1 as usize) / 4;
     t_size.height += 1;
     let resizing_plan = scaler
-        .plan_cbcr_resampling(
+        .plan_rgb_resampling_f32(
             ImageSize::new(dimensions.0 as usize, dimensions.1 as usize),
             t_size,
         )
         .unwrap();
 
     let mut store =
-        CbCr8ImageStore::from_slice(&bytes, dimensions.0 as usize, dimensions.1 as usize).unwrap();
+        RgbF32ImageStore::from_slice(&bytes, dimensions.0 as usize, dimensions.1 as usize).unwrap();
     store.bit_depth = 8;
-    let mut dst_store = CbCr8ImageStoreMut::alloc_with_depth(
+    let mut dst_store = RgbF32ImageStoreMut::alloc_with_depth(
         dimensions.0 as usize / 4,
         dimensions.1 as usize / 4 + 1,
         8,
@@ -113,9 +113,9 @@ fn main() {
     let dst = dst_store
         .as_bytes()
         .iter()
-        .map(|&x| x)
+        // .map(|&x| x)
         // .map(|&x| ((x >> 8) as u8).min(255))
-        // .map(|&x| (x as f32 * 255.).round() as u8)
+        .map(|&x| (x as f32 * 255.).round() as u8)
         .collect::<Vec<_>>();
 
     if dst_store.channels == 4 {
diff --git a/src/avx2/check_alpha.rs b/src/avx2/check_alpha.rs
@@ -39,11 +39,7 @@ pub(crate) fn avx_has_non_constant_cap_alpha_rgba8(
 }
 
 #[target_feature(enable = "avx2")]
-unsafe fn avx_has_non_constant_cap_alpha_rgba8_impl(
-    store: &[u8],
-    width: usize,
-    stride: usize,
-) -> bool {
+fn avx_has_non_constant_cap_alpha_rgba8_impl(store: &[u8], width: usize, stride: usize) -> bool {
     unsafe {
         if store.is_empty() {
             return true;
@@ -138,11 +134,7 @@ pub(crate) fn avx_has_non_constant_cap_alpha_rgba16(
 }
 
 #[target_feature(enable = "avx2")]
-unsafe fn avx_has_non_constant_cap_alpha_rgba16_impl(
-    store: &[u16],
-    width: usize,
-    stride: usize,
-) -> bool {
+fn avx_has_non_constant_cap_alpha_rgba16_impl(store: &[u16], width: usize, stride: usize) -> bool {
     unsafe {
         if store.is_empty() {
             return true;
diff --git a/src/avx2/horizontal_ar30.rs b/src/avx2/horizontal_ar30.rs
@@ -151,7 +151,7 @@ impl<const AR_TYPE: usize, const AR_ORDER: usize> Row4ExecutionUnit<AR_TYPE, AR_
 
     #[inline]
     #[target_feature(enable = "avx2")]
-    unsafe fn conv_horiz_rgba_1_u8_i16(
+    fn conv_horiz_rgba_1_u8_i16(
         &self,
         start_x: usize,
         src0: &[u8],
diff --git a/src/avx2/mod.rs b/src/avx2/mod.rs
@@ -82,7 +82,8 @@ pub(crate) use plane_f32_f64::{
     convolve_hor_plane_avx_row_one_f32_f64, convolve_hor_plane_avx_rows_4_f32_f64,
 };
 pub(crate) use plane_u16::{
-    convolve_horizontal_plane_avx_rows_4_u16_f, convolve_horizontal_plane_avx_u16_row_f,
+    convolve_horizontal_plane_avx_rows_4_u16_default, convolve_horizontal_plane_avx_rows_4_u16_fma,
+    convolve_horizontal_plane_avx_u16_row_default, convolve_horizontal_plane_avx_u16_row_fma,
 };
 pub(crate) use plane_u16_lb::{
     convolve_horizontal_plane_avx_rows_4_u16, convolve_horizontal_plane_avx_u16lp_row,
diff --git a/src/avx2/plane_u16.rs b/src/avx2/plane_u16.rs
@@ -110,7 +110,7 @@ fn conv_horiz_rgba_8_u16<const FMA: bool>(
     }
 }
 
-pub(crate) fn convolve_horizontal_plane_avx_rows_4_u16_f(
+pub(crate) fn convolve_horizontal_plane_avx_rows_4_u16_default(
     src: &[u16],
     src_stride: usize,
     dst: &mut [u16],
@@ -119,25 +119,34 @@ pub(crate) fn convolve_horizontal_plane_avx_rows_4_u16_f(
     bit_depth: u32,
 ) {
     unsafe {
-        if std::arch::is_x86_feature_detected!("fma") {
-            convolve_horizontal_plane_avx_rows_4_u16_fma(
-                src,
-                src_stride,
-                dst,
-                dst_stride,
-                filter_weights,
-                bit_depth,
-            );
-        } else {
-            convolve_horizontal_plane_avx_rows_4_u16_def(
-                src,
-                src_stride,
-                dst,
-                dst_stride,
-                filter_weights,
-                bit_depth,
-            );
-        }
+        convolve_horizontal_plane_avx_rows_4_u16_def(
+            src,
+            src_stride,
+            dst,
+            dst_stride,
+            filter_weights,
+            bit_depth,
+        );
+    }
+}
+
+pub(crate) fn convolve_horizontal_plane_avx_rows_4_u16_fma(
+    src: &[u16],
+    src_stride: usize,
+    dst: &mut [u16],
+    dst_stride: usize,
+    filter_weights: &FilterWeights<f32>,
+    bit_depth: u32,
+) {
+    unsafe {
+        convolve_horizontal_plane_avx_rows_4_u16_fma_impl(
+            src,
+            src_stride,
+            dst,
+            dst_stride,
+            filter_weights,
+            bit_depth,
+        );
     }
 }
 
@@ -157,7 +166,7 @@ fn convolve_horizontal_plane_avx_rows_4_u16_def(
 
 #[target_feature(enable = "avx2", enable = "fma")]
 /// This inlining is required to activate all features for runtime dispatch.
-fn convolve_horizontal_plane_avx_rows_4_u16_fma(
+fn convolve_horizontal_plane_avx_rows_4_u16_fma_impl(
     src: &[u16],
     src_stride: usize,
     dst: &mut [u16],
@@ -282,18 +291,25 @@ impl<const FMA: bool> Row4ExecutionHandler<FMA> {
     }
 }
 
-pub(crate) fn convolve_horizontal_plane_avx_u16_row_f(
+pub(crate) fn convolve_horizontal_plane_avx_u16_row_fma(
     src: &[u16],
     dst: &mut [u16],
     filter_weights: &FilterWeights<f32>,
     bit_depth: u32,
 ) {
     unsafe {
-        if std::arch::is_x86_feature_detected!("fma") {
-            convolve_horizontal_plane_avx_u16_row_fma(src, dst, filter_weights, bit_depth);
-        } else {
-            convolve_horizontal_plane_avx_u16_row_def(src, dst, filter_weights, bit_depth);
-        }
+        convolve_horizontal_plane_avx_u16_row_fma_impl(src, dst, filter_weights, bit_depth);
+    }
+}
+
+pub(crate) fn convolve_horizontal_plane_avx_u16_row_default(
+    src: &[u16],
+    dst: &mut [u16],
+    filter_weights: &FilterWeights<f32>,
+    bit_depth: u32,
+) {
+    unsafe {
+        convolve_horizontal_plane_avx_u16_row_def(src, dst, filter_weights, bit_depth);
     }
 }
 
@@ -311,7 +327,7 @@ fn convolve_horizontal_plane_avx_u16_row_def(
 
 #[target_feature(enable = "avx2", enable = "fma")]
 /// This inlining is required to activate all features for runtime dispatch.
-fn convolve_horizontal_plane_avx_u16_row_fma(
+fn convolve_horizontal_plane_avx_u16_row_fma_impl(
     src: &[u16],
     dst: &mut [u16],
     filter_weights: &FilterWeights<f32>,
diff --git a/src/avx2/plane_u16_lb.rs b/src/avx2/plane_u16_lb.rs
@@ -252,7 +252,6 @@ pub(crate) fn convolve_horizontal_plane_avx_u16lp_row(
 ) {
     unsafe {
         #[cfg(feature = "avx512")]
-        #[allow(clippy::incompatible_msrv)]
         if std::arch::is_x86_feature_detected!("avxvnni") {
             return convolve_horizontal_plane_avx_u16_row_vn(src, dst, filter_weights, bit_depth);
         }
diff --git a/src/avx2/rgb_f32.rs b/src/avx2/rgb_f32.rs
@@ -48,12 +48,8 @@ fn ch_parts_4_rgb_f32_sse<const FMA: bool>(
         let rgb_pixel_0 = _mm_loadu_ps(src_ptr.as_ptr());
         let rgb_pixel_1 = _mm_loadu_ps(src_ptr.get_unchecked(3..).as_ptr());
         let rgb_pixel_2 = _mm_loadu_ps(src_ptr.get_unchecked(6..).as_ptr());
-        let rgb_pixel_3 = _mm_setr_ps(
-            *src_ptr.get_unchecked(9),
-            *src_ptr.get_unchecked(10),
-            *src_ptr.get_unchecked(11),
-            0.,
-        );
+        let mut rgb_pixel_3 = _mm_loadu_ps(src_ptr.get_unchecked(8..).as_ptr());
+        rgb_pixel_3 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_3, rgb_pixel_3);
 
         let acc = _mm_prefer_fma_ps::<FMA>(store_0, rgb_pixel_0, weight0);
         let acc = _mm_prefer_fma_ps::<FMA>(acc, rgb_pixel_1, weight1);
@@ -81,22 +77,14 @@ fn ch_parts_4_rgb_f32_avx<const FMA: bool>(
         let rgb_pixel_0_0 = _mm_loadu_ps(src_ptr0.as_ptr());
         let rgb_pixel_0_1 = _mm_loadu_ps(src_ptr0.get_unchecked(3..).as_ptr());
         let rgb_pixel_0_2 = _mm_loadu_ps(src_ptr0.get_unchecked(6..).as_ptr());
-        let rgb_pixel_0_3 = _mm_setr_ps(
-            *src_ptr0.get_unchecked(9),
-            *src_ptr0.get_unchecked(10),
-            *src_ptr0.get_unchecked(11),
-            0.,
-        );
+        let mut rgb_pixel_0_3 = _mm_loadu_ps(src_ptr0.get_unchecked(8..).as_ptr());
+        rgb_pixel_0_3 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_0_3, rgb_pixel_0_3);
 
         let rgb_pixel_1_0 = _mm_loadu_ps(src_ptr1.as_ptr());
         let rgb_pixel_1_1 = _mm_loadu_ps(src_ptr1.get_unchecked(3..).as_ptr());
         let rgb_pixel_1_2 = _mm_loadu_ps(src_ptr1.get_unchecked(6..).as_ptr());
-        let rgb_pixel_1_3 = _mm_setr_ps(
-            *src_ptr1.get_unchecked(9),
-            *src_ptr1.get_unchecked(10),
-            *src_ptr1.get_unchecked(11),
-            0.,
-        );
+        let mut rgb_pixel_1_3 = _mm_loadu_ps(src_ptr1.get_unchecked(8..).as_ptr());
+        rgb_pixel_1_3 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_1_3, rgb_pixel_1_3);
 
         let rgb_pixel_0 =
             _mm256_insertf128_ps::<1>(_mm256_castps128_ps256(rgb_pixel_0_0), rgb_pixel_1_0);
@@ -132,20 +120,12 @@ fn ch_parts_2_rgb_f32_avx<const FMA: bool>(
         let orig1 = _mm_loadu_ps(src_ptr1.as_ptr());
 
         let rgb_pixel_0_0 = orig0;
-        let rgb_pixel_0_1 = _mm_setr_ps(
-            *src_ptr0.get_unchecked(3),
-            *src_ptr0.get_unchecked(4),
-            *src_ptr0.get_unchecked(5),
-            0.,
-        );
+        let mut rgb_pixel_0_1 = _mm_loadu_ps(src_ptr0.get_unchecked(2..).as_ptr());
+        rgb_pixel_0_1 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_0_1, rgb_pixel_0_1);
 
         let rgb_pixel_1_0 = orig1;
-        let rgb_pixel_1_1 = _mm_setr_ps(
-            *src_ptr1.get_unchecked(3),
-            *src_ptr1.get_unchecked(4),
-            *src_ptr1.get_unchecked(5),
-            0.,
-        );
+        let mut rgb_pixel_1_1 = _mm_loadu_ps(src_ptr1.get_unchecked(2..).as_ptr());
+        rgb_pixel_1_1 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_1_1, rgb_pixel_1_1);
 
         let rgb_pixel_0 =
             _mm256_insertf128_ps::<1>(_mm256_castps128_ps256(rgb_pixel_0_0), rgb_pixel_1_0);
@@ -172,12 +152,8 @@ fn ch_parts_2_rgb_f32<const FMA: bool>(
 
         let orig1 = _mm_loadu_ps(src_ptr.as_ptr());
         let rgb_pixel_0 = orig1;
-        let rgb_pixel_1 = _mm_setr_ps(
-            *src_ptr.get_unchecked(3),
-            *src_ptr.get_unchecked(4),
-            *src_ptr.get_unchecked(5),
-            0.,
-        );
+        let mut rgb_pixel_1 = _mm_loadu_ps(src_ptr.get_unchecked(2..).as_ptr());
+        rgb_pixel_1 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_1, rgb_pixel_1);
 
         let mut acc = _mm_prefer_fma_ps::<FMA>(store_0, rgb_pixel_0, weight0);
         acc = _mm_prefer_fma_ps::<FMA>(acc, rgb_pixel_1, weight1);
diff --git a/src/handler_provider.rs b/src/handler_provider.rs
@@ -252,8 +252,17 @@ impl RowHandlerFloatingPoint<u16, f32, f32> for u16 {
                         bit_depth,
                     );
                 } else if CN == 1 {
-                    use crate::avx2::convolve_horizontal_plane_avx_u16_row_f;
-                    return convolve_horizontal_plane_avx_u16_row_f(
+                    if has_fma {
+                        use crate::avx2::convolve_horizontal_plane_avx_u16_row_fma;
+                        return convolve_horizontal_plane_avx_u16_row_fma(
+                            src,
+                            dst,
+                            filter_weights,
+                            bit_depth,
+                        );
+                    }
+                    use crate::avx2::convolve_horizontal_plane_avx_u16_row_default;
+                    return convolve_horizontal_plane_avx_u16_row_default(
                         src,
                         dst,
                         filter_weights,
@@ -350,8 +359,19 @@ impl RowHandlerFloatingPoint<u16, f32, f32> for u16 {
                         bit_depth,
                     );
                 } else if CN == 1 {
-                    use crate::avx2::convolve_horizontal_plane_avx_rows_4_u16_f;
-                    return convolve_horizontal_plane_avx_rows_4_u16_f(
+                    if has_fma {
+                        use crate::avx2::convolve_horizontal_plane_avx_rows_4_u16_fma;
+                        return convolve_horizontal_plane_avx_rows_4_u16_fma(
+                            src,
+                            src_stride,
+                            dst,
+                            dst_stride,
+                            filter_weights,
+                            bit_depth,
+                        );
+                    }
+                    use crate::avx2::convolve_horizontal_plane_avx_rows_4_u16_default;
+                    return convolve_horizontal_plane_avx_rows_4_u16_default(
                         src,
                         src_stride,
                         dst,
diff --git a/src/sse/rgb_f32.rs b/src/sse/rgb_f32.rs
@@ -51,12 +51,8 @@ fn convolve_horizontal_parts_4_rgb_f32<const FMA: bool>(
         let rgb_pixel_0 = _mm_loadu_ps(src_ptr);
         let rgb_pixel_1 = _mm_loadu_ps(src_ptr.add(3));
         let rgb_pixel_2 = _mm_loadu_ps(src_ptr.add(6));
-        let rgb_pixel_3 = _mm_setr_ps(
-            src_ptr.add(9).read_unaligned(),
-            src_ptr.add(10).read_unaligned(),
-            src_ptr.add(11).read_unaligned(),
-            0f32,
-        );
+        let mut rgb_pixel_3 = _mm_loadu_ps(src_ptr.add(8));
+        rgb_pixel_3 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_3, rgb_pixel_3);
 
         let acc = _mm_prefer_fma_ps::<FMA>(store_0, rgb_pixel_0, weight0);
         let acc = _mm_prefer_fma_ps::<FMA>(acc, rgb_pixel_1, weight1);
@@ -79,12 +75,8 @@ fn convolve_horizontal_parts_2_rgb_f32<const FMA: bool>(
 
         let orig1 = _mm_loadu_ps(src_ptr);
         let rgb_pixel_0 = orig1;
-        let rgb_pixel_1 = _mm_setr_ps(
-            src_ptr.add(3).read_unaligned(),
-            src_ptr.add(4).read_unaligned(),
-            src_ptr.add(5).read_unaligned(),
-            0f32,
-        );
+        let mut rgb_pixel_1 = _mm_loadu_ps(src_ptr.add(2));
+        rgb_pixel_1 = _mm_shuffle_ps::<{ shuffle(0, 3, 2, 1) }>(rgb_pixel_1, rgb_pixel_1);
 
         let mut acc = _mm_prefer_fma_ps::<FMA>(store_0, rgb_pixel_0, weight0);
         acc = _mm_prefer_fma_ps::<FMA>(acc, rgb_pixel_1, weight1);

Original file line number	Diff line number	Diff line change
`@@ -252,7 +252,6 @@ pub(crate) fn convolve_horizontal_plane_avx_u16lp_row(`
`252`	`252`	`) {`
`253`	`253`	`unsafe {`
`254`	`254`	`#[cfg(feature = "avx512")]`
`255`		`- #[allow(clippy::incompatible_msrv)]`
`256`	`255`	`if std::arch::is_x86_feature_detected!("avxvnni") {`
`257`	`256`	`return convolve_horizontal_plane_avx_u16_row_vn(src, dst, filter_weights, bit_depth);`
`258`	`257`	`}`