diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs b/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs
index 45d6e6d13d..b932028149 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs
@@ -5,6 +5,7 @@ using System.Buffers.Binary;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using static SixLabors.ImageSharp.SimdUtils;
 
 // The JIT can detect and optimize rotation idioms ROTL (Rotate Left)
 // and ROTR (Rotate Right) emitting efficient CPU instructions:
@@ -18,9 +19,12 @@ namespace SixLabors.ImageSharp;
 internal interface IComponentShuffle
 {
     /// <summary>
-    /// Gets the shuffle control.
+    /// 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"/>.
     /// </summary>
-    byte Control { get; }
+    /// <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);
 
     /// <summary>
     /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
@@ -58,11 +62,15 @@ internal readonly struct DefaultShuffle4 : IShuffle4
         this.p2 = p2;
         this.p1 = p1;
         this.p0 = p0;
-        this.Control = SimdUtils.Shuffle.MmShuffle(p3, p2, p1, p0);
+        this.Control = Shuffle.MmShuffle(p3, p2, p1, p0);
     }
 
     public byte Control { get; }
 
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, this.Control);
+
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
@@ -86,11 +94,9 @@ internal readonly struct DefaultShuffle4 : IShuffle4
 
 internal readonly struct WXYZShuffle4 : IShuffle4
 {
-    public byte Control
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        get => SimdUtils.Shuffle.MmShuffle(2, 1, 0, 3);
-    }
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle2103);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
@@ -112,11 +118,9 @@ internal readonly struct WXYZShuffle4 : IShuffle4
 
 internal readonly struct WZYXShuffle4 : IShuffle4
 {
-    public byte Control
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        get => SimdUtils.Shuffle.MmShuffle(0, 1, 2, 3);
-    }
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle0123);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
@@ -138,11 +142,9 @@ internal readonly struct WZYXShuffle4 : IShuffle4
 
 internal readonly struct YZWXShuffle4 : IShuffle4
 {
-    public byte Control
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        get => SimdUtils.Shuffle.MmShuffle(0, 3, 2, 1);
-    }
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle0321);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
@@ -164,11 +166,9 @@ internal readonly struct YZWXShuffle4 : IShuffle4
 
 internal readonly struct ZYXWShuffle4 : IShuffle4
 {
-    public byte Control
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        get => SimdUtils.Shuffle.MmShuffle(3, 0, 1, 2);
-    }
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle3012);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
@@ -197,11 +197,9 @@ internal readonly struct ZYXWShuffle4 : IShuffle4
 
 internal readonly struct XWZYShuffle4 : IShuffle4
 {
-    public byte Control
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        get => SimdUtils.Shuffle.MmShuffle(1, 2, 3, 0);
-    }
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle1230);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs b/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs
index 76cffd82bf..7f99b3a084 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs
@@ -3,6 +3,7 @@
 
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using static SixLabors.ImageSharp.SimdUtils;
 
 namespace SixLabors.ImageSharp;
 
@@ -29,11 +30,15 @@ internal readonly struct DefaultPad3Shuffle4 : IPad3Shuffle4
         this.p2 = p2;
         this.p1 = p1;
         this.p0 = p0;
-        this.Control = SimdUtils.Shuffle.MmShuffle(p3, p2, p1, p0);
+        this.Control = Shuffle.MmShuffle(p3, p2, p1, p0);
     }
 
     public byte Control { get; }
 
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, this.Control);
+
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
@@ -51,7 +56,7 @@ internal readonly struct DefaultPad3Shuffle4 : IPad3Shuffle4
 
         for (int i = 0, j = 0; i < source.Length; i += 3, j += 4)
         {
-            ref var s = ref Unsafe.Add(ref sBase, i);
+            ref byte s = ref Unsafe.Add(ref sBase, i);
             tu = Unsafe.As<byte, uint>(ref s) | 0xFF000000;
 
             Unsafe.Add(ref dBase, j) = Unsafe.Add(ref t, p0);
@@ -64,11 +69,9 @@ internal readonly struct DefaultPad3Shuffle4 : IPad3Shuffle4
 
 internal readonly struct XYZWPad3Shuffle4 : IPad3Shuffle4
 {
-    public byte Control
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        get => SimdUtils.Shuffle.MmShuffle(3, 2, 1, 0);
-    }
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle3210);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs
index 9bee9d15ec..edbd2cd5ea 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs
@@ -3,6 +3,7 @@
 
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using static SixLabors.ImageSharp.SimdUtils;
 
 namespace SixLabors.ImageSharp;
 
@@ -26,11 +27,15 @@ internal readonly struct DefaultShuffle3 : IShuffle3
         this.p2 = p2;
         this.p1 = p1;
         this.p0 = p0;
-        this.Control = SimdUtils.Shuffle.MmShuffle(3, p2, p1, p0);
+        this.Control = Shuffle.MmShuffle(3, p2, p1, p0);
     }
 
     public byte Control { get; }
 
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle3Reduce(ref source, ref dest, this.Control);
+
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs
index 90b77b568e..2179a085be 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs
@@ -3,6 +3,7 @@
 
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using static SixLabors.ImageSharp.SimdUtils;
 
 namespace SixLabors.ImageSharp;
 
@@ -27,11 +28,15 @@ internal readonly struct DefaultShuffle4Slice3 : IShuffle4Slice3
         this.p2 = p2;
         this.p1 = p1;
         this.p0 = p0;
