Refactor, Added SSE for RGBA -> XYZa

.github/workflows/build_push.yml

@@ -23,8 +23,9 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
-      - run: rustup target add aarch64-unknown-linux-gnu x86_64-unknown-linux-gnu
+      - run: rustup target add aarch64-unknown-linux-gnu x86_64-unknown-linux-gnu i686-unknown-linux-gnu
       - run: cargo build --target aarch64-unknown-linux-gnu
       - run: cargo build --target x86_64-unknown-linux-gnu
+      - run: cargo build --target i686-unknown-linux-gnu
       - name: Test release pipeline
         run: cargo publish --dry-run

src/avx2_to_xyz_lab.rs

@@ -13,9 +13,6 @@ use crate::image_to_xyz_lab::XyzTarget;
 #[allow(unused_imports)]
 use crate::neon_gamma_curves::*;
 #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-#[allow(unused_imports)]
-use crate::sse_gamma_curves::{sse_rec709_to_linear, sse_srgb_to_linear};
-#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
 use crate::x86_64_simd_support::*;
 #[cfg(target_arch = "x86")]
 use std::arch::x86::*;

src/avx_math.rs

@@ -19,7 +19,6 @@ pub unsafe fn _mm256_prefer_fma_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
     return _mm256_fmadd_ps(b, c, a);
 }
 
-
 #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
 #[inline(always)]
 #[allow(dead_code)]

src/concat_alpha.rs

@@ -1,7 +1,5 @@
 #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
 use crate::x86_64_simd_support::{avx2_deinterleave_rgb_ps, avx2_interleave_rgba_ps};
-#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::x86_64_simd_support::{sse_deinterleave_rgb_ps, sse_interleave_ps_rgba};
 #[cfg(all(
     any(target_arch = "aarch64", target_arch = "arm"),
     target_feature = "neon"
@@ -13,6 +11,8 @@ use std::arch::x86::*;
 use std::arch::x86_64::*;
 #[allow(unused_imports)]
 use std::slice;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::*;
 
 /// Adds alpha plane into an existing RGB/XYZ/LAB or other 3 plane image. Image will become RGBA, XYZa, LABa etc.
 pub fn append_alpha(

src/image_to_linear.rs

@@ -7,8 +7,8 @@ use crate::image::ImageConfiguration;
     target_feature = "neon"
 ))]
 use crate::neon_to_linear::neon_channels_to_linear;
-#[cfg(target_arch = "x86_64")]
-use crate::sse_to_linear::sse_channels_to_linear;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::*;
 use crate::Rgb;
 
 #[inline(always)]
