Port shuffle4

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -5,7 +5,6 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp;
@@ -61,6 +60,12 @@ internal static class Numerics
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static nint Modulo4(nint x) => x & 3;
 
+    /// <summary>
+    /// Calculates <paramref name="x"/> % 4
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static nuint Modulo4(nuint x) => x & 3;
+
     /// <summary>
     /// Calculates <paramref name="x"/> % 8
     /// </summary>

src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs

@@ -19,24 +19,26 @@ namespace SixLabors.ImageSharp;
 internal interface IComponentShuffle
 {
     /// <summary>
-    /// Shuffles then slices 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// Shuffles then slices 8-bit integers in <paramref name="source"/>
+    /// using the control and store the results in <paramref name="destination"/>.
+    /// If successful, this method will reduce the length of <paramref name="source"/> length
+    /// by the shuffle amount.
     /// </summary>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
-    void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest);
+    /// <param name="destination">The destination span of bytes.</param>
+    void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination);
 
     /// <summary>
-    /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// Shuffle 8-bit integers in <paramref name="source"/>
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <remarks>
-    /// Implementation can assume that source.Length is less or equal than dest.Length.
+    /// Implementation can assume that source.Length is less or equal than destination.Length.
     /// Loops should iterate using source.Length.
     /// </remarks>
-    void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest);
+    void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination);
 }
 
 /// <inheritdoc/>
@@ -44,24 +46,21 @@ internal interface IShuffle4 : IComponentShuffle
 {
 }
 
-internal readonly struct DefaultShuffle4 : IShuffle4
+internal readonly struct DefaultShuffle4(byte control) : IShuffle4
 {
-    public DefaultShuffle4(byte control)
-        => this.Control = control;
-
-    public byte Control { get; }
+    public byte Control { get; } = control;
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, this.Control);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, this.Control);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
-        ref byte dBase = ref MemoryMarshal.GetReference(dest);
+        ref byte dBase = ref MemoryMarshal.GetReference(destination);
 
-        Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
 
         for (nuint i = 0; i < (uint)source.Length; i += 4)
         {
@@ -76,14 +75,14 @@ internal readonly struct DefaultShuffle4 : IShuffle4
 internal readonly struct WXYZShuffle4 : IShuffle4
 {
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle2103);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle2103);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
         uint n = (uint)source.Length / 4;
 
         for (nuint i = 0; i < n; i++)
@@ -100,14 +99,14 @@ internal readonly struct WXYZShuffle4 : IShuffle4
 internal readonly struct WZYXShuffle4 : IShuffle4
 {
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle0123);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle0123);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
         uint n = (uint)source.Length / 4;
 
         for (nuint i = 0; i < n; i++)
@@ -124,14 +123,14 @@ internal readonly struct WZYXShuffle4 : IShuffle4
 internal readonly struct YZWXShuffle4 : IShuffle4
 {
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle0321);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle0321);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
         uint n = (uint)source.Length / 4;
 
         for (nuint i = 0; i < n; i++)
@@ -148,14 +147,14 @@ internal readonly struct YZWXShuffle4 : IShuffle4
 internal readonly struct ZYXWShuffle4 : IShuffle4
 {
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle3012);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle3012);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
         uint n = (uint)source.Length / 4;
 
         for (nuint i = 0; i < n; i++)
@@ -179,14 +178,14 @@ internal readonly struct ZYXWShuffle4 : IShuffle4
 internal readonly struct XWZYShuffle4 : IShuffle4
 {
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle1230);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle1230);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
         uint n = (uint)source.Length / 4;
 
         for (nuint i = 0; i < n; i++)

src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs

@@ -24,12 +24,12 @@ internal readonly struct DefaultPad3Shuffle4 : IPad3Shuffle4
         => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, this.Control);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
         ref byte dBase = ref MemoryMarshal.GetReference(dest);
 
-        Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
 
         Span<byte> temp = stackalloc byte[4];
         ref byte t = ref MemoryMarshal.GetReference(temp);