-        this.Control = SimdUtils.Shuffle.MmShuffle(p3, p2, p1, p0);
+        this.Control = Shuffle.MmShuffle(p3, p2, p1, p0);
     }
 
     public byte Control { get; }
 
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, this.Control);
+
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
     {
@@ -53,11 +58,9 @@ internal readonly struct DefaultShuffle4Slice3 : IShuffle4Slice3
 
 internal readonly struct XYZWShuffle4Slice3 : IShuffle4Slice3
 {
-    public byte Control
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        get => SimdUtils.Shuffle.MmShuffle(3, 2, 1, 0);
-    }
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
+        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, Shuffle.MMShuffle3210);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs b/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs
index b91dc2fad2..4ff5f3d5b1 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs
@@ -37,6 +37,7 @@ internal static partial class SimdUtils
     /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
     /// using the control and store the results in <paramref name="dest"/>.
     /// </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="shuffle">The type of shuffle to perform.</param>
@@ -49,7 +50,7 @@ internal static partial class SimdUtils
     {
         VerifyShuffle4SpanInput(source, dest);
 
-        HwIntrinsics.Shuffle4Reduce(ref source, ref dest, shuffle.Control);
+        shuffle.ShuffleReduce(ref source, ref dest);
 
         // Deal with the remainder:
         if (source.Length > 0)
@@ -62,6 +63,7 @@ internal static partial class SimdUtils
     /// Shuffle 8-bit integer triplets within 128-bit lanes in <paramref name="source"/>
     /// using the control and store the results in <paramref name="dest"/>.
     /// </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="shuffle">The type of shuffle to perform.</param>
@@ -75,7 +77,7 @@ internal static partial class SimdUtils
         // Source length should be smaller than dest length, and divisible by 3.
         VerifyShuffle3SpanInput(source, dest);
 
-        HwIntrinsics.Shuffle3Reduce(ref source, ref dest, shuffle.Control);
+        shuffle.ShuffleReduce(ref source, ref dest);
 
         // Deal with the remainder:
         if (source.Length > 0)
@@ -88,6 +90,7 @@ internal static partial class SimdUtils
     /// 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"/>.
     /// </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="shuffle">The type of shuffle to perform.</param>
@@ -100,7 +103,7 @@ internal static partial class SimdUtils
     {
         VerifyPad3Shuffle4SpanInput(source, dest);
 
-        HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, shuffle.Control);
+        shuffle.ShuffleReduce(ref source, ref dest);
 
         // Deal with the remainder:
         if (source.Length > 0)
@@ -113,6 +116,7 @@ internal static partial class SimdUtils
     /// 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"/>.
     /// </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="shuffle">The type of shuffle to perform.</param>
@@ -125,7 +129,7 @@ internal static partial class SimdUtils
     {
         VerifyShuffle4Slice3SpanInput(source, dest);
 
-        HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, shuffle.Control);
+        shuffle.ShuffleReduce(ref source, ref dest);
 
         // Deal with the remainder:
         if (source.Length > 0)
@@ -153,7 +157,7 @@ internal static partial class SimdUtils
     }
 
     [Conditional("DEBUG")]