@@ -35,18 +35,21 @@ fn channels_to_linear<const CHANNELS_CONFIGURATION: u8, const USE_ALPHA: bool>(
 
     let channels = image_configuration.get_channels_count();
 
-    #[cfg(target_arch = "x86_64")]
+    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
     let mut _has_sse = false;
 
-    #[cfg(all(target_arch = "x86_64", target_feature = "sse4.1"))]
+    #[cfg(all(
+        any(target_arch = "x86_64", target_arch = "x86"),
+        target_feature = "sse4.1"
+    ))]
     if is_x86_feature_detected!("sse4.1") {
         _has_sse = true;
     }
 
     for _ in 0..height as usize {
         let mut cx = 0usize;
 
-        #[cfg(target_arch = "x86_64")]
+        #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
         unsafe {
             if _has_sse {
                 cx = sse_channels_to_linear::<CHANNELS_CONFIGURATION, USE_ALPHA>(

src/image_to_linear_u8.rs

@@ -13,10 +13,10 @@ use crate::neon_to_linear::get_neon_linear_transfer;
 ))]
 use crate::neon_to_linear_u8::neon_image_linear_to_u8;
 #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::sse_image_to_linear_u8::sse_image_to_linear_unsigned;
-#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::sse_to_linear::get_sse_linear_transfer;
+use crate::sse::get_sse_linear_transfer;
 use crate::Rgb;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::sse_image_to_linear_unsigned::sse_channels_to_linear_u8;
 
 #[inline]
 fn channels_to_linear<const CHANNELS_CONFIGURATION: u8, const USE_ALPHA: bool>(
@@ -60,7 +60,7 @@ fn channels_to_linear<const CHANNELS_CONFIGURATION: u8, const USE_ALPHA: bool>(
         unsafe {
             if _has_sse {
                 let transfer = get_sse_linear_transfer(transfer_function);
-                cx = sse_image_to_linear_unsigned::sse_channels_to_linear::<
+                cx = sse_channels_to_linear_u8::<
                     CHANNELS_CONFIGURATION,
                     USE_ALPHA,
                 >(

src/image_to_xyz_lab.rs

@@ -9,10 +9,10 @@ use crate::image_to_xyz_lab::XyzTarget::{LAB, LUV, XYZ};
     target_feature = "neon"
 ))]
 use crate::neon_to_xyz_lab::neon_channels_to_xyz_or_lab;
-#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::sse_to_xyz_lab::sse_channels_to_xyz_or_lab;
 use crate::{Rgb, Xyz, SRGB_TO_XYZ_D65};
 use std::slice;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::sse_channels_to_xyz_or_lab;
 
 pub(crate) enum XyzTarget {
     LAB = 0,

src/image_xyza_laba.rs

@@ -1,13 +1,15 @@
 use crate::image::ImageConfiguration;
 use crate::image_to_xyz_lab::XyzTarget;
 use crate::image_to_xyz_lab::XyzTarget::{LAB, LUV, XYZ};
-use crate::{Rgb, TransferFunction, Xyz, SRGB_TO_XYZ_D65};
-use std::slice;
 #[cfg(all(
     any(target_arch = "aarch64", target_arch = "arm"),
     target_feature = "neon"
 ))]
 use crate::neon_to_xyza_laba::neon_channels_to_xyza_or_laba;
+use crate::{Rgb, TransferFunction, Xyz, SRGB_TO_XYZ_D65};
+use std::slice;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::sse_channels_to_xyza_laba;
 
 #[inline(always)]
 fn channels_to_xyz_with_alpha<const CHANNELS_CONFIGURATION: u8, const TARGET: u8>(
@@ -29,6 +31,17 @@ fn channels_to_xyz_with_alpha<const CHANNELS_CONFIGURATION: u8, const TARGET: u8
     let mut src_offset = 0usize;
     let mut dst_offset = 0usize;
 
+    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+    let mut _has_sse = false;
+
+    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+    {
+        #[cfg(target_feature = "sse4.1")]
+        if is_x86_feature_detected!("sse4.1") {
+            _has_sse = true;
+        }
+    }
+
     const CHANNELS: usize = 4;
 
     let channels = image_configuration.get_channels_count();
@@ -37,6 +50,22 @@ fn channels_to_xyz_with_alpha<const CHANNELS_CONFIGURATION: u8, const TARGET: u8
         #[allow(unused_mut)]
         let mut cx = 0usize;
 
+        #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+        unsafe {
+            if _has_sse {
+                cx = sse_channels_to_xyza_laba::<CHANNELS_CONFIGURATION, TARGET>(
+                    cx,
+                    src.as_ptr(),
+                    src_offset,
+                    width,
+                    dst.as_mut_ptr(),
+                    dst_offset,
+                    &matrix,
+                    transfer_function,
+                );
+            }
+        }
+
         #[cfg(all(
             any(target_arch = "aarch64", target_arch = "arm"),
             target_feature = "neon"
@@ -134,10 +163,7 @@ pub fn rgba_to_lab_with_alpha(
     width: u32,
     height: u32,
 ) {
-    channels_to_xyz_with_alpha::<
-        { ImageConfiguration::Rgba as u8 },
-        { LAB as u8 },
-    >(
+    channels_to_xyz_with_alpha::<{ ImageConfiguration::Rgba as u8 }, { LAB as u8 }>(
         src,
         src_stride,
         dst,
@@ -168,10 +194,7 @@ pub fn bgra_to_lab_with_alpha(
     width: u32,
     height: u32,
 ) {
-    channels_to_xyz_with_alpha::<
-        { ImageConfiguration::Bgra as u8 },
-        { LAB as u8 },
-    >(
+    channels_to_xyz_with_alpha::<{ ImageConfiguration::Bgra as u8 }, { LAB as u8 }>(
         src,
         src_stride,
         dst,
@@ -183,7 +206,6 @@ pub fn bgra_to_lab_with_alpha(
     );
 }
 
-
 /// This function converts RGBA to CIE L*uv against D65 white point and preserving and normalizing alpha channels keeping it at last positions. This is much more effective than naive direct transformation
 ///
 /// # Arguments
@@ -203,10 +225,7 @@ pub fn rgba_to_luv_with_alpha(
     width: u32,
     height: u32,
 ) {
-    channels_to_xyz_with_alpha::<
-        { ImageConfiguration::Rgba as u8 },
-        { LUV as u8 },
-    >(
+    channels_to_xyz_with_alpha::<{ ImageConfiguration::Rgba as u8 }, { LUV as u8 }>(
         src,
         src_stride,
         dst,
@@ -237,10 +256,7 @@ pub fn bgra_to_luv_with_alpha(
     width: u32,
     height: u32,
 ) {
-    channels_to_xyz_with_alpha::<
-        { ImageConfiguration::Bgra as u8 },
-        { LUV as u8 },
-    >(
+    channels_to_xyz_with_alpha::<{ ImageConfiguration::Bgra as u8 }, { LUV as u8 }>(
         src,
         src_stride,
         dst,

src/lib.rs

@@ -9,20 +9,14 @@ mod rgba;
 mod neon_math;
 mod neon_gamma_curves;
 mod xyz_transform;
-mod image_to_xyz_lab;
 mod image;
 mod neon_to_xyz_lab;
 mod xyz_lab_to_image;
-mod sse_math;
-mod sse_gamma_curves;
-mod sse_to_xyz_lab;
 mod x86_64_simd_support;
 mod neon_to_linear;
-mod sse_to_linear;
 mod image_to_linear;
 mod linear_to_image;
 mod neon_linear_to_image;
-mod sse_linear_to_image;
 mod neon_xyz_lab_to_image;
 mod concat_alpha;
 mod avx_math;
@@ -36,8 +30,9 @@ mod xyza_laba_to_image;
 mod neon_xyza_laba_to_image;
 mod image_to_linear_u8;
 mod neon_to_linear_u8;
-mod sse_image_to_linear_u8;
 mod linear_to_image_u8;
+mod sse;
+mod image_to_xyz_lab;
 
 pub use gamma_curves::*;
 pub use hsl::Hsl;

src/linear_to_image.rs

@@ -7,9 +7,9 @@ use crate::image::ImageConfiguration;
     target_feature = "neon"
 ))]
 use crate::neon_linear_to_image::neon_linear_to_gamma;
-#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::sse_linear_to_image::sse_linear_to_gamma;
 use crate::Rgb;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::sse_linear_to_gamma;
 
 #[inline(always)]
 fn linear_to_gamma_channels<const CHANNELS_CONFIGURATION: u8, const USE_ALPHA: bool>(

src/linear_to_image_u8.rs

@@ -13,10 +13,10 @@ use crate::neon_linear_to_image::get_neon_gamma_transfer;
 ))]
 use crate::neon_to_linear_u8::neon_image_linear_to_u8;
 #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::sse_image_to_linear_u8::sse_image_to_linear_unsigned;
-#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::sse_linear_to_image::get_sse_gamma_transfer;
+use crate::sse::get_sse_gamma_transfer;
 use crate::Rgb;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::sse_image_to_linear_unsigned::sse_channels_to_linear_u8;
 
 #[inline]
 fn linear_to_gamma_channels<const CHANNELS_CONFIGURATION: u8, const USE_ALPHA: bool>(
@@ -60,7 +60,7 @@ fn linear_to_gamma_channels<const CHANNELS_CONFIGURATION: u8, const USE_ALPHA: b
         unsafe {
             if _has_sse {
                 let transfer = get_sse_gamma_transfer(transfer_function);
-                cx = sse_image_to_linear_unsigned::sse_channels_to_linear::<
+                cx = sse_channels_to_linear_u8::<
                     CHANNELS_CONFIGURATION,
                     USE_ALPHA,
                 >(

src/rgb_expand.rs

@@ -9,6 +9,8 @@ use std::arch::aarch64::*;
 use std::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+use crate::sse::*;
 
 /// Expands RGB to RGBA.
 pub fn rgb_to_rgba(

src/sse/mod.rs

@@ -0,0 +1,18 @@
+mod sse_image_to_linear_u8;
+mod sse_linear_to_image;
+mod sse_math;
+mod sse_to_linear;
+mod sse_to_xyz_lab;
+mod sse_gamma_curves;
+mod sse_support;
+mod sse_from_xyz_lab;
+mod sse_to_xyza_laba;
+
+pub use sse_image_to_linear_u8::*;
+pub use sse_linear_to_image::*;
+pub use sse_math::*;
+pub use sse_to_xyz_lab::*;
+pub use sse_gamma_curves::*;
+pub use sse_support::*;
+pub use sse_to_linear::*;
+pub use sse_to_xyza_laba::*;

src/sse_gamma_curves.rs → src/sse/sse_gamma_curves.rs

@@ -1,7 +1,7 @@
 #[allow(unused_imports)]
 use crate::gamma_curves::TransferFunction;
 #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-use crate::sse_math::*;
+use crate::sse::*;
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 #[cfg(target_arch = "x86")]
@@ -86,3 +86,13 @@ pub unsafe fn sse_rec709_to_linear(linear: __m128) -> __m128 {
     low = _mm_mul_ps(low, _mm_set1_ps(1f32 / 4.5f32));
     return _mm_select_ps(mask, high, low);
 }
+
+#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+pub unsafe fn get_sse_linear_transfer(
+    transfer_function: TransferFunction,
+) -> unsafe fn(__m128) -> __m128 {
+    match transfer_function {
+        TransferFunction::Srgb => sse_srgb_to_linear,
+        TransferFunction::Rec709 => sse_rec709_to_linear,
+    }
+}

src/sse_image_to_linear_u8.rs → src/sse/sse_image_to_linear_u8.rs

@@ -8,17 +8,12 @@ pub mod sse_image_to_linear_unsigned {
     use crate::image_to_xyz_lab::XyzTarget;
     #[allow(unused_imports)]
     use crate::neon_gamma_curves::*;
-    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-    #[allow(unused_imports)]
-    use crate::sse_gamma_curves::{sse_rec709_to_linear, sse_srgb_to_linear};
-    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-    use crate::x86_64_simd_support::*;
+    use crate::sse::*;
     #[cfg(target_arch = "x86")]
     use std::arch::x86::*;
     #[cfg(target_arch = "x86_64")]
     use std::arch::x86_64::*;
 
-    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
     #[inline(always)]
     unsafe fn sse_triple_to_linear_u8(
         r: __m128i,
@@ -41,9 +36,8 @@ pub mod sse_image_to_linear_unsigned {
         )
     }
 
-    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
     #[inline(always)]
-    pub(crate) unsafe fn sse_channels_to_linear<
+    pub(crate) unsafe fn sse_channels_to_linear_u8<
         const CHANNELS_CONFIGURATION: u8,
         const USE_ALPHA: bool,
     >(

src/sse_linear_to_image.rs → src/sse/sse_linear_to_image.rs

@@ -1,7 +1,7 @@
 #[allow(unused_imports)]
 use crate::image::ImageConfiguration;
 #[allow(unused_imports)]
-use crate::sse_gamma_curves::*;
+use crate::sse::*;
 #[allow(unused_imports)]
 use crate::x86_64_simd_support::*;
 #[allow(unused_imports)]