@@ -52,10 +52,10 @@ internal readonly struct XYZWPad3Shuffle4 : IPad3Shuffle4
 {
     [MethodImpl(InliningOptions.ShortMethod)]
     public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle3210);
+        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, SimdUtils.Shuffle.MMShuffle3210);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
         ref byte dBase = ref MemoryMarshal.GetReference(dest);

src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs

@@ -24,12 +24,12 @@ internal readonly struct DefaultShuffle3 : IShuffle3
         => HwIntrinsics.Shuffle3Reduce(ref source, ref dest, this.Control);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
         ref byte dBase = ref MemoryMarshal.GetReference(dest);
 
-        Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
 
         for (nuint i = 0; i < (uint)source.Length; i += 3)
         {

src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs

@@ -24,12 +24,12 @@ internal readonly struct DefaultShuffle4Slice3 : IShuffle4Slice3
         => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, this.Control);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
         ref byte dBase = ref MemoryMarshal.GetReference(dest);
 
-        Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
 
         for (nuint i = 0, j = 0; i < (uint)dest.Length; i += 3, j += 4)
         {
@@ -44,10 +44,10 @@ internal readonly struct XYZWShuffle4Slice3 : IShuffle4Slice3
 {
     [MethodImpl(InliningOptions.ShortMethod)]
     public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, Shuffle.MMShuffle3210);
+        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, SimdUtils.Shuffle.MMShuffle3210);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
         ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
         ref Byte3 dBase = ref Unsafe.As<byte, Byte3>(ref MemoryMarshal.GetReference(dest));

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

@@ -51,22 +51,32 @@ internal static partial class SimdUtils
 
         /// <summary>
         /// Shuffle single-precision (32-bit) floating-point elements in <paramref name="source"/>
-        /// using the control and store the results in <paramref name="dest"/>.
+        /// using the control and store the results in <paramref name="destination"/>.
         /// </summary>
         /// <param name="source">The source span of floats.</param>
-        /// <param name="dest">The destination span of floats.</param>
+        /// <param name="destination">The destination span of floats.</param>
         /// <param name="control">The byte control.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Shuffle4Reduce(
             ref ReadOnlySpan<float> source,
-            ref Span<float> dest,
+            ref Span<float> destination,
             [ConstantExpected] byte control)
         {
-            if (Avx.IsSupported || Sse.IsSupported)
+            if (Vector512.IsHardwareAccelerated || Vector256.IsHardwareAccelerated || Vector128.IsHardwareAccelerated)
             {
-                int remainder = Avx.IsSupported
-                    ? Numerics.ModuloP2(source.Length, Vector256<float>.Count)
-                    : Numerics.ModuloP2(source.Length, Vector128<float>.Count);
+                int remainder = 0;
+                if (Vector512.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector512<float>.Count);
+                }
+                else if (Vector256.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector256<float>.Count);
+                }
+                else if (Vector128.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector128<float>.Count);
+                }
 
                 int adjustedCount = source.Length - remainder;
 
@@ -74,17 +84,17 @@ internal static partial class SimdUtils
                 {
                     Shuffle4(
                         source[..adjustedCount],
-                        dest[..adjustedCount],
+                        destination[..adjustedCount],
                         control);
 
                     source = source[adjustedCount..];
-                    dest = dest[adjustedCount..];
+                    destination = destination[adjustedCount..];
                 }
             }
         }
 
         /// <summary>
-        /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
+        /// Shuffle 8-bit integers <paramref name="source"/>
         /// using the control and store the results in <paramref name="dest"/>.
         /// </summary>
         /// <param name="source">The source span of bytes.</param>
@@ -96,11 +106,21 @@ internal static partial class SimdUtils
             ref Span<byte> dest,
             byte control)
         {
-            if (Avx2.IsSupported || Ssse3.IsSupported)
+            if (Vector512.IsHardwareAccelerated || Vector256.IsHardwareAccelerated || Vector128.IsHardwareAccelerated)
             {
-                int remainder = Avx2.IsSupported
-                    ? Numerics.ModuloP2(source.Length, Vector256<byte>.Count)
-                    : Numerics.ModuloP2(source.Length, Vector128<byte>.Count);
+                int remainder = 0;
+                if (Vector512.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector512<byte>.Count);
+                }
+                else if (Vector256.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector256<byte>.Count);
+                }
+                else if (Vector128.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector128<byte>.Count);
+                }
 
                 int adjustedCount = source.Length - remainder;
 
