Optimize and cleanup ByteToNormalizedFloatReduce

Author: JimBobSquarePants

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -1069,4 +1069,24 @@ public static nuint Vector256Count<TVector>(this Span<float> span)
     public static nuint Vector256Count<TVector>(int length)
         where TVector : struct
         => (uint)length / (uint)Vector256<TVector>.Count;
+
+    /// <summary>
+    /// Gets the count of vectors that safely fit into the given span.
+    /// </summary>
+    /// <typeparam name="TVector">The type of the vector.</typeparam>
+    /// <param name="span">The given span.</param>
+    /// <returns>Count of vectors that safely fit into the span.</returns>
+    public static nuint Vector512Count<TVector>(this Span<float> span)
+        where TVector : struct
+        => (uint)span.Length / (uint)Vector512<TVector>.Count;
+
+    /// <summary>
+    /// Gets the count of vectors that safely fit into length.
+    /// </summary>
+    /// <typeparam name="TVector">The type of the vector.</typeparam>
+    /// <param name="length">The given length.</param>
+    /// <returns>Count of vectors that safely fit into the length.</returns>
+    public static nuint Vector512Count<TVector>(int length)
+        where TVector : struct
+        => (uint)length / (uint)Vector512<TVector>.Count;
 }

src/ImageSharp/Common/Helpers/SimdUtils.Convert.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp;
+
+internal static partial class SimdUtils
+{
+    /// <summary>
+    /// Converts all input <see cref="byte"/>-s to <see cref="float"/>-s normalized into [0..1].
+    /// <paramref name="source"/> should be the of the same size as <paramref name="destination"/>,
+    /// but there are no restrictions on the span's length.
+    /// </summary>
+    /// <param name="source">The source span of bytes</param>
+    /// <param name="destination">The destination span of floats</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> destination)
+    {
+        DebugGuard.IsTrue(source.Length == destination.Length, nameof(source), "Input spans must be of same length!");
+
+        HwIntrinsics.ByteToNormalizedFloatReduce(ref source, ref destination);
+
+        if (source.Length > 0)
+        {
+            ConvertByteToNormalizedFloatRemainder(source, destination);
+        }
+    }
+
+    /// <summary>
+    /// Convert all <see cref="float"/> values normalized into [0..1] from 'source' into 'destination' buffer of <see cref="byte"/>.
+    /// The values are scaled up into [0-255] and rounded, overflows are clamped.
+    /// <paramref name="source"/> should be the of the same size as <paramref name="destination"/>,
+    /// but there are no restrictions on the span's length.
+    /// </summary>
+    /// <param name="source">The source span of floats</param>
+    /// <param name="destination">The destination span of bytes</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    internal static void NormalizedFloatToByteSaturate(ReadOnlySpan<float> source, Span<byte> destination)
+    {
+        DebugGuard.IsTrue(source.Length == destination.Length, nameof(source), "Input spans must be of same length!");
+
+        HwIntrinsics.NormalizedFloatToByteSaturateReduce(ref source, ref destination);
+
+        if (source.Length > 0)
+        {
+            ConvertNormalizedFloatToByteRemainder(source, destination);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void ConvertByteToNormalizedFloatRemainder(ReadOnlySpan<byte> source, Span<float> destination)
+    {
+        ref byte sBase = ref MemoryMarshal.GetReference(source);
+        ref float dBase = ref MemoryMarshal.GetReference(destination);
+
+        for (int i = 0; i < source.Length; i++)
+        {
+            Unsafe.Add(ref dBase, i) = Unsafe.Add(ref sBase, i) / 255f;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void ConvertNormalizedFloatToByteRemainder(ReadOnlySpan<float> source, Span<byte> destination)
+    {
+        ref float sBase = ref MemoryMarshal.GetReference(source);
+        ref byte dBase = ref MemoryMarshal.GetReference(destination);
+        for (int i = 0; i < source.Length; i++)
+        {
+            Unsafe.Add(ref dBase, i) = ConvertToByte(Unsafe.Add(ref sBase, i));
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static byte ConvertToByte(float f) => (byte)Numerics.Clamp((f * 255F) + 0.5F, 0, 255F);
+}