-    private static void VerifyShuffle4SpanInput<T>(ReadOnlySpan<T> source, Span<T> dest)
+    internal static void VerifyShuffle4SpanInput<T>(ReadOnlySpan<T> source, Span<T> dest)
         where T : struct
     {
         DebugGuard.IsTrue(
@@ -222,6 +226,263 @@ internal static partial class SimdUtils
 
     public static class Shuffle
     {
+        public const byte MMShuffle0000 = 0b00000000;
+        public const byte MMShuffle0001 = 0b00000001;
+        public const byte MMShuffle0002 = 0b00000010;
+        public const byte MMShuffle0003 = 0b00000011;
+        public const byte MMShuffle0010 = 0b00000100;
+        public const byte MMShuffle0011 = 0b00000101;
+        public const byte MMShuffle0012 = 0b00000110;
+        public const byte MMShuffle0013 = 0b00000111;
+        public const byte MMShuffle0020 = 0b00001000;
+        public const byte MMShuffle0021 = 0b00001001;
+        public const byte MMShuffle0022 = 0b00001010;
+        public const byte MMShuffle0023 = 0b00001011;
+        public const byte MMShuffle0030 = 0b00001100;
+        public const byte MMShuffle0031 = 0b00001101;
+        public const byte MMShuffle0032 = 0b00001110;
+        public const byte MMShuffle0033 = 0b00001111;
+        public const byte MMShuffle0100 = 0b00010000;
+        public const byte MMShuffle0101 = 0b00010001;
+        public const byte MMShuffle0102 = 0b00010010;
+        public const byte MMShuffle0103 = 0b00010011;
+        public const byte MMShuffle0110 = 0b00010100;
+        public const byte MMShuffle0111 = 0b00010101;
+        public const byte MMShuffle0112 = 0b00010110;
+        public const byte MMShuffle0113 = 0b00010111;
+        public const byte MMShuffle0120 = 0b00011000;
+        public const byte MMShuffle0121 = 0b00011001;
+        public const byte MMShuffle0122 = 0b00011010;
+        public const byte MMShuffle0123 = 0b00011011;
+        public const byte MMShuffle0130 = 0b00011100;
+        public const byte MMShuffle0131 = 0b00011101;
+        public const byte MMShuffle0132 = 0b00011110;
+        public const byte MMShuffle0133 = 0b00011111;
+        public const byte MMShuffle0200 = 0b00100000;
+        public const byte MMShuffle0201 = 0b00100001;
+        public const byte MMShuffle0202 = 0b00100010;
+        public const byte MMShuffle0203 = 0b00100011;
+        public const byte MMShuffle0210 = 0b00100100;
+        public const byte MMShuffle0211 = 0b00100101;
+        public const byte MMShuffle0212 = 0b00100110;
+        public const byte MMShuffle0213 = 0b00100111;
+        public const byte MMShuffle0220 = 0b00101000;
+        public const byte MMShuffle0221 = 0b00101001;
+        public const byte MMShuffle0222 = 0b00101010;
+        public const byte MMShuffle0223 = 0b00101011;
+        public const byte MMShuffle0230 = 0b00101100;
+        public const byte MMShuffle0231 = 0b00101101;
+        public const byte MMShuffle0232 = 0b00101110;
+        public const byte MMShuffle0233 = 0b00101111;
+        public const byte MMShuffle0300 = 0b00110000;
+        public const byte MMShuffle0301 = 0b00110001;
+        public const byte MMShuffle0302 = 0b00110010;
+        public const byte MMShuffle0303 = 0b00110011;
+        public const byte MMShuffle0310 = 0b00110100;
+        public const byte MMShuffle0311 = 0b00110101;
+        public const byte MMShuffle0312 = 0b00110110;
+        public const byte MMShuffle0313 = 0b00110111;
+        public const byte MMShuffle0320 = 0b00111000;
+        public const byte MMShuffle0321 = 0b00111001;
+        public const byte MMShuffle0322 = 0b00111010;
+        public const byte MMShuffle0323 = 0b00111011;
+        public const byte MMShuffle0330 = 0b00111100;
+        public const byte MMShuffle0331 = 0b00111101;
+        public const byte MMShuffle0332 = 0b00111110;
+        public const byte MMShuffle0333 = 0b00111111;
+        public const byte MMShuffle1000 = 0b01000000;
+        public const byte MMShuffle1001 = 0b01000001;
+        public const byte MMShuffle1002 = 0b01000010;
+        public const byte MMShuffle1003 = 0b01000011;
+        public const byte MMShuffle1010 = 0b01000100;
+        public const byte MMShuffle1011 = 0b01000101;
+        public const byte MMShuffle1012 = 0b01000110;
+        public const byte MMShuffle1013 = 0b01000111;
+        public const byte MMShuffle1020 = 0b01001000;
+        public const byte MMShuffle1021 = 0b01001001;
+        public const byte MMShuffle1022 = 0b01001010;
+        public const byte MMShuffle1023 = 0b01001011;
+        public const byte MMShuffle1030 = 0b01001100;
+        public const byte MMShuffle1031 = 0b01001101;
+        public const byte MMShuffle1032 = 0b01001110;
+        public const byte MMShuffle1033 = 0b01001111;
+        public const byte MMShuffle1100 = 0b01010000;
+        public const byte MMShuffle1101 = 0b01010001;
+        public const byte MMShuffle1102 = 0b01010010;
+        public const byte MMShuffle1103 = 0b01010011;
+        public const byte MMShuffle1110 = 0b01010100;
+        public const byte MMShuffle1111 = 0b01010101;
+        public const byte MMShuffle1112 = 0b01010110;
+        public const byte MMShuffle1113 = 0b01010111;
+        public const byte MMShuffle1120 = 0b01011000;
+        public const byte MMShuffle1121 = 0b01011001;
+        public const byte MMShuffle1122 = 0b01011010;
+        public const byte MMShuffle1123 = 0b01011011;
+        public const byte MMShuffle1130 = 0b01011100;
+        public const byte MMShuffle1131 = 0b01011101;
+        public const byte MMShuffle1132 = 0b01011110;
+        public const byte MMShuffle1133 = 0b01011111;
+        public const byte MMShuffle1200 = 0b01100000;
+        public const byte MMShuffle1201 = 0b01100001;
+        public const byte MMShuffle1202 = 0b01100010;
+        public const byte MMShuffle1203 = 0b01100011;
+        public const byte MMShuffle1210 = 0b01100100;
+        public const byte MMShuffle1211 = 0b01100101;
+        public const byte MMShuffle1212 = 0b01100110;
+        public const byte MMShuffle1213 = 0b01100111;
+        public const byte MMShuffle1220 = 0b01101000;
+        public const byte MMShuffle1221 = 0b01101001;
+        public const byte MMShuffle1222 = 0b01101010;
+        public const byte MMShuffle1223 = 0b01101011;
+        public const byte MMShuffle1230 = 0b01101100;
+        public const byte MMShuffle1231 = 0b01101101;
+        public const byte MMShuffle1232 = 0b01101110;
+        public const byte MMShuffle1233 = 0b01101111;
+        public const byte MMShuffle1300 = 0b01110000;
+        public const byte MMShuffle1301 = 0b01110001;
+        public const byte MMShuffle1302 = 0b01110010;
+        public const byte MMShuffle1303 = 0b01110011;
+        public const byte MMShuffle1310 = 0b01110100;
+        public const byte MMShuffle1311 = 0b01110101;
+        public const byte MMShuffle1312 = 0b01110110;
+        public const byte MMShuffle1313 = 0b01110111;
+        public const byte MMShuffle1320 = 0b01111000;
+        public const byte MMShuffle1321 = 0b01111001;
+        public const byte MMShuffle1322 = 0b01111010;
+        public const byte MMShuffle1323 = 0b01111011;
+        public const byte MMShuffle1330 = 0b01111100;
+        public const byte MMShuffle1331 = 0b01111101;
+        public const byte MMShuffle1332 = 0b01111110;
+        public const byte MMShuffle1333 = 0b01111111;
+        public const byte MMShuffle2000 = 0b10000000;
+        public const byte MMShuffle2001 = 0b10000001;
+        public const byte MMShuffle2002 = 0b10000010;
+        public const byte MMShuffle2003 = 0b10000011;
+        public const byte MMShuffle2010 = 0b10000100;
+        public const byte MMShuffle2011 = 0b10000101;
+        public const byte MMShuffle2012 = 0b10000110;
+        public const byte MMShuffle2013 = 0b10000111;
+        public const byte MMShuffle2020 = 0b10001000;
+        public const byte MMShuffle2021 = 0b10001001;
+        public const byte MMShuffle2022 = 0b10001010;
+        public const byte MMShuffle2023 = 0b10001011;
+        public const byte MMShuffle2030 = 0b10001100;
+        public const byte MMShuffle2031 = 0b10001101;
+        public const byte MMShuffle2032 = 0b10001110;
+        public const byte MMShuffle2033 = 0b10001111;
+        public const byte MMShuffle2100 = 0b10010000;
+        public const byte MMShuffle2101 = 0b10010001;
+        public const byte MMShuffle2102 = 0b10010010;
+        public const byte MMShuffle2103 = 0b10010011;
+        public const byte MMShuffle2110 = 0b10010100;
+        public const byte MMShuffle2111 = 0b10010101;
+        public const byte MMShuffle2112 = 0b10010110;
+        public const byte MMShuffle2113 = 0b10010111;
+        public const byte MMShuffle2120 = 0b10011000;
+        public const byte MMShuffle2121 = 0b10011001;
+        public const byte MMShuffle2122 = 0b10011010;
+        public const byte MMShuffle2123 = 0b10011011;
+        public const byte MMShuffle2130 = 0b10011100;
+        public const byte MMShuffle2131 = 0b10011101;
+        public const byte MMShuffle2132 = 0b10011110;
+        public const byte MMShuffle2133 = 0b10011111;
+        public const byte MMShuffle2200 = 0b10100000;
+        public const byte MMShuffle2201 = 0b10100001;
+        public const byte MMShuffle2202 = 0b10100010;
+        public const byte MMShuffle2203 = 0b10100011;
+        public const byte MMShuffle2210 = 0b10100100;
+        public const byte MMShuffle2211 = 0b10100101;
+        public const byte MMShuffle2212 = 0b10100110;
+        public const byte MMShuffle2213 = 0b10100111;
+        public const byte MMShuffle2220 = 0b10101000;
+        public const byte MMShuffle2221 = 0b10101001;
+        public const byte MMShuffle2222 = 0b10101010;
+        public const byte MMShuffle2223 = 0b10101011;
+        public const byte MMShuffle2230 = 0b10101100;
+        public const byte MMShuffle2231 = 0b10101101;
+        public const byte MMShuffle2232 = 0b10101110;
+        public const byte MMShuffle2233 = 0b10101111;
+        public const byte MMShuffle2300 = 0b10110000;
+        public const byte MMShuffle2301 = 0b10110001;
+        public const byte MMShuffle2302 = 0b10110010;
+        public const byte MMShuffle2303 = 0b10110011;
+        public const byte MMShuffle2310 = 0b10110100;
+        public const byte MMShuffle2311 = 0b10110101;
+        public const byte MMShuffle2312 = 0b10110110;
+        public const byte MMShuffle2313 = 0b10110111;
+        public const byte MMShuffle2320 = 0b10111000;
+        public const byte MMShuffle2321 = 0b10111001;
+        public const byte MMShuffle2322 = 0b10111010;
+        public const byte MMShuffle2323 = 0b10111011;
+        public const byte MMShuffle2330 = 0b10111100;
+        public const byte MMShuffle2331 = 0b10111101;
+        public const byte MMShuffle2332 = 0b10111110;
+        public const byte MMShuffle2333 = 0b10111111;
+        public const byte MMShuffle3000 = 0b11000000;
+        public const byte MMShuffle3001 = 0b11000001;
+        public const byte MMShuffle3002 = 0b11000010;
+        public const byte MMShuffle3003 = 0b11000011;
+        public const byte MMShuffle3010 = 0b11000100;
+        public const byte MMShuffle3011 = 0b11000101;
+        public const byte MMShuffle3012 = 0b11000110;
+        public const byte MMShuffle3013 = 0b11000111;
+        public const byte MMShuffle3020 = 0b11001000;
+        public const byte MMShuffle3021 = 0b11001001;
+        public const byte MMShuffle3022 = 0b11001010;
+        public const byte MMShuffle3023 = 0b11001011;
+        public const byte MMShuffle3030 = 0b11001100;
+        public const byte MMShuffle3031 = 0b11001101;
+        public const byte MMShuffle3032 = 0b11001110;
+        public const byte MMShuffle3033 = 0b11001111;
+        public const byte MMShuffle3100 = 0b11010000;
+        public const byte MMShuffle3101 = 0b11010001;
+        public const byte MMShuffle3102 = 0b11010010;
+        public const byte MMShuffle3103 = 0b11010011;
+        public const byte MMShuffle3110 = 0b11010100;
+        public const byte MMShuffle3111 = 0b11010101;
+        public const byte MMShuffle3112 = 0b11010110;
+        public const byte MMShuffle3113 = 0b11010111;
+        public const byte MMShuffle3120 = 0b11011000;
+        public const byte MMShuffle3121 = 0b11011001;
+        public const byte MMShuffle3122 = 0b11011010;
+        public const byte MMShuffle3123 = 0b11011011;
+        public const byte MMShuffle3130 = 0b11011100;
+        public const byte MMShuffle3131 = 0b11011101;
+        public const byte MMShuffle3132 = 0b11011110;
+        public const byte MMShuffle3133 = 0b11011111;
+        public const byte MMShuffle3200 = 0b11100000;
+        public const byte MMShuffle3201 = 0b11100001;
+        public const byte MMShuffle3202 = 0b11100010;
+        public const byte MMShuffle3203 = 0b11100011;
+        public const byte MMShuffle3210 = 0b11100100;
+        public const byte MMShuffle3211 = 0b11100101;
+        public const byte MMShuffle3212 = 0b11100110;
+        public const byte MMShuffle3213 = 0b11100111;
+        public const byte MMShuffle3220 = 0b11101000;
+        public const byte MMShuffle3221 = 0b11101001;
+        public const byte MMShuffle3222 = 0b11101010;
+        public const byte MMShuffle3223 = 0b11101011;
+        public const byte MMShuffle3230 = 0b11101100;
+        public const byte MMShuffle3231 = 0b11101101;
+        public const byte MMShuffle3232 = 0b11101110;
+        public const byte MMShuffle3233 = 0b11101111;
+        public const byte MMShuffle3300 = 0b11110000;
+        public const byte MMShuffle3301 = 0b11110001;
+        public const byte MMShuffle3302 = 0b11110010;
+        public const byte MMShuffle3303 = 0b11110011;
+        public const byte MMShuffle3310 = 0b11110100;
+        public const byte MMShuffle3311 = 0b11110101;
+        public const byte MMShuffle3312 = 0b11110110;
+        public const byte MMShuffle3313 = 0b11110111;
+        public const byte MMShuffle3320 = 0b11111000;
+        public const byte MMShuffle3321 = 0b11111001;
+        public const byte MMShuffle3322 = 0b11111010;
+        public const byte MMShuffle3323 = 0b11111011;
+        public const byte MMShuffle3330 = 0b11111100;
+        public const byte MMShuffle3331 = 0b11111101;
+        public const byte MMShuffle3332 = 0b11111110;
+        public const byte MMShuffle3333 = 0b11111111;
+
         [MethodImpl(InliningOptions.ShortMethod)]
         public static byte MmShuffle(byte p3, byte p2, byte p1, byte p0)
             => (byte)((p3 << 6) | (p2 << 4) | (p1 << 2) | p0);
diff --git a/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs b/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs
index 5d9c207096..ac92ce6a6a 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs
@@ -96,7 +96,7 @@ internal static unsafe class LosslessUtils
     {
         if (Avx2.IsSupported)
         {
-            var addGreenToBlueAndRedMaskAvx2 = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
+            Vector256<byte> addGreenToBlueAndRedMaskAvx2 = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
             int numPixels = pixelData.Length;
             nint i;
             for (i = 0; i <= numPixels - 8; i += 8)
@@ -115,7 +115,7 @@ internal static unsafe class LosslessUtils
         }
         else if (Ssse3.IsSupported)
         {
-            var addGreenToBlueAndRedMaskSsse3 = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
+            Vector128<byte> addGreenToBlueAndRedMaskSsse3 = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
             int numPixels = pixelData.Length;
             nint i;
             for (i = 0; i <= numPixels - 4; i += 4)
@@ -138,13 +138,11 @@ internal static unsafe class LosslessUtils
             nint i;
             for (i = 0; i <= numPixels - 4; i += 4)
             {
-                const byte mmShuffle_2200 = 0b_10_10_00_00;
-
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
                 Vector128<byte> input = Unsafe.As<uint, Vector128<uint>>(ref pos).AsByte();
                 Vector128<ushort> a = Sse2.ShiftRightLogical(input.AsUInt16(), 8); // 0 a 0 g
-                Vector128<ushort> b = Sse2.ShuffleLow(a, mmShuffle_2200);
-                Vector128<ushort> c = Sse2.ShuffleHigh(b, mmShuffle_2200); // 0g0g
+                Vector128<ushort> b = Sse2.ShuffleLow(a, SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<ushort> c = Sse2.ShuffleHigh(b, SimdUtils.Shuffle.MMShuffle2200); // 0g0g
                 Vector128<byte> output = Sse2.Add(input.AsByte(), c.AsByte());
                 Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
             }
@@ -178,7 +176,7 @@ internal static unsafe class LosslessUtils
     {
         if (Avx2.IsSupported)
         {
-            var subtractGreenFromBlueAndRedMaskAvx2 = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
+            Vector256<byte> subtractGreenFromBlueAndRedMaskAvx2 = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
             int numPixels = pixelData.Length;
             nint i;
             for (i = 0; i <= numPixels - 8; i += 8)
@@ -197,7 +195,7 @@ internal static unsafe class LosslessUtils
         }
         else if (Ssse3.IsSupported)
         {
-            var subtractGreenFromBlueAndRedMaskSsse3 = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
+            Vector128<byte> subtractGreenFromBlueAndRedMaskSsse3 = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
             int numPixels = pixelData.Length;
             nint i;
             for (i = 0; i <= numPixels - 4; i += 4)
@@ -220,13 +218,11 @@ internal static unsafe class LosslessUtils
             nint i;
             for (i = 0; i <= numPixels - 4; i += 4)
             {
-                const byte mmShuffle_2200 = 0b_10_10_00_00;
-
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
                 Vector128<byte> input = Unsafe.As<uint, Vector128<uint>>(ref pos).AsByte();
                 Vector128<ushort> a = Sse2.ShiftRightLogical(input.AsUInt16(), 8); // 0 a 0 g
-                Vector128<ushort> b = Sse2.ShuffleLow(a, mmShuffle_2200);
-                Vector128<ushort> c = Sse2.ShuffleHigh(b, mmShuffle_2200); // 0g0g
+                Vector128<ushort> b = Sse2.ShuffleLow(a, SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<ushort> c = Sse2.ShuffleHigh(b, SimdUtils.Shuffle.MMShuffle2200); // 0g0g
                 Vector128<byte> output = Sse2.Subtract(input.AsByte(), c.AsByte());
                 Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
             }
@@ -334,7 +330,7 @@ internal static unsafe class LosslessUtils
         while (y < yEnd)
         {
             int predRowIdx = predRowIdxStart;
-            var m = default(Vp8LMultipliers);
+            Vp8LMultipliers m = default;
             int srcSafeEnd = pixelPos + safeWidth;
             int srcEnd = pixelPos + width;
             while (pixelPos < srcSafeEnd)
@@ -371,21 +367,19 @@ internal static unsafe class LosslessUtils
     {
         if (Avx2.IsSupported && numPixels >= 8)
         {
-            var transformColorAlphaGreenMask256 = Vector256.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
-            var transformColorRedBlueMask256 = Vector256.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
+            Vector256<byte> transformColorAlphaGreenMask256 = Vector256.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
+            Vector256<byte> transformColorRedBlueMask256 = Vector256.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
             Vector256<int> multsrb = MkCst32(Cst5b(m.GreenToRed), Cst5b(m.GreenToBlue));
             Vector256<int> multsb2 = MkCst32(Cst5b(m.RedToBlue), 0);
 
             nint idx;
             for (idx = 0; idx <= numPixels - 8; idx += 8)
             {
-                const byte mmShuffle_2200 = 0b_10_10_00_00;
-
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), idx);
                 Vector256<uint> input = Unsafe.As<uint, Vector256<uint>>(ref pos);
                 Vector256<byte> a = Avx2.And(input.AsByte(), transformColorAlphaGreenMask256);
-                Vector256<short> b = Avx2.ShuffleLow(a.AsInt16(), mmShuffle_2200);
-                Vector256<short> c = Avx2.ShuffleHigh(b.AsInt16(), mmShuffle_2200);
+                Vector256<short> b = Avx2.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector256<short> c = Avx2.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
                 Vector256<short> d = Avx2.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
                 Vector256<short> e = Avx2.ShiftLeftLogical(input.AsInt16(), 8);
                 Vector256<short> f = Avx2.MultiplyHigh(e.AsInt16(), multsb2.AsInt16());
@@ -403,20 +397,18 @@ internal static unsafe class LosslessUtils
         }
         else if (Sse2.IsSupported)
         {
-            var transformColorAlphaGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
-            var transformColorRedBlueMask = Vector128.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
+            Vector128<byte> transformColorAlphaGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
+            Vector128<byte> transformColorRedBlueMask = Vector128.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
             Vector128<int> multsrb = MkCst16(Cst5b(m.GreenToRed), Cst5b(m.GreenToBlue));
             Vector128<int> multsb2 = MkCst16(Cst5b(m.RedToBlue), 0);
             nint idx;
             for (idx = 0; idx <= numPixels - 4; idx += 4)
             {
-                const byte mmShuffle_2200 = 0b_10_10_00_00;
-
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), idx);
                 Vector128<uint> input = Unsafe.As<uint, Vector128<uint>>(ref pos);
                 Vector128<byte> a = Sse2.And(input.AsByte(), transformColorAlphaGreenMask);
-                Vector128<short> b = Sse2.ShuffleLow(a.AsInt16(), mmShuffle_2200);
-                Vector128<short> c = Sse2.ShuffleHigh(b.AsInt16(), mmShuffle_2200);
+                Vector128<short> b = Sse2.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<short> c = Sse2.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
                 Vector128<short> d = Sse2.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
                 Vector128<short> e = Sse2.ShiftLeftLogical(input.AsInt16(), 8);
                 Vector128<short> f = Sse2.MultiplyHigh(e.AsInt16(), multsb2.AsInt16());
@@ -465,19 +457,17 @@ internal static unsafe class LosslessUtils
     {
         if (Avx2.IsSupported && pixelData.Length >= 8)
         {
-            var transformColorInverseAlphaGreenMask256 = Vector256.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
+            Vector256<byte> transformColorInverseAlphaGreenMask256 = Vector256.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
             Vector256<int> multsrb = MkCst32(Cst5b(m.GreenToRed), Cst5b(m.GreenToBlue));
             Vector256<int> multsb2 = MkCst32(Cst5b(m.RedToBlue), 0);
             nint idx;
             for (idx = 0; idx <= pixelData.Length - 8; idx += 8)
             {
-                const byte mmShuffle_2200 = 0b_10_10_00_00;
-
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), idx);
                 Vector256<uint> input = Unsafe.As<uint, Vector256<uint>>(ref pos);
                 Vector256<byte> a = Avx2.And(input.AsByte(), transformColorInverseAlphaGreenMask256);
-                Vector256<short> b = Avx2.ShuffleLow(a.AsInt16(), mmShuffle_2200);
-                Vector256<short> c = Avx2.ShuffleHigh(b.AsInt16(), mmShuffle_2200);
+                Vector256<short> b = Avx2.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector256<short> c = Avx2.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
                 Vector256<short> d = Avx2.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
                 Vector256<byte> e = Avx2.Add(input.AsByte(), d.AsByte());
                 Vector256<short> f = Avx2.ShiftLeftLogical(e.AsInt16(), 8);
@@ -496,20 +486,18 @@ internal static unsafe class LosslessUtils
         }
         else if (Sse2.IsSupported)
         {
-            var transformColorInverseAlphaGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
+            Vector128<byte> transformColorInverseAlphaGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
             Vector128<int> multsrb = MkCst16(Cst5b(m.GreenToRed), Cst5b(m.GreenToBlue));
             Vector128<int> multsb2 = MkCst16(Cst5b(m.RedToBlue), 0);
 
             nint idx;
             for (idx = 0; idx <= pixelData.Length - 4; idx += 4)
             {
-                const byte mmShuffle_2200 = 0b_10_10_00_00;
-
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), idx);
                 Vector128<uint> input = Unsafe.As<uint, Vector128<uint>>(ref pos);
                 Vector128<byte> a = Sse2.And(input.AsByte(), transformColorInverseAlphaGreenMask);
-                Vector128<short> b = Sse2.ShuffleLow(a.AsInt16(), mmShuffle_2200);
-                Vector128<short> c = Sse2.ShuffleHigh(b.AsInt16(), mmShuffle_2200);
+                Vector128<short> b = Sse2.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<short> c = Sse2.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
                 Vector128<short> d = Sse2.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
                 Vector128<byte> e = Sse2.Add(input.AsByte(), d.AsByte());
                 Vector128<short> f = Sse2.ShiftLeftLogical(e.AsInt16(), 8);
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs
index cc263657f1..82f00e8760 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs
@@ -521,9 +521,8 @@ internal static unsafe class Vp8Encoding
     {
         // *in01 = 00 01 10 11 02 03 12 13
         // *in23 = 20 21 30 31 22 23 32 33
-        const byte mmShuffle_2301 = 0b_10_11_00_01;
-        Vector128<short> shuf01_p = Sse2.ShuffleHigh(row01, mmShuffle_2301);
-        Vector128<short> shuf32_p = Sse2.ShuffleHigh(row23, mmShuffle_2301);
+        Vector128<short> shuf01_p = Sse2.ShuffleHigh(row01, SimdUtils.Shuffle.MMShuffle2301);
+        Vector128<short> shuf32_p = Sse2.ShuffleHigh(row23, SimdUtils.Shuffle.MMShuffle2301);
 
         // 00 01 10 11 03 02 13 12
         // 20 21 30 31 23 22 33 32
@@ -555,9 +554,7 @@ internal static unsafe class Vp8Encoding
         Vector128<short> shi = Sse2.UnpackHigh(s03, s12); // 2 3 2 3 2 3
         Vector128<int> v23 = Sse2.UnpackHigh(slo.AsInt32(), shi.AsInt32());
         out01 = Sse2.UnpackLow(slo.AsInt32(), shi.AsInt32());
-
-        const byte mmShuffle_1032 = 0b_01_00_11_10;
-        out32 = Sse2.Shuffle(v23, mmShuffle_1032);
+        out32 = Sse2.Shuffle(v23, SimdUtils.Shuffle.MMShuffle1032);
     }
 
     public static void FTransformPass2SSE2(Vector128<int> v01, Vector128<int> v32, Span<short> output)
diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/ShuffleFloat4Channel.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/ShuffleFloat4Channel.cs
index bdeb880828..ec23364caa 100644
--- a/tests/ImageSharp.Benchmarks/Color/Bulk/ShuffleFloat4Channel.cs
+++ b/tests/ImageSharp.Benchmarks/Color/Bulk/ShuffleFloat4Channel.cs
@@ -9,7 +9,6 @@ namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
 [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
 public class ShuffleFloat4Channel
 {
-    private static readonly byte Control = default(WXYZShuffle4).Control;
     private float[] source;
     private float[] destination;
 
@@ -25,9 +24,7 @@ public class ShuffleFloat4Channel
 
     [Benchmark]
     public void Shuffle4Channel()
-    {
-        SimdUtils.Shuffle4(this.source, this.destination, Control);
-    }
+        => SimdUtils.Shuffle4(this.source, this.destination, SimdUtils.Shuffle.MMShuffle2103);
 }
 
 // 2020-10-29
diff --git a/tests/ImageSharp.Tests/Common/SimdUtilsTests.Shuffle.cs b/tests/ImageSharp.Tests/Common/SimdUtilsTests.Shuffle.cs
index 9727731b6e..2c4989f387 100644
--- a/tests/ImageSharp.Tests/Common/SimdUtilsTests.Shuffle.cs
+++ b/tests/ImageSharp.Tests/Common/SimdUtilsTests.Shuffle.cs
@@ -16,7 +16,7 @@ public partial class SimdUtilsTests
             // No need to test multiple shuffle controls as the
             // pipeline is always the same.
             int size = FeatureTestRunner.Deserialize<int>(serialized);
-            byte control = default(WZYXShuffle4).Control;
+            const byte control = SimdUtils.Shuffle.MMShuffle0123;
 
             TestShuffleFloat4Channel(
                 size,
@@ -45,39 +45,39 @@ public partial class SimdUtilsTests
             TestShuffleByte4Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4(s.Span, d.Span, wxyz),
-                wxyz.Control);
+                SimdUtils.Shuffle.MMShuffle2103);
 
             WZYXShuffle4 wzyx = default;
             TestShuffleByte4Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4(s.Span, d.Span, wzyx),
-                wzyx.Control);
+                SimdUtils.Shuffle.MMShuffle0123);
 
             YZWXShuffle4 yzwx = default;
             TestShuffleByte4Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4(s.Span, d.Span, yzwx),
-                yzwx.Control);
+                SimdUtils.Shuffle.MMShuffle0321);
 
             ZYXWShuffle4 zyxw = default;
             TestShuffleByte4Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4(s.Span, d.Span, zyxw),
-                zyxw.Control);
+                SimdUtils.Shuffle.MMShuffle3012);
 
-            var xwyz = new DefaultShuffle4(2, 1, 3, 0);
+            DefaultShuffle4 xwyz = new(2, 1, 3, 0);
             TestShuffleByte4Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4(s.Span, d.Span, xwyz),
                 xwyz.Control);
 
-            var yyyy = new DefaultShuffle4(1, 1, 1, 1);
+            DefaultShuffle4 yyyy = new(1, 1, 1, 1);
             TestShuffleByte4Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4(s.Span, d.Span, yyyy),
                 yyyy.Control);
 
-            var wwww = new DefaultShuffle4(3, 3, 3, 3);
+            DefaultShuffle4 wwww = new(3, 3, 3, 3);
             TestShuffleByte4Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4(s.Span, d.Span, wwww),
@@ -101,25 +101,25 @@ public partial class SimdUtilsTests
             // These cannot be expressed as a theory as you cannot
             // use RemoteExecutor within generic methods nor pass
             // IShuffle3 to the generic utils method.
-            var zyx = new DefaultShuffle3(0, 1, 2);
+            DefaultShuffle3 zyx = new(0, 1, 2);
             TestShuffleByte3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle3(s.Span, d.Span, zyx),
                 zyx.Control);
 
-            var xyz = new DefaultShuffle3(2, 1, 0);
+            DefaultShuffle3 xyz = new(2, 1, 0);
             TestShuffleByte3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle3(s.Span, d.Span, xyz),
                 xyz.Control);
 