@@ -218,76 +238,102 @@ internal static partial class SimdUtils
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void Shuffle4(
             ReadOnlySpan<float> source,
-            Span<float> dest,
+            Span<float> destination,
             [ConstantExpected] byte control)
         {
-            if (Avx.IsSupported)
+            if (Vector512.IsHardwareAccelerated)
             {
-                ref Vector256<float> sourceBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Span<int> temp = stackalloc int[Vector512<int>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector512<int> mask = Unsafe.As<int, Vector512<int>>(ref MemoryMarshal.GetReference(temp));
 
-                ref Vector256<float> destBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(dest));
+                ref Vector512<float> sourceBase = ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector512<float> destinationBase = ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
 
-                nint n = (nint)dest.Vector256Count<float>();
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
+                nuint n = (uint)destination.Length / (uint)Vector512<float>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                for (nint i = 0; i < u; i += 4)
+                for (nuint i = 0; i < u; i += 4)
                 {
-                    ref Vector256<float> vd0 = ref Unsafe.Add(ref destBase, i);
-                    ref Vector256<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector512<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector512<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Avx.Permute(vs0, control);
-                    Unsafe.Add(ref vd0, 1) = Avx.Permute(Unsafe.Add(ref vs0, 1), control);
-                    Unsafe.Add(ref vd0, 2) = Avx.Permute(Unsafe.Add(ref vs0, 2), control);
-                    Unsafe.Add(ref vd0, 3) = Avx.Permute(Unsafe.Add(ref vs0, 3), control);
+                    vd0 = Vector512.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector512.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector512.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector512.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destBase, i) = Avx.Permute(Unsafe.Add(ref sourceBase, i), control);
+                        Unsafe.Add(ref destinationBase, i) = Vector512.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
-            else
+            else if (Vector256.IsHardwareAccelerated)
             {
-                // Sse
-                ref Vector128<float> sourceBase =
-                    ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(source));
+                Span<int> temp = stackalloc int[Vector256<int>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector256<int> mask = Unsafe.As<int, Vector256<int>>(ref MemoryMarshal.GetReference(temp));
 
-                ref Vector128<float> destBase =
-                    ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(dest));
+                ref Vector256<float> sourceBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector256<float> destinationBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
 
-                nint n = (nint)((uint)dest.Length / (uint)Vector128<float>.Count);
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
+                nuint n = (uint)destination.Length / (uint)Vector256<float>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                for (nint i = 0; i < u; i += 4)
+                for (nuint i = 0; i < u; i += 4)
                 {
-                    ref Vector128<float> vd0 = ref Unsafe.Add(ref destBase, i);
-                    ref Vector128<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector256<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector256<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Sse.Shuffle(vs0, vs0, control);
+                    vd0 = Vector256.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector256.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector256.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector256.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
+                }
 
-                    Vector128<float> vs1 = Unsafe.Add(ref vs0, 1);
-                    Unsafe.Add(ref vd0, 1) = Sse.Shuffle(vs1, vs1, control);
+                if (m > 0)
+                {
+                    for (nuint i = u; i < n; i++)
+                    {
+                        Unsafe.Add(ref destinationBase, i) = Vector256.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
+                    }
+                }
+            }
+            else if (Vector128.IsHardwareAccelerated)
+            {
+                Span<int> temp = stackalloc int[Vector128<int>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector128<int> mask = Unsafe.As<int, Vector128<int>>(ref MemoryMarshal.GetReference(temp));
+
+                ref Vector128<float> sourceBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector128<float> destinationBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(destination));
 
-                    Vector128<float> vs2 = Unsafe.Add(ref vs0, 2);
-                    Unsafe.Add(ref vd0, 2) = Sse.Shuffle(vs2, vs2, control);
+                nuint n = (uint)destination.Length / (uint)Vector128<float>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
+
+                for (nuint i = 0; i < u; i += 4)
+                {
+                    ref Vector128<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector128<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    Vector128<float> vs3 = Unsafe.Add(ref vs0, 3);
-                    Unsafe.Add(ref vd0, 3) = Sse.Shuffle(vs3, vs3, control);
+                    vd0 = Vector128.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector128.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector128.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector128.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Vector128<float> vs = Unsafe.Add(ref sourceBase, i);
-                        Unsafe.Add(ref destBase, i) = Sse.Shuffle(vs, vs, control);
+                        Unsafe.Add(ref destinationBase, i) = Vector128.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
@@ -296,80 +342,102 @@ internal static partial class SimdUtils
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void Shuffle4(
             ReadOnlySpan<byte> source,
-            Span<byte> dest,
+            Span<byte> destination,
             byte control)
         {
-            if (Avx2.IsSupported)
+            if (Vector512.IsHardwareAccelerated)
             {
-                // I've chosen to do this for convenience while we determine what
-                // shuffle controls to add to the library.
-                // We can add static ROS instances if need be in the future.
-                Span<byte> bytes = stackalloc byte[Vector256<byte>.Count];
-                Shuffle.MMShuffleSpan(ref bytes, control);
-                Vector256<byte> vshuffle = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(bytes));
+                Span<byte> temp = stackalloc byte[Vector512<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector512<byte> mask = Unsafe.As<byte, Vector512<byte>>(ref MemoryMarshal.GetReference(temp));
 
-                ref Vector256<byte> sourceBase =
-                    ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector512<byte> sourceBase = ref Unsafe.As<byte, Vector512<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector512<byte> destinationBase = ref Unsafe.As<byte, Vector512<byte>>(ref MemoryMarshal.GetReference(destination));
 
-                ref Vector256<byte> destBase =
-                    ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(dest));
+                nuint n = (uint)destination.Length / (uint)Vector512<byte>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
+
+                for (nuint i = 0; i < u; i += 4)
+                {
+                    ref Vector512<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector512<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
+
+                    vd0 = Vector512.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector512.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector512.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector512.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
+                }
+
+                if (m > 0)
+                {
+                    for (nuint i = u; i < n; i++)
+                    {
+                        Unsafe.Add(ref destinationBase, i) = Vector512.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
+                    }
+                }
+            }
+            else if (Vector256.IsHardwareAccelerated)
+            {
+                Span<byte> temp = stackalloc byte[Vector256<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector256<byte> mask = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(temp));
 
-                nint n = (nint)((uint)dest.Length / (uint)Vector256<byte>.Count);
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
+                ref Vector256<byte> sourceBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector256<byte> destinationBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(destination));
 
-                for (nint i = 0; i < u; i += 4)
+                nuint n = (uint)destination.Length / (uint)Vector256<byte>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
+
+                for (nuint i = 0; i < u; i += 4)
                 {
                     ref Vector256<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
-                    ref Vector256<byte> vd0 = ref Unsafe.Add(ref destBase, i);
+                    ref Vector256<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Avx2.Shuffle(vs0, vshuffle);
-                    Unsafe.Add(ref vd0, 1) = Avx2.Shuffle(Unsafe.Add(ref vs0, 1), vshuffle);
-                    Unsafe.Add(ref vd0, 2) = Avx2.Shuffle(Unsafe.Add(ref vs0, 2), vshuffle);
-                    Unsafe.Add(ref vd0, 3) = Avx2.Shuffle(Unsafe.Add(ref vs0, 3), vshuffle);
+                    vd0 = Vector256.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector256.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector256.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector256.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destBase, i) = Avx2.Shuffle(Unsafe.Add(ref sourceBase, i), vshuffle);
+                        Unsafe.Add(ref destinationBase, i) = Vector256.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
-            else
+            else if (Vector128.IsHardwareAccelerated)
             {
-                // Ssse3
-                Span<byte> bytes = stackalloc byte[Vector128<byte>.Count];
-                Shuffle.MMShuffleSpan(ref bytes, control);
-                Vector128<byte> vshuffle = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(bytes));
-
-                ref Vector128<byte> sourceBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
+                Span<byte> temp = stackalloc byte[Vector128<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector128<byte> mask = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(temp));
 
-                ref Vector128<byte> destBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(dest));
+                ref Vector128<byte> sourceBase = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector128<byte> destinationBase = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));
 
