Address feedback

Author: JimBobSquarePants

src/ImageSharp/Common/Helpers/SimdUtils.cs

@@ -5,6 +5,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp;
@@ -40,13 +41,28 @@ internal static Vector4 PseudoRound(this Vector4 v)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static Vector<float> FastRound(this Vector<float> v)
     {
+        // .NET9+ has a built-in method for this Vector.Round
         if (Avx2.IsSupported && Vector<float>.Count == Vector256<float>.Count)
         {
             ref Vector256<float> v256 = ref Unsafe.As<Vector<float>, Vector256<float>>(ref v);
             Vector256<float> vRound = Avx.RoundToNearestInteger(v256);
             return Unsafe.As<Vector256<float>, Vector<float>>(ref vRound);
         }
 
+        if (Sse41.IsSupported && Vector<float>.Count == Vector128<float>.Count)
+        {
+            ref Vector128<float> v128 = ref Unsafe.As<Vector<float>, Vector128<float>>(ref v);
+            Vector128<float> vRound = Sse41.RoundToNearestInteger(v128);
+            return Unsafe.As<Vector128<float>, Vector<float>>(ref vRound);
+        }
+
+        if (AdvSimd.IsSupported && Vector<float>.Count == Vector128<float>.Count)
+        {
+            ref Vector128<float> v128 = ref Unsafe.As<Vector<float>, Vector128<float>>(ref v);
+            Vector128<float> vRound = AdvSimd.RoundToNearest(v128);
+            return Unsafe.As<Vector128<float>, Vector<float>>(ref vRound);
+        }
+
         // https://github.com/g-truc/glm/blob/master/glm/simd/common.h#L11
         Vector<float> sign = v & new Vector<float>(-0F);
         Vector<float> val_2p23_f32 = sign | new Vector<float>(8388608F);

src/ImageSharp/Common/Helpers/Vector128Utilities.cs

@@ -244,6 +244,11 @@ public static Vector128<float> MultiplyAdd(
             return Fma.MultiplyAdd(vm1, vm0, va);
         }
 
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.FusedMultiplyAdd(va, vm0, vm1);
+        }
+
         return va + (vm0 * vm1);
     }
 

src/ImageSharp/Common/Helpers/Vector256Utilities.cs

@@ -149,11 +149,6 @@ public static Vector256<float> MultiplyAdd(
             return Fma.MultiplyAdd(vm0, vm1, va);
         }
 
-        if (Avx.IsSupported)
-        {
-            return Avx.Add(Avx.Multiply(vm0, vm1), va);
-        }
-
         return va + (vm0 * vm1);
     }
 

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector128.cs

@@ -78,10 +78,12 @@ public static void ConvertFromRgb(in ComponentValues values, float maxValue, Spa
                 Vector128<float> ytmp = scale - Unsafe.Add(ref srcB, i);
                 Vector128<float> ktmp = Vector128.Min(ctmp, Vector128.Min(mtmp, ytmp));
 
-                Vector128<float> kMask = Vector128.Equals(ktmp, scale);
-                ctmp = Vector128.AndNot((ctmp - ktmp) / (scale - ktmp), kMask);
-                mtmp = Vector128.AndNot((mtmp - ktmp) / (scale - ktmp), kMask);
-                ytmp = Vector128.AndNot((ytmp - ktmp) / (scale - ktmp), kMask);
+                Vector128<float> kMask = ~Vector128.Equals(ktmp, scale);
+                Vector128<float> divisor = scale - ktmp;
+
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
 
                 Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
                 Unsafe.Add(ref destM, i) = scale - (mtmp * scale);

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector256.cs

@@ -78,10 +78,12 @@ public static void ConvertFromRgb(in ComponentValues values, float maxValue, Spa
                 Vector256<float> ytmp = scale - Unsafe.Add(ref srcB, i);
                 Vector256<float> ktmp = Vector256.Min(ctmp, Vector256.Min(mtmp, ytmp));
 
-                Vector256<float> kMask = Vector256.Equals(ktmp, scale);
-                ctmp = Vector256.AndNot((ctmp - ktmp) / (scale - ktmp), kMask);
-                mtmp = Vector256.AndNot((mtmp - ktmp) / (scale - ktmp), kMask);
-                ytmp = Vector256.AndNot((ytmp - ktmp) / (scale - ktmp), kMask);
+                Vector256<float> kMask = ~Vector256.Equals(ktmp, scale);
+                Vector256<float> divisor = scale - ktmp;
+
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
 
                 Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
                 Unsafe.Add(ref destM, i) = scale - (mtmp * scale);

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector512.cs

@@ -86,10 +86,12 @@ internal static void ConvertFromRgbVectorized(in ComponentValues values, float m
                 Vector512<float> ytmp = scale - Unsafe.Add(ref srcB, i);
                 Vector512<float> ktmp = Vector512.Min(ctmp, Vector512.Min(mtmp, ytmp));
 
-                Vector512<float> kMask = Vector512.Equals(ktmp, scale);
-                ctmp = Vector512.AndNot((ctmp - ktmp) / (scale - ktmp), kMask);
-                mtmp = Vector512.AndNot((mtmp - ktmp) / (scale - ktmp), kMask);
-                ytmp = Vector512.AndNot((ytmp - ktmp) / (scale - ktmp), kMask);
+                Vector512<float> kMask = ~Vector512.Equals(ktmp, scale);
+                Vector512<float> divisor = scale - ktmp;
+
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
 
                 Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
                 Unsafe.Add(ref destM, i) = scale - (mtmp * scale);

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector128.cs

@@ -25,7 +25,7 @@ protected JpegColorConverterVector128(JpegColorSpace colorSpace, int precision)
         {
         }
 
-        public static bool IsSupported => Vector128.IsHardwareAccelerated && Vector128<float>.IsSupported;
+        public static bool IsSupported => Vector128.IsHardwareAccelerated;
 
         public sealed override bool IsAvailable => IsSupported;
 

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector256.cs

@@ -25,7 +25,7 @@ protected JpegColorConverterVector256(JpegColorSpace colorSpace, int precision)
         {
         }
 
-        public static bool IsSupported => Vector256.IsHardwareAccelerated && Vector256<float>.IsSupported;
+        public static bool IsSupported => Vector256.IsHardwareAccelerated;
 
         public sealed override bool IsAvailable => IsSupported;
 

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector512.cs

@@ -19,7 +19,7 @@ protected JpegColorConverterVector512(JpegColorSpace colorSpace, int precision)
         {
         }
 
-        public static bool IsSupported => Vector512.IsHardwareAccelerated && Vector512<float>.IsSupported;
+        public static bool IsSupported => Vector512.IsHardwareAccelerated;
 
         /// <inheritdoc/>
         public override bool IsAvailable => IsSupported;