-            var yyy = new DefaultShuffle3(1, 1, 1);
+            DefaultShuffle3 yyy = new(1, 1, 1);
             TestShuffleByte3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle3(s.Span, d.Span, yyy),
                 yyy.Control);
 
-            var zzz = new DefaultShuffle3(2, 2, 2);
+            DefaultShuffle3 zzz = new(2, 2, 2);
             TestShuffleByte3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle3(s.Span, d.Span, zzz),
@@ -147,21 +147,21 @@ public partial class SimdUtilsTests
             TestPad3Shuffle4Channel(
                 size,
                 (s, d) => SimdUtils.Pad3Shuffle4(s.Span, d.Span, xyzw),
-                xyzw.Control);
+                SimdUtils.Shuffle.MMShuffle3210);
 
-            var xwyz = new DefaultPad3Shuffle4(2, 1, 3, 0);
+            DefaultPad3Shuffle4 xwyz = new(2, 1, 3, 0);
             TestPad3Shuffle4Channel(
                 size,
                 (s, d) => SimdUtils.Pad3Shuffle4(s.Span, d.Span, xwyz),
                 xwyz.Control);
 
-            var yyyy = new DefaultPad3Shuffle4(1, 1, 1, 1);
+            DefaultPad3Shuffle4 yyyy = new(1, 1, 1, 1);
             TestPad3Shuffle4Channel(
                 size,
                 (s, d) => SimdUtils.Pad3Shuffle4(s.Span, d.Span, yyyy),
                 yyyy.Control);
 