-                nint n = (nint)((uint)dest.Length / (uint)Vector128<byte>.Count);
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
+                nuint n = (uint)destination.Length / (uint)Vector128<byte>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                for (nint i = 0; i < u; i += 4)
+                for (nuint i = 0; i < u; i += 4)
                 {
                     ref Vector128<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
-                    ref Vector128<byte> vd0 = ref Unsafe.Add(ref destBase, i);
+                    ref Vector128<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Ssse3.Shuffle(vs0, vshuffle);
-                    Unsafe.Add(ref vd0, 1) = Ssse3.Shuffle(Unsafe.Add(ref vs0, 1), vshuffle);
-                    Unsafe.Add(ref vd0, 2) = Ssse3.Shuffle(Unsafe.Add(ref vs0, 2), vshuffle);
-                    Unsafe.Add(ref vd0, 3) = Ssse3.Shuffle(Unsafe.Add(ref vs0, 3), vshuffle);
+                    vd0 = Vector128.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector128.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector128.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector128.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destBase, i) = Ssse3.Shuffle(Unsafe.Add(ref sourceBase, i), vshuffle);
+                        Unsafe.Add(ref destinationBase, i) = Vector128.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }

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

@@ -12,140 +12,140 @@ internal static partial class SimdUtils
 {
     /// <summary>
     /// Shuffle single-precision (32-bit) floating-point elements in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <param name="source">The source span of floats.</param>
-    /// <param name="dest">The destination span of floats.</param>
+    /// <param name="destination">The destination span of floats.</param>
     /// <param name="control">The byte control.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle4(
         ReadOnlySpan<float> source,
-        Span<float> dest,
+        Span<float> destination,
         [ConstantExpected] byte control)
     {
-        VerifyShuffle4SpanInput(source, dest);
+        VerifyShuffle4SpanInput(source, destination);
 
-        HwIntrinsics.Shuffle4Reduce(ref source, ref dest, control);
+        HwIntrinsics.Shuffle4Reduce(ref source, ref destination, control);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            Shuffle4Remainder(source, dest, control);
+            Shuffle4Remainder(source, destination, control);
         }
     }
 
     /// <summary>
     /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle4<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IShuffle4
     {
-        VerifyShuffle4SpanInput(source, dest);
+        VerifyShuffle4SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     /// <summary>
     /// Shuffle 8-bit integer triplets within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle3<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IShuffle3
     {
-        // Source length should be smaller than dest length, and divisible by 3.
-        VerifyShuffle3SpanInput(source, dest);
+        // Source length should be smaller than destination length, and divisible by 3.
+        VerifyShuffle3SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     /// <summary>
     /// Pads then shuffles 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Pad3Shuffle4<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IPad3Shuffle4
     {
-        VerifyPad3Shuffle4SpanInput(source, dest);
+        VerifyPad3Shuffle4SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     /// <summary>
     /// Shuffles then slices 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle4Slice3<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IShuffle4Slice3
     {
-        VerifyShuffle4Slice3SpanInput(source, dest);
+        VerifyShuffle4Slice3SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     private static void Shuffle4Remainder(
         ReadOnlySpan<float> source,
-        Span<float> dest,
+        Span<float> destination,
         byte control)
     {
         ref float sBase = ref MemoryMarshal.GetReference(source);
-        ref float dBase = ref MemoryMarshal.GetReference(dest);
+        ref float dBase = ref MemoryMarshal.GetReference(destination);
         Shuffle.InverseMMShuffle(control, out uint p3, out uint p2, out uint p1, out uint p0);
 
         for (nuint i = 0; i < (uint)source.Length; i += 4)
@@ -158,69 +158,69 @@ internal static partial class SimdUtils
     }
 
     [Conditional("DEBUG")]
-    internal static void VerifyShuffle4SpanInput<T>(ReadOnlySpan<T> source, Span<T> dest)
+    internal static void VerifyShuffle4SpanInput<T>(ReadOnlySpan<T> source, Span<T> destination)
         where T : struct
     {
         DebugGuard.IsTrue(
-            source.Length == dest.Length,
+            source.Length == destination.Length,
             nameof(source),
             "Input spans must be of same length!");
 
         DebugGuard.IsTrue(
             source.Length % 4 == 0,
             nameof(source),
-            "Input spans must be divisable by 4!");
+            "Input spans must be divisible by 4!");
     }
 
     [Conditional("DEBUG")]
-    private static void VerifyShuffle3SpanInput<T>(ReadOnlySpan<T> source, Span<T> dest)
+    private static void VerifyShuffle3SpanInput<T>(ReadOnlySpan<T> source, Span<T> destination)
         where T : struct
     {
         DebugGuard.IsTrue(
-            source.Length <= dest.Length,
+            source.Length <= destination.Length,
             nameof(source),
-            "Source should fit into dest!");
+            "Source should fit into destination!");
 
         DebugGuard.IsTrue(
             source.Length % 3 == 0,
             nameof(source),
-            "Input spans must be divisable by 3!");
+            "Input spans must be divisible by 3!");
     }
 
     [Conditional("DEBUG")]
-    private static void VerifyPad3Shuffle4SpanInput(ReadOnlySpan<byte> source, Span<byte> dest)
+    private static void VerifyPad3Shuffle4SpanInput(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         DebugGuard.IsTrue(
             source.Length % 3 == 0,
             nameof(source),
-            "Input span must be divisable by 3!");
+            "Input span must be divisible by 3!");
 
         DebugGuard.IsTrue(
-            dest.Length % 4 == 0,
-            nameof(dest),
-            "Output span must be divisable by 4!");
+            destination.Length % 4 == 0,
+            nameof(destination),
+            "Output span must be divisible by 4!");
 
         DebugGuard.IsTrue(
-            source.Length == dest.Length * 3 / 4,
+            source.Length == destination.Length * 3 / 4,
             nameof(source),
             "Input span must be 3/4 the length of the output span!");
     }
 
     [Conditional("DEBUG")]
-    private static void VerifyShuffle4Slice3SpanInput(ReadOnlySpan<byte> source, Span<byte> dest)
+    private static void VerifyShuffle4Slice3SpanInput(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         DebugGuard.IsTrue(
             source.Length % 4 == 0,
             nameof(source),
-            "Input span must be divisable by 4!");
+            "Input span must be divisible by 4!");
 
         DebugGuard.IsTrue(
-            dest.Length % 3 == 0,
-            nameof(dest),
-            "Output span must be divisable by 3!");
+            destination.Length % 3 == 0,
+            nameof(destination),
+            "Output span must be divisible by 3!");
 
         DebugGuard.IsTrue(
-            dest.Length >= source.Length * 3 / 4,
+            destination.Length >= source.Length * 3 / 4,
             nameof(source),
             "Output span must be at least 3/4 the length of the input span!");
     }
@@ -509,6 +509,27 @@ internal static partial class SimdUtils
             }
         }
 
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static void MMShuffleSpan(ref Span<int> span, byte control)
+        {
+            InverseMMShuffle(
+                 control,
+                 out uint p3,
+                 out uint p2,
+                 out uint p1,
+                 out uint p0);
+
+            ref int spanBase = ref MemoryMarshal.GetReference(span);
+
+            for (nuint i = 0; i < (uint)span.Length; i += 4)
+            {
+                Unsafe.Add(ref spanBase, i + 0) = (int)(p0 + i);
+                Unsafe.Add(ref spanBase, i + 1) = (int)(p1 + i);
+                Unsafe.Add(ref spanBase, i + 2) = (int)(p2 + i);
+                Unsafe.Add(ref spanBase, i + 3) = (int)(p3 + i);
+            }
+        }
+
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void InverseMMShuffle(
             byte control,

src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.Chunks;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;

src/ImageSharp/Formats/Webp/Chunks/WebpAnimationParameter.cs

@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers.Binary;
-using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp.Formats.Webp.Chunks;
 

src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Common.Helpers;
-
 namespace SixLabors.ImageSharp.Formats.Webp.Chunks;
 
 internal readonly struct WebpFrameData

src/ImageSharp/Formats/Webp/Chunks/WebpVp8X.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Common.Helpers;
-
 namespace SixLabors.ImageSharp.Formats.Webp.Chunks;
 
 internal readonly struct WebpVp8X

src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs

@@ -6,7 +6,6 @@ using System.Buffers;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.BitWriter;
 using SixLabors.ImageSharp.Formats.Webp.Chunks;
 using SixLabors.ImageSharp.Memory;

src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs

@@ -4,7 +4,6 @@
 
 using System.Buffers;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.BitWriter;
 using SixLabors.ImageSharp.Formats.Webp.Chunks;
 using SixLabors.ImageSharp.Memory;

src/ImageSharp/Common/Helpers/RiffHelper.cs → src/ImageSharp/Formats/Webp/RiffHelper.cs

@@ -4,7 +4,7 @@
 using System.Buffers.Binary;
 using System.Text;
 
-namespace SixLabors.ImageSharp.Common.Helpers;
+namespace SixLabors.ImageSharp.Formats.Webp;
 
 internal static class RiffHelper
 {

src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs

@@ -28,7 +28,7 @@ internal static partial class Vector4Converters
         private static readonly int Vector4ConversionThreshold = CalculateVector4ConversionThreshold();
 
         /// <summary>
-        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.ToVector4(SixLabors.ImageSharp.Configuration,System.ReadOnlySpan{TPixel},System.Span{System.Numerics.Vector4},SixLabors.ImageSharp.PixelFormats.PixelConversionModifiers)"/>
+        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.ToVector4(Configuration,ReadOnlySpan{TPixel},Span{Vector4},PixelConversionModifiers)"/>
         /// The method works by internally converting to a <see cref="Rgba32"/> therefore it's not applicable for that type!
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
@@ -72,7 +72,7 @@ internal static partial class Vector4Converters
         }
 
         /// <summary>
-        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.FromVector4Destructive(SixLabors.ImageSharp.Configuration,System.Span{System.Numerics.Vector4},System.Span{TPixel},SixLabors.ImageSharp.PixelFormats.PixelConversionModifiers)"/>
+        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.FromVector4Destructive(Configuration,Span{Vector4},Span{TPixel},PixelConversionModifiers)"/>
         /// The method is works by internally converting to a <see cref="Rgba32"/> therefore it's not applicable for that type!
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
@@ -102,16 +102,14 @@ internal static partial class Vector4Converters
 
             // For the opposite direction it's not easy to implement the trick used in RunRgba32CompatibleToVector4Conversion,
             // so let's allocate a temporary buffer as usually:
-            using (IMemoryOwner<Rgba32> tempBuffer = configuration.MemoryAllocator.Allocate<Rgba32>(count))
-            {
-                Span<Rgba32> tempSpan = tempBuffer.Memory.Span;
+            using IMemoryOwner<Rgba32> tempBuffer = configuration.MemoryAllocator.Allocate<Rgba32>(count);
+            Span<Rgba32> tempSpan = tempBuffer.Memory.Span;
 
-                SimdUtils.NormalizedFloatToByteSaturate(
-                    MemoryMarshal.Cast<Vector4, float>(sourceVectors),
-                    MemoryMarshal.Cast<Rgba32, byte>(tempSpan));
+            SimdUtils.NormalizedFloatToByteSaturate(
+                MemoryMarshal.Cast<Vector4, float>(sourceVectors),
+                MemoryMarshal.Cast<Rgba32, byte>(tempSpan));
 
-                pixelOperations.FromRgba32(configuration, tempSpan, destPixels);
-            }
+            pixelOperations.FromRgba32(configuration, tempSpan, destPixels);
         }
 
         private static int CalculateVector4ConversionThreshold()