-            var wwww = new DefaultPad3Shuffle4(3, 3, 3, 3);
+            DefaultPad3Shuffle4 wwww = new(3, 3, 3, 3);
             TestPad3Shuffle4Channel(
                 size,
                 (s, d) => SimdUtils.Pad3Shuffle4(s.Span, d.Span, wwww),
@@ -189,21 +189,21 @@ public partial class SimdUtilsTests
             TestShuffle4Slice3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4Slice3(s.Span, d.Span, xyzw),
-                xyzw.Control);
+                SimdUtils.Shuffle.MMShuffle3210);
 
-            var xwyz = new DefaultShuffle4Slice3(2, 1, 3, 0);
+            DefaultShuffle4Slice3 xwyz = new(2, 1, 3, 0);
             TestShuffle4Slice3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4Slice3(s.Span, d.Span, xwyz),
                 xwyz.Control);
 
-            var yyyy = new DefaultShuffle4Slice3(1, 1, 1, 1);
+            DefaultShuffle4Slice3 yyyy = new(1, 1, 1, 1);
             TestShuffle4Slice3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4Slice3(s.Span, d.Span, yyyy),
                 yyyy.Control);
 
-            var wwww = new DefaultShuffle4Slice3(3, 3, 3, 3);
+            DefaultShuffle4Slice3 wwww = new(3, 3, 3, 3);
             TestShuffle4Slice3Channel(
                 size,
                 (s, d) => SimdUtils.Shuffle4Slice3(s.Span, d.Span, wwww),
@@ -222,7 +222,7 @@ public partial class SimdUtilsTests
         byte control)
     {
         float[] source = new Random(count).GenerateRandomFloatArray(count, 0, 256);
-        var result = new float[count];
+        float[] result = new float[count];
 
         float[] expected = new float[count];
 
@@ -253,7 +253,7 @@ public partial class SimdUtilsTests
     {
         byte[] source = new byte[count];
         new Random(count).NextBytes(source);
-        var result = new byte[count];
+        byte[] result = new byte[count];
 
         byte[] expected = new byte[count];
 
@@ -284,7 +284,7 @@ public partial class SimdUtilsTests
     {
         byte[] source = new byte[count];
         new Random(count).NextBytes(source);
-        var result = new byte[count];
+        byte[] result = new byte[count];
 
         byte[] expected = new byte[count];
 
@@ -315,7 +315,7 @@ public partial class SimdUtilsTests
         byte[] source = new byte[count];
         new Random(count).NextBytes(source);
 
-        var result = new byte[count * 4 / 3];
+        byte[] result = new byte[count * 4 / 3];
 
         byte[] expected = new byte[result.Length];
 
@@ -366,7 +366,7 @@ public partial class SimdUtilsTests
         byte[] source = new byte[count];
         new Random(count).NextBytes(source);
 
-        var result = new byte[count * 3 / 4];
+        byte[] result = new byte[count * 3 / 4];
 
         byte[] expected = new byte[result.Length];