Merge pull request #3161 from SixLabors/perf/simd-primitives-normalization

Normalize SIMD pipelines using TensorPrimitives_

shared-infrastructure

@@ -1 +1 @@
-Subproject commit 7ac5703452348d9295db31fc0912c2bd9e419dc9
+Subproject commit 74b7f32b8e41fdf8fe2f3eda54fd5a82ebbedfbc

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsIcc.cs

@@ -5,9 +5,11 @@ using System.Buffers;
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
 using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
@@ -658,38 +660,10 @@ internal static class ColorProfileConverterExtensionsIcc
 
     private static void ClipNegative(Span<Vector4> source)
     {
-        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported && Vector<float>.Count >= source.Length * 4)
+        // Vector4 values are contiguous floats, so flattening preserves the component order
-        {
+        // while allowing one shared tensor traversal to process every channel and SIMD tail.
-            // SIMD loop
+        Span<float> values = MemoryMarshal.Cast<Vector4, float>(source);
-            int i = 0;
+        TensorPrimitives_.Max(values, 0F, values);
-            int simdBatchSize = Vector<float>.Count / 4; // Number of Vector4 elements per SIMD batch
-            for (; i <= source.Length - simdBatchSize; i += simdBatchSize)
-            {
-                // Load the vector from source span
-                Vector<float> v = Unsafe.ReadUnaligned<Vector<float>>(ref Unsafe.As<Vector4, byte>(ref source[i]));
-
-                v = Vector.Max(v, Vector<float>.Zero);
-
-                // Write the vector to the destination span
-                Unsafe.WriteUnaligned(ref Unsafe.As<Vector4, byte>(ref source[i]), v);
-            }
-
-            // Scalar fallback for remaining elements
-            for (; i < source.Length; i++)
-            {
-                ref Vector4 s = ref source[i];
-                s = Vector4.Max(s, Vector4.Zero);
-            }
-        }
-        else
-        {
-            // Scalar fallback if SIMD is not supported
-            for (int i = 0; i < source.Length; i++)
-            {
-                ref Vector4 s = ref source[i];
-                s = Vector4.Max(s, Vector4.Zero);
-            }
-        }
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -708,39 +682,9 @@ internal static class ColorProfileConverterExtensionsIcc
 
     private static void LabToLab(Span<Vector4> source, Span<Vector4> destination, [ConstantExpected] float scale)
     {
-        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported)
+        // Reinterpreting both spans exposes all four components to one multiplication traversal;
-        {
+        // the source and destination retain their original Vector4 boundaries after the operation.
-            Vector<float> vScale = new(scale);
+        TensorPrimitives_.Multiply(MemoryMarshal.Cast<Vector4, float>(source), scale, MemoryMarshal.Cast<Vector4, float>(destination));
-            int i = 0;
-
-            // SIMD loop
-            int simdBatchSize = Vector<float>.Count / 4; // Number of Vector4 elements per SIMD batch
-            for (; i <= source.Length - simdBatchSize; i += simdBatchSize)
-            {
-                // Load the vector from source span
-                Vector<float> v = Unsafe.ReadUnaligned<Vector<float>>(ref Unsafe.As<Vector4, byte>(ref source[i]));
-
-                // Scale the vector
-                v *= vScale;
-
-                // Write the scaled vector to the destination span
-                Unsafe.WriteUnaligned(ref Unsafe.As<Vector4, byte>(ref destination[i]), v);
-            }
-
-            // Scalar fallback for remaining elements
-            for (; i < source.Length; i++)
-            {
-                destination[i] = source[i] * scale;
-            }
-        }
-        else
-        {
-            // Scalar fallback if SIMD is not supported
-            for (int i = 0; i < source.Length; i++)
-            {
-                destination[i] = source[i] * scale;
-            }
-        }
     }
 
     private class ConversionParams

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -329,22 +329,7 @@ internal static class Numerics
     /// <param name="max">The maximum inclusive value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Clamp(Span<byte> span, byte min, byte max)
-    {
+        => TensorPrimitives_.Clamp(span, min, max, span);
-        Span<byte> remainder = span[ClampReduce(span, min, max)..];
-
-        if (remainder.Length > 0)
-        {
-            ref byte remainderStart = ref MemoryMarshal.GetReference(remainder);
-            ref byte remainderEnd = ref Unsafe.Add(ref remainderStart, (uint)remainder.Length);
-
-            while (Unsafe.IsAddressLessThan(ref remainderStart, ref remainderEnd))
-            {
-                remainderStart = Clamp(remainderStart, min, max);
-
-                remainderStart = ref Unsafe.Add(ref remainderStart, 1);
-            }
-        }
-    }
 
     /// <summary>
     /// Clamps the span values to the inclusive range of min and max.
@@ -354,22 +339,7 @@ internal static class Numerics
     /// <param name="max">The maximum inclusive value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Clamp(Span<uint> span, uint min, uint max)
-    {
+        => TensorPrimitives_.Clamp(span, min, max, span);
-        Span<uint> remainder = span[ClampReduce(span, min, max)..];
-
-        if (remainder.Length > 0)
-        {
-            ref uint remainderStart = ref MemoryMarshal.GetReference(remainder);
-            ref uint remainderEnd = ref Unsafe.Add(ref remainderStart, (uint)remainder.Length);
-
-            while (Unsafe.IsAddressLessThan(ref remainderStart, ref remainderEnd))
-            {
-                remainderStart = Clamp(remainderStart, min, max);
-
-                remainderStart = ref Unsafe.Add(ref remainderStart, 1);
-            }
-        }
-    }
 
     /// <summary>
     /// Clamps the span values to the inclusive range of min and max.
@@ -379,22 +349,7 @@ internal static class Numerics
     /// <param name="max">The maximum inclusive value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Clamp(Span<int> span, int min, int max)
-    {
+        => TensorPrimitives_.Clamp(span, min, max, span);
-        Span<int> remainder = span[ClampReduce(span, min, max)..];
-
-        if (remainder.Length > 0)
-        {
-            ref int remainderStart = ref MemoryMarshal.GetReference(remainder);
-            ref int remainderEnd = ref Unsafe.Add(ref remainderStart, (uint)remainder.Length);
-
-            while (Unsafe.IsAddressLessThan(ref remainderStart, ref remainderEnd))
-            {
-                remainderStart = Clamp(remainderStart, min, max);
-
-                remainderStart = ref Unsafe.Add(ref remainderStart, 1);
-            }
-        }
-    }
 
     /// <summary>
     /// Clamps the span values to the inclusive range of min and max.
@@ -404,22 +359,7 @@ internal static class Numerics
     /// <param name="max">The maximum inclusive value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Clamp(Span<float> span, float min, float max)
-    {
+        => TensorPrimitives_.Clamp(span, min, max, span);
-        Span<float> remainder = span[ClampReduce(span, min, max)..];
-
-        if (remainder.Length > 0)
-        {
-            ref float remainderStart = ref MemoryMarshal.GetReference(remainder);
-            ref float remainderEnd = ref Unsafe.Add(ref remainderStart, (uint)remainder.Length);
-
-            while (Unsafe.IsAddressLessThan(ref remainderStart, ref remainderEnd))
-            {
-                remainderStart = Clamp(remainderStart, min, max);
-
-                remainderStart = ref Unsafe.Add(ref remainderStart, 1);
-            }
-        }
-    }
 
     /// <summary>
     /// Clamps the span values to the inclusive range of min and max.
@@ -429,87 +369,7 @@ internal static class Numerics
     /// <param name="max">The maximum inclusive value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Clamp(Span<double> span, double min, double max)
-    {
+        => TensorPrimitives_.Clamp(span, min, max, span);
-        Span<double> remainder = span[ClampReduce(span, min, max)..];
-
-        if (remainder.Length > 0)
-        {
-            ref double remainderStart = ref MemoryMarshal.GetReference(remainder);
-            ref double remainderEnd = ref Unsafe.Add(ref remainderStart, (uint)remainder.Length);
-
-            while (Unsafe.IsAddressLessThan(ref remainderStart, ref remainderEnd))
-            {
-                remainderStart = Clamp(remainderStart, min, max);
-
-                remainderStart = ref Unsafe.Add(ref remainderStart, 1);
-            }
-        }
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static int ClampReduce<T>(Span<T> span, T min, T max)
-        where T : unmanaged
-    {
-        if (Vector.IsHardwareAccelerated && span.Length >= Vector<T>.Count)
-        {
-            int remainder = ModuloP2(span.Length, Vector<T>.Count);
-            int adjustedCount = span.Length - remainder;
-
-            if (adjustedCount > 0)
-            {
-                ClampImpl(span[..adjustedCount], min, max);
-            }
-
-            return adjustedCount;
-        }
-
-        return 0;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void ClampImpl<T>(Span<T> span, T min, T max)
-        where T : unmanaged
-    {
-        ref T sRef = ref MemoryMarshal.GetReference(span);
-        Vector<T> vmin = new(min);
-        Vector<T> vmax = new(max);
-
-        nint n = (nint)(uint)span.Length / Vector<T>.Count;
-        nint m = Modulo4(n);
-        nint u = n - m;
-
-        ref Vector<T> vs0 = ref Unsafe.As<T, Vector<T>>(ref MemoryMarshal.GetReference(span));
-        ref Vector<T> vs1 = ref Unsafe.Add(ref vs0, 1);
-        ref Vector<T> vs2 = ref Unsafe.Add(ref vs0, 2);
-        ref Vector<T> vs3 = ref Unsafe.Add(ref vs0, 3);
-        ref Vector<T> vsEnd = ref Unsafe.Add(ref vs0, u);
-
-        while (Unsafe.IsAddressLessThan(ref vs0, ref vsEnd))
-        {
-            vs0 = Vector.Min(Vector.Max(vmin, vs0), vmax);
-            vs1 = Vector.Min(Vector.Max(vmin, vs1), vmax);
-            vs2 = Vector.Min(Vector.Max(vmin, vs2), vmax);
-            vs3 = Vector.Min(Vector.Max(vmin, vs3), vmax);
-
-            vs0 = ref Unsafe.Add(ref vs0, 4);
-            vs1 = ref Unsafe.Add(ref vs1, 4);
-            vs2 = ref Unsafe.Add(ref vs2, 4);
-            vs3 = ref Unsafe.Add(ref vs3, 4);
-        }
-
-        if (m > 0)
-        {
-            vs0 = ref vsEnd;
-            vsEnd = ref Unsafe.Add(ref vsEnd, m);
-
-            while (Unsafe.IsAddressLessThan(ref vs0, ref vsEnd))
-            {
-                vs0 = Vector.Min(Vector.Max(vmin, vs0), vmax);
-
-                vs0 = ref Unsafe.Add(ref vs0, 1);
-            }
-        }
-    }
 
     /// <summary>
     /// Pre-multiplies the "x", "y", "z" components of a vector by its "w" component leaving the "w" component intact.
@@ -1210,39 +1070,5 @@ internal static class Numerics
     /// <param name="sum">The sum of the values in <paramref name="span"/>.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Normalize(Span<float> span, float sum)
-    {
+        => TensorPrimitives_.Divide(span, sum, span);
-        if (Vector256.IsHardwareAccelerated)
-        {
-            ref float startRef = ref MemoryMarshal.GetReference(span);
-            ref float endRef = ref Unsafe.Add(ref startRef, span.Length & ~7);
-            Vector256<float> sum256 = Vector256.Create(sum);
-
-            while (Unsafe.IsAddressLessThan(ref startRef, ref endRef))
-            {
-                Unsafe.As<float, Vector256<float>>(ref startRef) /= sum256;
-                startRef = ref Unsafe.Add(ref startRef, (nuint)8);
-            }
-
-            if ((span.Length & 7) >= 4)
-            {
-                Unsafe.As<float, Vector128<float>>(ref startRef) /= sum256.GetLower();
-                startRef = ref Unsafe.Add(ref startRef, (nuint)4);
-            }
-
-            endRef = ref Unsafe.Add(ref startRef, span.Length & 3);
-
-            while (Unsafe.IsAddressLessThan(ref startRef, ref endRef))
-            {
-                startRef /= sum;
-                startRef = ref Unsafe.Add(ref startRef, (nuint)1);
-            }
-        }
-        else
-        {
-            for (int i = 0; i < span.Length; i++)
-            {
-                span[i] /= sum;
-            }
-        }
-    }
 }

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

@@ -1,36 +1,26 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-// The JIT can detect and optimize rotation idioms ROTL (Rotate Left)
+using System.Runtime.Intrinsics;
-// and ROTR (Rotate Right) emitting efficient CPU instructions:
+
-// https://github.com/dotnet/coreclr/pull/1830
 namespace SixLabors.ImageSharp;
 
 /// <summary>
-/// Defines the contract for methods that allow the shuffling of pixel components.
+/// Defines a stateless operation over packed pixel components.
-/// Used for shuffling on platforms that do not support Hardware Intrinsics.
 /// </summary>
 internal interface IComponentShuffle
 {
     /// <summary>
-    /// Shuffles then slices 8-bit integers in <paramref name="source"/>
+    /// Reorders one packed pixel.
-    /// using a byte 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="source">The source components, with the first component in the least-significant byte.</param>
-    /// <param name="destination">The destination span of bytes.</param>
+    /// <returns>The reordered packed components.</returns>
-    void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination);
+    public static abstract uint Invoke(uint source);
 
     /// <summary>
-    /// Shuffle 8-bit integers in <paramref name="source"/>
+    /// Reorders the packed pixels in a 128-bit vector.
-    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
-    /// <param name="source">The source span of bytes.</param>
+    /// <param name="source">The source pixels.</param>
-    /// <param name="destination">The destination span of bytes.</param>
+    /// <returns>The reordered pixels.</returns>
-    /// <remarks>
+    public static abstract Vector128<byte> Invoke(Vector128<byte> source);
-    /// Implementation can assume that source.Length is less or equal than destination.Length.
-    /// Loops should iterate using source.Length.
-    /// </remarks>
-    void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination);
 }

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

@@ -1,99 +1,95 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp;
 
-/// <inheritdoc/>
+/// <summary>
+/// Defines a stateless operation that reorders a three-component pixel after adding opaque alpha.
+/// </summary>
 internal interface IPad3Shuffle4 : IComponentShuffle
 {
 }
 
-internal readonly struct DefaultPad3Shuffle4([ConstantExpected] byte control) : IPad3Shuffle4
+/// <summary>
+/// Preserves XYZ order and appends opaque W.
+/// </summary>
+internal readonly struct XYZWPad3Shuffle4 : IPad3Shuffle4
 {
-    public byte Control { get; } = control;
+    /// <inheritdoc />
-
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source) => source;
-#pragma warning disable CA1857 // A constant is expected for the parameter
-        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref destination, this.Control);
-#pragma warning restore CA1857 // A constant is expected for the parameter
 
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source) => source;
+}
+
+/// <summary>
+/// Reorders padded XYZW components to WXYZ.
+/// </summary>
+internal readonly struct WXYZPad3Shuffle4 : IPad3Shuffle4
+{
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    public static uint Invoke(uint source)
-    {
+
-        ref byte sBase = ref MemoryMarshal.GetReference(source);
+        // The scalar pipeline has already appended opaque W, so the four-component
-        ref byte dBase = ref MemoryMarshal.GetReference(destination);
+        // WXYZ operator performs the complete remaining permutation.
-
+        => WXYZShuffle4.Invoke(source);
-        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
+
-
+    /// <inheritdoc />
-        for (nuint i = 0, j = 0; i < (uint)source.Length; i += 3, j += 4)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        {
+    public static Vector128<byte> Invoke(Vector128<byte> source)
-            // Expanding 3-byte pixels to 4 bytes can overwrite the next source
+
-            // triplet when spans overlap. Assemble the padded pixel first, then
+        // Each four-byte group is an XYZW pixel with opaque W. Selecting [3, 0, 1, 2]
-            // shuffle from the staged uint.
+        // produces WXYZ, and offsets 4, 8, and 12 repeat that rotation for the next pixels.
-            uint packed =
+        => Vector128_.ShuffleNative(source, Vector128.Create((byte)3, 0, 1, 2, 7, 4, 5, 6, 11, 8, 9, 10, 15, 12, 13, 14));
-                Unsafe.Add(ref sBase, i + 0u) |
-                ((uint)Unsafe.Add(ref sBase, i + 1u) << 8) |
-                ((uint)Unsafe.Add(ref sBase, i + 2u) << 16) |
-                0xFF000000;
-
-            ref byte pBase = ref Unsafe.As<uint, byte>(ref packed);
-
-            Unsafe.Add(ref dBase, j + 0u) = Unsafe.Add(ref pBase, p0);
-            Unsafe.Add(ref dBase, j + 1u) = Unsafe.Add(ref pBase, p1);
-            Unsafe.Add(ref dBase, j + 2u) = Unsafe.Add(ref pBase, p2);
-            Unsafe.Add(ref dBase, j + 3u) = Unsafe.Add(ref pBase, p3);
-        }
-    }
 }
 
-internal readonly struct XYZWPad3Shuffle4 : IPad3Shuffle4
+/// <summary>
+/// Reorders padded XYZW components to WZYX.
+/// </summary>
+internal readonly struct WZYXPad3Shuffle4 : IPad3Shuffle4
 {
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source)
-        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle3210);
 
+        // The scalar pipeline has already appended opaque W, so the four-component
+        // WZYX operator performs the complete remaining permutation.
+        => WZYXShuffle4.Invoke(source);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
+
+        // Each four-byte group is an XYZW pixel with opaque W. Selecting [3, 2, 1, 0]
+        // produces WZYX, and offsets 4, 8, and 12 repeat that reversal for the next pixels.
+        => Vector128_.ShuffleNative(source, Vector128.Create((byte)3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12));
+}
+
+/// <summary>
+/// Reorders padded XYZW components to ZYXW.
+/// </summary>
+internal readonly struct ZYXWPad3Shuffle4 : IPad3Shuffle4
+{
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    public static uint Invoke(uint source)
-    {
+
-        ref byte sBase = ref MemoryMarshal.GetReference(source);
+        // The scalar pipeline has already appended opaque W, so the four-component
-        ref byte dBase = ref MemoryMarshal.GetReference(destination);
+        // ZYXW operator performs the complete remaining permutation.
-
+        => ZYXWShuffle4.Invoke(source);
-        ref byte sEnd = ref Unsafe.Add(ref sBase, (uint)source.Length);
+
-        ref byte sLoopEnd = ref Unsafe.Subtract(ref sEnd, 4);
+    /// <inheritdoc />
-
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        while (Unsafe.IsAddressLessThan(ref sBase, ref sLoopEnd))
+    public static Vector128<byte> Invoke(Vector128<byte> source)
-        {
+
-            // The fast scalar path reads one extra byte past the source triplet.
+        // Each four-byte group is an XYZW pixel with opaque W. Selecting [2, 1, 0, 3]
-            // Keep that widened read in a local before writing the expanded pixel
+        // exchanges X and Z to produce ZYXW, with offsets 4, 8, and 12 covering the next pixels.
-            // so overlapping destinations cannot change what was read.
+        => Vector128_.ShuffleNative(source, Vector128.Create((byte)2, 1, 0, 3, 6, 5, 4, 7, 10, 9, 8, 11, 14, 13, 12, 15));
-            uint packed = Unsafe.As<byte, uint>(ref sBase) | 0xFF000000;
-
-            Unsafe.As<byte, uint>(ref dBase) = packed;
-
-            sBase = ref Unsafe.Add(ref sBase, 3);
-            dBase = ref Unsafe.Add(ref dBase, 4);
-        }
-
-        while (Unsafe.IsAddressLessThan(ref sBase, ref sEnd))
-        {
-            // The final triplet cannot use the widened read above, so assemble
-            // the same padded uint byte-by-byte before the overlapping store.
-            uint packed =
-                Unsafe.Add(ref sBase, 0u) |
-                ((uint)Unsafe.Add(ref sBase, 1u) << 8) |
-                ((uint)Unsafe.Add(ref sBase, 2u) << 16) |
-                0xFF000000;
-
-            Unsafe.As<byte, uint>(ref dBase) = packed;
-
-            sBase = ref Unsafe.Add(ref sBase, 3);
-            dBase = ref Unsafe.Add(ref dBase, 4);
-        }
-    }
 }

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

@@ -1,51 +1,38 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp;
 
-/// <inheritdoc/>
+/// <summary>
+/// Identifies a stateless three-component shuffle operator.
+/// </summary>
 internal interface IShuffle3 : IComponentShuffle
 {
 }
 
-internal readonly struct DefaultShuffle3([ConstantExpected] byte control) : IShuffle3
+/// <summary>
+/// Reorders XYZ components to ZYX.
+/// </summary>
+internal readonly struct ZYXShuffle3 : IShuffle3
 {
-    public byte Control { get; } = control;
+    /// <inheritdoc />
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
-#pragma warning disable CA1857 // A constant is expected for the parameter
-        => HwIntrinsics.Shuffle3Reduce(ref source, ref destination, this.Control);
-#pragma warning restore CA1857 // A constant is expected for the parameter
-
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    public static uint Invoke(uint source)
-    {
-        ref byte sBase = ref MemoryMarshal.GetReference(source);
-        ref byte dBase = ref MemoryMarshal.GetReference(destination);
-
-        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)
+        // The scalar tail is staged as XYZW with an unused W byte. Reusing the four-component
-        {
+        // ZYXW operator produces ZYX in the low three bytes consumed by the caller.
-            // The scalar remainder can run in-place after the vector body. Load
+        => ZYXWShuffle4.Invoke(source);
-            // the full 3-byte pixel into a register-sized value before stores so
-            // channel swaps cannot corrupt later reads from the same pixel.
-            uint packed =
-                Unsafe.Add(ref sBase, i + 0u) |
-                ((uint)Unsafe.Add(ref sBase, i + 1u) << 8) |
-                ((uint)Unsafe.Add(ref sBase, i + 2u) << 16);
 
-            ref byte pBase = ref Unsafe.As<uint, byte>(ref packed);
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
 
-            Unsafe.Add(ref dBase, i + 0u) = Unsafe.Add(ref pBase, p0);
+        // Each four-byte group is a temporary XYZW pixel created by the shuffle pipeline.
-            Unsafe.Add(ref dBase, i + 1u) = Unsafe.Add(ref pBase, p1);
+        // Selecting [2, 1, 0, 3] produces ZYXW, and offsets 4, 8, and 12 repeat that
-            Unsafe.Add(ref dBase, i + 2u) = Unsafe.Add(ref pBase, p2);
+        // permutation for the next pixels. The pipeline subsequently discards every W byte.
-        }
+        => Vector128_.ShuffleNative(source, Vector128.Create((byte)2, 1, 0, 3, 6, 5, 4, 7, 10, 9, 8, 11, 14, 13, 12, 15));
-    }
 }

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

@@ -2,183 +2,287 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers.Binary;
-using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp;
 
-/// <inheritdoc/>
+/// <summary>
+/// Defines a stateless operation over one packed four-component pixel.
+/// </summary>
 internal interface IShuffle4 : IComponentShuffle
 {
-}
+    /// <summary>
-
+    /// Reorders the packed pixels in a 256-bit vector.
-internal readonly struct DefaultShuffle4([ConstantExpected] byte control) : IShuffle4
+    /// </summary>
-{
+    /// <param name="source">The source pixels.</param>
-    public byte Control { get; } = control;
+    /// <returns>The reordered pixels.</returns>
+    public static abstract Vector256<byte> Invoke(Vector256<byte> source);
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+    /// <summary>
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    /// Reorders the packed pixels in a 512-bit vector.
-#pragma warning disable CA1857 // A constant is expected for the parameter
+    /// </summary>
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, this.Control);
+    /// <param name="source">The source pixels.</param>
-#pragma warning restore CA1857 // A constant is expected for the parameter
+    /// <returns>The reordered pixels.</returns>
+    public static abstract Vector512<byte> Invoke(Vector512<byte> source);
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+    /// <summary>
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    /// Expands one 128-bit lane mask into absolute indices for a 512-bit shuffle.
+    /// </summary>
+    /// <param name="laneMask">The indices, from zero through fifteen, for one 128-bit lane.</param>
+    /// <returns>The corresponding absolute indices for all four 128-bit lanes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> ExpandLaneMask(Vector128<byte> laneMask)
     {
-        ref byte sBase = ref MemoryMarshal.GetReference(source);
+        // A 512-bit vector contains four 128-bit lanes, and each lane contains four packed
-        ref byte dBase = ref MemoryMarshal.GetReference(destination);
+        // XYZW pixels. The supplied mask addresses bytes 0..15 in the first lane. The managed
-
+        // Vector512.Shuffle fallback addresses the complete 64-byte vector, so the same
-        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
+        // permutation must address bytes 16..31, 32..47, and 48..63 in the remaining lanes.
-
+        //
-        for (nuint i = 0; i < (uint)source.Length; i += 4)
+        // AVX-512BW VPSHUFB instead interprets indices independently within each 128-bit lane
-        {
+        // and uses only the low four bits to select a byte. Adding the lane offsets therefore
-            // The generic path may be used with source and destination pointing
+        // satisfies the managed absolute-index contract without changing the native lane-local
-            // at the same pixel. Load all channels first so subsequent stores
+        // permutation.
-            // index only staged bytes, matching the specialized uint shuffles.
+        Vector128<byte> lane1 = laneMask + Vector128.Create((byte)16);
-            uint packed = Unsafe.As<byte, uint>(ref Unsafe.Add(ref sBase, i));
+        Vector128<byte> lane2 = laneMask + Vector128.Create((byte)32);
-            ref byte pBase = ref Unsafe.As<uint, byte>(ref packed);
+        Vector128<byte> lane3 = laneMask + Vector128.Create((byte)48);
-
+
-            Unsafe.Add(ref dBase, i + 0u) = Unsafe.Add(ref pBase, p0);
+        return Vector512.Create(Vector256.Create(laneMask, lane1), Vector256.Create(lane2, lane3));
-            Unsafe.Add(ref dBase, i + 1u) = Unsafe.Add(ref pBase, p1);
-            Unsafe.Add(ref dBase, i + 2u) = Unsafe.Add(ref pBase, p2);
-            Unsafe.Add(ref dBase, i + 3u) = Unsafe.Add(ref pBase, p3);
-        }
     }
 }
 
+/// <summary>
+/// Reorders XYZW components to WXYZ.
+/// </summary>
 internal readonly struct WXYZShuffle4 : IShuffle4
 {
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle2103);
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+        // source          = [W Z Y X]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+        // ROTL(8, source) = [Z Y X W]
+        => BitOperations.RotateLeft(source, 8);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
+        => Vector128_.ShuffleNative(source, CreateLaneMask());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> Invoke(Vector256<byte> source)
     {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        // AVX2 byte shuffles select within 128-bit lanes, so both halves use the same pixel-local indices.
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        Vector128<byte> mask = CreateLaneMask();
-        uint n = (uint)source.Length / 4;
+        return Vector256_.ShufflePerLane(source, Vector256.Create(mask, mask));
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed          = [W Z Y X]
-            // ROTL(8, packed) = [Z Y X W]
-            Unsafe.Add(ref dBase, i) = (packed << 8) | (packed >> 24);
-        }
     }
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> Invoke(Vector512<byte> source)
+
+        // Expand the four-pixel lane permutation across all four 128-bit lanes.
+        => Vector512_.ShuffleNative(source, IShuffle4.ExpandLaneMask(CreateLaneMask()));
+
+    /// <summary>
+    /// Creates the indices that rotate each XYZW pixel to WXYZ within one 128-bit lane.
+    /// </summary>
+    /// <returns>The pixel-local byte shuffle indices.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<byte> CreateLaneMask()
+
+        // Each four-byte group is one XYZW pixel. Selecting [3, 0, 1, 2] produces
+        // WXYZ, and offsets 4, 8, and 12 repeat that permutation for the next pixels.
+        => Vector128.Create((byte)3, 0, 1, 2, 7, 4, 5, 6, 11, 8, 9, 10, 15, 12, 13, 14);
 }
 
+/// <summary>
+/// Reorders XYZW components to WZYX.
+/// </summary>
 internal readonly struct WZYXShuffle4 : IShuffle4
 {
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle0123);
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+        // source          = [W Z Y X]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+        // REVERSE(source) = [X Y Z W]
+        => BinaryPrimitives.ReverseEndianness(source);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
+        => Vector128_.ShuffleNative(source, CreateLaneMask());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> Invoke(Vector256<byte> source)
     {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        // AVX2 byte shuffles select within 128-bit lanes, so both halves use the same pixel-local indices.
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        Vector128<byte> mask = CreateLaneMask();
-        uint n = (uint)source.Length / 4;
+        return Vector256_.ShufflePerLane(source, Vector256.Create(mask, mask));
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // REVERSE(packedArgb) = [X Y Z W]
-            Unsafe.Add(ref dBase, i) = BinaryPrimitives.ReverseEndianness(packed);
-        }
     }
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> Invoke(Vector512<byte> source)
+
+        // Expand the four-pixel lane permutation across all four 128-bit lanes.
+        => Vector512_.ShuffleNative(source, IShuffle4.ExpandLaneMask(CreateLaneMask()));
+
+    /// <summary>
+    /// Creates the indices that reverse each XYZW pixel to WZYX within one 128-bit lane.
+    /// </summary>
+    /// <returns>The pixel-local byte shuffle indices.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<byte> CreateLaneMask()
+
+        // Each four-byte group is one XYZW pixel. Selecting [3, 2, 1, 0] produces
+        // WZYX, and offsets 4, 8, and 12 repeat that reversal for the next pixels.
+        => Vector128.Create((byte)3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
 }
 
+/// <summary>
+/// Reorders XYZW components to YZWX.
+/// </summary>
 internal readonly struct YZWXShuffle4 : IShuffle4
 {
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle0321);
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+        // source          = [W Z Y X]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+        // ROTR(8, source) = [X W Z Y]
+        => BitOperations.RotateRight(source, 8);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
+        => Vector128_.ShuffleNative(source, CreateLaneMask());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> Invoke(Vector256<byte> source)
     {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        // AVX2 byte shuffles select within 128-bit lanes, so both halves use the same pixel-local indices.
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        Vector128<byte> mask = CreateLaneMask();
-        uint n = (uint)source.Length / 4;
+        return Vector256_.ShufflePerLane(source, Vector256.Create(mask, mask));
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // ROTR(8, packedArgb) = [Y Z W X]
-            Unsafe.Add(ref dBase, i) = BitOperations.RotateRight(packed, 8);
-        }
     }
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> Invoke(Vector512<byte> source)
+
+        // Expand the four-pixel lane permutation across all four 128-bit lanes.
+        => Vector512_.ShuffleNative(source, IShuffle4.ExpandLaneMask(CreateLaneMask()));
+
+    /// <summary>
+    /// Creates the indices that rotate each XYZW pixel to YZWX within one 128-bit lane.
+    /// </summary>
+    /// <returns>The pixel-local byte shuffle indices.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<byte> CreateLaneMask()
+
+        // Each four-byte group is one XYZW pixel. Selecting [1, 2, 3, 0] produces
+        // YZWX, and offsets 4, 8, and 12 repeat that rotation for the next pixels.
+        => Vector128.Create((byte)1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12);
 }
 
+/// <summary>
+/// Reorders XYZW components to ZYXW.
+/// </summary>
 internal readonly struct ZYXWShuffle4 : IShuffle4
 {
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle3012);
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+        // source                     = [W Z Y X]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+        // source & 0xFF00FF00        = [W 0 Y 0]
+        // ROTL(source & 0x00FF00FF)  = [0 X 0 Z]
+        // combined                   = [W X Y Z]
+        => (source & 0xFF00FF00) | BitOperations.RotateLeft(source & 0x00FF00FF, 16);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
+        => Vector128_.ShuffleNative(source, CreateLaneMask());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> Invoke(Vector256<byte> source)
     {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        // AVX2 byte shuffles select within 128-bit lanes, so both halves use the same pixel-local indices.
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        Vector128<byte> mask = CreateLaneMask();
-        uint n = (uint)source.Length / 4;
+        return Vector256_.ShufflePerLane(source, Vector256.Create(mask, mask));
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // tmp1                = [W 0 Y 0]
-            // tmp2                = [0 Z 0 X]
-            // tmp3=ROTL(16, tmp2) = [0 X 0 Z]
-            // tmp1 + tmp3         = [W X Y Z]
-            uint tmp1 = packed & 0xFF00FF00;
-            uint tmp2 = packed & 0x00FF00FF;
-            uint tmp3 = BitOperations.RotateLeft(tmp2, 16);
-
-            Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
-        }
     }
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> Invoke(Vector512<byte> source)
+
+        // Expand the four-pixel lane permutation across all four 128-bit lanes.
+        => Vector512_.ShuffleNative(source, IShuffle4.ExpandLaneMask(CreateLaneMask()));
+
+    /// <summary>
+    /// Creates the indices that exchange X and Z in each XYZW pixel within one 128-bit lane.
+    /// </summary>
+    /// <returns>The pixel-local byte shuffle indices.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<byte> CreateLaneMask()
+
+        // Each four-byte group is one XYZW pixel. Selecting [2, 1, 0, 3] exchanges
+        // X and Z to produce ZYXW, with offsets 4, 8, and 12 covering the next pixels.
+        => Vector128.Create((byte)2, 1, 0, 3, 6, 5, 4, 7, 10, 9, 8, 11, 14, 13, 12, 15);
 }
 
+/// <summary>
+/// Reorders XYZW components to XWZY.
+/// </summary>
 internal readonly struct XWZYShuffle4 : IShuffle4
 {
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle1230);
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+        // source                     = [W Z Y X]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+        // source & 0x00FF00FF        = [0 Z 0 X]
+        // ROTL(source & 0xFF00FF00)  = [Y 0 W 0]
+        // combined                   = [Y Z W X]
+        => (source & 0x00FF00FF) | BitOperations.RotateLeft(source & 0xFF00FF00, 16);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
+        => Vector128_.ShuffleNative(source, CreateLaneMask());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> Invoke(Vector256<byte> source)
     {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        // AVX2 byte shuffles select within 128-bit lanes, so both halves use the same pixel-local indices.
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        Vector128<byte> mask = CreateLaneMask();
-        uint n = (uint)source.Length / 4;
+        return Vector256_.ShufflePerLane(source, Vector256.Create(mask, mask));
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // tmp1                = [0 Z 0 X]
-            // tmp2                = [W 0 Y 0]
-            // tmp3=ROTL(16, tmp2) = [Y 0 W 0]
-            // tmp1 + tmp3         = [Y Z W X]
-            uint tmp1 = packed & 0x00FF00FF;
-            uint tmp2 = packed & 0xFF00FF00;
-            uint tmp3 = BitOperations.RotateLeft(tmp2, 16);
-
-            Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
-        }
     }
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> Invoke(Vector512<byte> source)
+
+        // Expand the four-pixel lane permutation across all four 128-bit lanes.
+        => Vector512_.ShuffleNative(source, IShuffle4.ExpandLaneMask(CreateLaneMask()));
+
+    /// <summary>
+    /// Creates the indices that exchange Y and W in each XYZW pixel within one 128-bit lane.
+    /// </summary>
+    /// <returns>The pixel-local byte shuffle indices.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<byte> CreateLaneMask()
+
+        // Each four-byte group is one XYZW pixel. Selecting [0, 3, 2, 1] exchanges
+        // Y and W to produce XWZY, with offsets 4, 8, and 12 covering the next pixels.
+        => Vector128.Create((byte)0, 3, 2, 1, 4, 7, 6, 5, 8, 11, 10, 9, 12, 15, 14, 13);
 }

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

@@ -1,103 +1,106 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using static SixLabors.ImageSharp.SimdUtils;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp;
 
-/// <inheritdoc/>
+/// <summary>
+/// Defines a stateless operation that reorders four packed components before retaining three.
+/// </summary>
 internal interface IShuffle4Slice3 : IComponentShuffle
 {
 }
 
-internal readonly struct DefaultShuffle4Slice3([ConstantExpected] byte control) : IShuffle4Slice3
+/// <summary>
+/// Preserves XYZ order and discards W.
+/// </summary>
+internal readonly struct XYZWShuffle4Slice3 : IShuffle4Slice3
 {
-    public byte Control { get; } = control;
+    /// <inheritdoc />
-
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source) => source;
-#pragma warning disable CA1857 // A constant is expected for the parameter
-        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref destination, this.Control);
-#pragma warning restore CA1857 // A constant is expected for the parameter
 
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source) => source;
+}
+
+/// <summary>
+/// Reorders XYZW components to YZW before discarding X.
+/// </summary>
+internal readonly struct YZWXShuffle4Slice3 : IShuffle4Slice3
+{
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    public static uint Invoke(uint source)
-    {
+
-        ref byte sBase = ref MemoryMarshal.GetReference(source);
+        // Reuse the four-component rotation; the caller stores only the low YZW
-        ref byte dBase = ref MemoryMarshal.GetReference(destination);
+        // bytes and therefore discards the rotated X byte.
-
+        => YZWXShuffle4.Invoke(source);
-        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
+
-
+    /// <inheritdoc />
-        for (nuint i = 0, j = 0; i < (uint)destination.Length; i += 3, j += 4)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        {
+    public static Vector128<byte> Invoke(Vector128<byte> source)
-            // Shrinking 4-byte pixels to 3 bytes can still be called in-place by
+
-            // tail code. Read the complete source pixel first, then write only
+        // Each four-byte group is an XYZW pixel. Selecting [1, 2, 3, 0] produces
-            // the requested channels into the destination triplet.
+        // YZWX, and offsets 4, 8, and 12 repeat that rotation for the next pixels.
-            uint packed = Unsafe.As<byte, uint>(ref Unsafe.Add(ref sBase, j));
+        // The surrounding pipeline subsequently removes every fourth byte.
-            ref byte pBase = ref Unsafe.As<uint, byte>(ref packed);
+        => Vector128_.ShuffleNative(source, Vector128.Create((byte)1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12));
-
-            Unsafe.Add(ref dBase, i + 0u) = Unsafe.Add(ref pBase, p0);
-            Unsafe.Add(ref dBase, i + 1u) = Unsafe.Add(ref pBase, p1);
-            Unsafe.Add(ref dBase, i + 2u) = Unsafe.Add(ref pBase, p2);
-        }
-    }
 }
 
-internal readonly struct XYZWShuffle4Slice3 : IShuffle4Slice3
+/// <summary>
+/// Reorders XYZW components to WZY before discarding X.
+/// </summary>
+internal readonly struct WZYXShuffle4Slice3 : IShuffle4Slice3
 {
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+    public static uint Invoke(uint source)
-        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle3210);
 
+        // Reuse the four-component reversal; the caller stores only the low WZY
+        // bytes and therefore discards the reversed X byte.
+        => WZYXShuffle4.Invoke(source);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Invoke(Vector128<byte> source)
+
+        // Each four-byte group is an XYZW pixel. Selecting [3, 2, 1, 0] produces
+        // WZYX, and offsets 4, 8, and 12 repeat that reversal for the next pixels.
+        // The surrounding pipeline subsequently removes every fourth byte.
+        => Vector128_.ShuffleNative(source, Vector128.Create((byte)3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12));
+}
+
+/// <summary>
+/// Reorders XYZW components to ZYX before discarding W.
+/// </summary>
+internal readonly struct ZYXWShuffle4Slice3 : IShuffle4Slice3
+{
+    /// <inheritdoc />
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    public static uint Invoke(uint source)
-    {
+
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        // Reuse the four-component exchange; the caller stores only the low ZYX
-        ref Byte3 dBase = ref Unsafe.As<byte, Byte3>(ref MemoryMarshal.GetReference(destination));
+        // bytes and therefore discards the preserved W byte.
-
+        => ZYXWShuffle4.Invoke(source);
-        nint n = (nint)(uint)source.Length / 4;
+
-        nint m = Numerics.Modulo4(n);
+    /// <inheritdoc />
-        nint u = n - m;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
+    public static Vector128<byte> Invoke(Vector128<byte> source)
-        ref uint sLoopEnd = ref Unsafe.Add(ref sBase, u);
+
-        ref uint sEnd = ref Unsafe.Add(ref sBase, n);
+        // Each four-byte group is an XYZW pixel. Selecting [2, 1, 0, 3] produces
-
+        // ZYXW, and offsets 4, 8, and 12 repeat that exchange for the next pixels.
-        while (Unsafe.IsAddressLessThan(ref sBase, ref sLoopEnd))
+        // The surrounding pipeline subsequently removes every fourth byte.
-        {
+        => Vector128_.ShuffleNative(source, Vector128.Create((byte)2, 1, 0, 3, 6, 5, 4, 7, 10, 9, 8, 11, 14, 13, 12, 15));
-            // Stage the four source pixels before the 3-byte stores. Even
-            // though this path preserves XYZ order, the packed loads must happen
-            // before destination writes when the spans overlap.
-            uint packed0 = Unsafe.Add(ref sBase, 0u);
-            uint packed1 = Unsafe.Add(ref sBase, 1u);
-            uint packed2 = Unsafe.Add(ref sBase, 2u);
-            uint packed3 = Unsafe.Add(ref sBase, 3u);
-
-            Unsafe.Add(ref dBase, 0u) = Unsafe.As<uint, Byte3>(ref packed0);
-            Unsafe.Add(ref dBase, 1u) = Unsafe.As<uint, Byte3>(ref packed1);
-            Unsafe.Add(ref dBase, 2u) = Unsafe.As<uint, Byte3>(ref packed2);
-            Unsafe.Add(ref dBase, 3u) = Unsafe.As<uint, Byte3>(ref packed3);
-
-            sBase = ref Unsafe.Add(ref sBase, 4);
-            dBase = ref Unsafe.Add(ref dBase, 4);
-        }
-
-        while (Unsafe.IsAddressLessThan(ref sBase, ref sEnd))
-        {
-            // Same overlap rule as the unrolled loop: take the 4-byte source
-            // pixel before storing the 3-byte destination value.
-            uint packed = Unsafe.Add(ref sBase, 0u);
-
-            Unsafe.Add(ref dBase, 0u) = Unsafe.As<uint, Byte3>(ref packed);
-
-            sBase = ref Unsafe.Add(ref sBase, 1);
-            dBase = ref Unsafe.Add(ref dBase, 1);
-        }
-    }
 }
 
+/// <summary>
+/// Represents one tightly packed three-byte value for scalar four-to-three component writes.
+/// </summary>
 [StructLayout(LayoutKind.Explicit, Size = 3)]
 internal readonly struct Byte3
 {

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

@@ -6,6 +6,8 @@ using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp;
 
@@ -42,22 +44,89 @@ internal static partial class SimdUtils
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source 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> destination,
+        Span<byte> destination)
-        TShuffle shuffle)
         where TShuffle : struct, IShuffle4
     {
         VerifyShuffle4SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref destination);
+        ref byte sourceBase = ref MemoryMarshal.GetReference(source);
+        ref byte destinationBase = ref MemoryMarshal.GetReference(destination);
+        int length = source.Length;
+        int i = 0;
 
-        // Deal with the remainder:
+        // The same offset flows through descending widths. This keeps a single traversal while
-        if (source.Length > 0)
+        // allowing a row that is not a multiple of the widest register to retain a vectorized tail.
+        if (Vector512.IsHardwareAccelerated)
+        {
+            int fourVectorsFromEnd = length - (Vector512<byte>.Count * 4);
+
+            for (; i <= fourVectorsFromEnd; i += Vector512<byte>.Count * 4)
+            {
+                // Four independent vectors amortize loop control and expose enough work for the CPU
+                // to overlap loads, byte shuffles, and stores without changing pixel ordering.
+                TShuffle.Invoke(Vector512.LoadUnsafe(ref sourceBase, (nuint)i)).StoreUnsafe(ref destinationBase, (nuint)i);
+                TShuffle.Invoke(Vector512.LoadUnsafe(ref sourceBase, (nuint)(i + Vector512<byte>.Count))).StoreUnsafe(ref destinationBase, (nuint)(i + Vector512<byte>.Count));
+                TShuffle.Invoke(Vector512.LoadUnsafe(ref sourceBase, (nuint)(i + (Vector512<byte>.Count * 2)))).StoreUnsafe(ref destinationBase, (nuint)(i + (Vector512<byte>.Count * 2)));
+                TShuffle.Invoke(Vector512.LoadUnsafe(ref sourceBase, (nuint)(i + (Vector512<byte>.Count * 3)))).StoreUnsafe(ref destinationBase, (nuint)(i + (Vector512<byte>.Count * 3)));
+            }
+
+            int oneVectorFromEnd = length - Vector512<byte>.Count;
+
+            for (; i <= oneVectorFromEnd; i += Vector512<byte>.Count)
+            {
+                TShuffle.Invoke(Vector512.LoadUnsafe(ref sourceBase, (nuint)i)).StoreUnsafe(ref destinationBase, (nuint)i);
+            }
+        }
+
+        if (Vector256.IsHardwareAccelerated)
+        {
+            int fourVectorsFromEnd = length - (Vector256<byte>.Count * 4);
+
+            for (; i <= fourVectorsFromEnd; i += Vector256<byte>.Count * 4)
+            {
+                TShuffle.Invoke(Vector256.LoadUnsafe(ref sourceBase, (nuint)i)).StoreUnsafe(ref destinationBase, (nuint)i);
+                TShuffle.Invoke(Vector256.LoadUnsafe(ref sourceBase, (nuint)(i + Vector256<byte>.Count))).StoreUnsafe(ref destinationBase, (nuint)(i + Vector256<byte>.Count));
+                TShuffle.Invoke(Vector256.LoadUnsafe(ref sourceBase, (nuint)(i + (Vector256<byte>.Count * 2)))).StoreUnsafe(ref destinationBase, (nuint)(i + (Vector256<byte>.Count * 2)));
+                TShuffle.Invoke(Vector256.LoadUnsafe(ref sourceBase, (nuint)(i + (Vector256<byte>.Count * 3)))).StoreUnsafe(ref destinationBase, (nuint)(i + (Vector256<byte>.Count * 3)));
+            }
+
+            int oneVectorFromEnd = length - Vector256<byte>.Count;
+
+            for (; i <= oneVectorFromEnd; i += Vector256<byte>.Count)
+            {
+                TShuffle.Invoke(Vector256.LoadUnsafe(ref sourceBase, (nuint)i)).StoreUnsafe(ref destinationBase, (nuint)i);
+            }
+        }
+
+        if (Vector128.IsHardwareAccelerated)
         {
-            shuffle.Shuffle(source, destination);
+            int fourVectorsFromEnd = length - (Vector128<byte>.Count * 4);
+
+            for (; i <= fourVectorsFromEnd; i += Vector128<byte>.Count * 4)
+            {
+                TShuffle.Invoke(Vector128.LoadUnsafe(ref sourceBase, (nuint)i)).StoreUnsafe(ref destinationBase, (nuint)i);
+                TShuffle.Invoke(Vector128.LoadUnsafe(ref sourceBase, (nuint)(i + Vector128<byte>.Count))).StoreUnsafe(ref destinationBase, (nuint)(i + Vector128<byte>.Count));
+                TShuffle.Invoke(Vector128.LoadUnsafe(ref sourceBase, (nuint)(i + (Vector128<byte>.Count * 2)))).StoreUnsafe(ref destinationBase, (nuint)(i + (Vector128<byte>.Count * 2)));
+                TShuffle.Invoke(Vector128.LoadUnsafe(ref sourceBase, (nuint)(i + (Vector128<byte>.Count * 3)))).StoreUnsafe(ref destinationBase, (nuint)(i + (Vector128<byte>.Count * 3)));
+            }
+
+            int oneVectorFromEnd = length - Vector128<byte>.Count;
+
+            for (; i <= oneVectorFromEnd; i += Vector128<byte>.Count)
+            {
+                TShuffle.Invoke(Vector128.LoadUnsafe(ref sourceBase, (nuint)i)).StoreUnsafe(ref destinationBase, (nuint)i);
+            }
+        }
+
+        // The vector cascade leaves fewer than four pixels. A full uint load keeps each pixel
+        // in a register while the closed operator resolves to its rotate, reverse, or mask sequence.
+        for (; i < length; i += 4)
+        {
+            uint packed = Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)i));
+            Unsafe.As<byte, uint>(ref Unsafe.Add(ref destinationBase, (nuint)i)) = TShuffle.Invoke(packed);
         }
     }
 
@@ -68,23 +137,114 @@ internal static partial class SimdUtils
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source 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> destination,
+        Span<byte> destination)
-        TShuffle shuffle)
         where TShuffle : struct, IShuffle3
     {
-        // Source length should be smaller than destination length, and divisible by 3.
         VerifyShuffle3SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref destination);
+        ref byte sourceBase = ref MemoryMarshal.GetReference(source);
+        ref byte destinationBase = ref MemoryMarshal.GetReference(destination);
+        int length = source.Length;
+        int i = 0;
 
-        // Deal with the remainder:
+        if (Vector128.IsHardwareAccelerated)
-        if (source.Length > 0)
+        {
+            // Each group contains sixteen XYZ pixels in three registers. For a register beginning
+            // [X0,Y0,Z0,X1,Y1,Z1,...], the indices [0,1,2,0x80,3,4,5,0x80,...]
+            // produce four [X,Y,Z,0] pixels. Index 0x80 selects zero on the native byte-shuffle
+            // instructions and on the portable helper, creating a temporary W lane for TShuffle.
+            Vector128<byte> padMask = Vector128.Create((byte)0, 1, 2, 0x80, 3, 4, 5, 0x80, 6, 7, 8, 0x80, 9, 10, 11, 0x80);
+
+            // After TShuffle places the retained components in bytes 0..2 of each four-byte pixel,
+            // [0,1,2,4,5,6,8,9,10,12,13,14] packs four triplets into twelve bytes. Rotating that
+            // mask by twelve positions moves the packed bytes four positions right. Alternating the
+            // two alignments lets AlignRight stitch four twelve-byte results into three full registers.
+            Vector128<byte> sliceMask = Vector128.Create((byte)0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 0x80, 0x80, 0x80, 0x80);
+            Vector128<byte> sliceEndMask = Vector128_.AlignRight(sliceMask, sliceMask, 12);
+            ref Vector128<byte> sourceVectors = ref Unsafe.As<byte, Vector128<byte>>(ref sourceBase);
+            ref Vector128<byte> destinationVectors = ref Unsafe.As<byte, Vector128<byte>>(ref destinationBase);
+            nuint sourceVectorCount = (uint)length / (uint)Vector128<byte>.Count;
+            nuint vectorIndex = 0;
+
+            for (; vectorIndex + 2 < sourceVectorCount; vectorIndex += 3)
+            {
+                // Realign the three source registers into four registers holding four complete
+                // triplets apiece. All source registers are captured before any destination store.
+                ref Vector128<byte> source0 = ref Unsafe.Add(ref sourceVectors, vectorIndex);
+                Vector128<byte> v0 = source0;
+                Vector128<byte> v1 = Unsafe.Add(ref source0, 1);
+                Vector128<byte> v2 = Unsafe.Add(ref source0, 2);
+                Vector128<byte> v3 = Vector128_.ShiftRightBytesInVector(v2, 4);
+
+                v2 = Vector128_.AlignRight(v2, v1, 8);
+                v1 = Vector128_.AlignRight(v1, v0, 12);
+
+                v0 = TShuffle.Invoke(Vector128_.ShuffleNative(v0, padMask));
+                v1 = TShuffle.Invoke(Vector128_.ShuffleNative(v1, padMask));
+                v2 = TShuffle.Invoke(Vector128_.ShuffleNative(v2, padMask));
+                v3 = TShuffle.Invoke(Vector128_.ShuffleNative(v3, padMask));
+
+                v0 = Vector128_.ShuffleNative(v0, sliceEndMask);
+                v1 = Vector128_.ShuffleNative(v1, sliceMask);
+                v2 = Vector128_.ShuffleNative(v2, sliceEndMask);
+                v3 = Vector128_.ShuffleNative(v3, sliceMask);
+
+                Vector128<byte> destination0 = Vector128_.AlignRight(v1, v0, 4);
+                Vector128<byte> destination2 = Vector128_.AlignRight(v3, v2, 12);
+                v1 = Vector128_.ShiftLeftBytesInVector(v1, 4);
+                v2 = Vector128_.ShiftRightBytesInVector(v2, 4);
+                Vector128<byte> destination1 = Vector128_.AlignRight(v2, v1, 8);
+
+                ref Vector128<byte> destination0Ref = ref Unsafe.Add(ref destinationVectors, vectorIndex);
+                destination0Ref = destination0;
+                Unsafe.Add(ref destination0Ref, 1) = destination1;
+                Unsafe.Add(ref destination0Ref, 2) = destination2;
+            }
+
+            i = (int)(vectorIndex * (uint)Vector128<byte>.Count);
+            int oneTailVectorFromEnd = length - Vector128<byte>.Count;
+
+            for (; i <= oneTailVectorFromEnd; i += 12)
+            {
+                // A single readable register contains four complete triplets plus four bytes from
+                // the following pixels. The pad mask ignores those extra bytes before the operator
+                // runs, and the slice mask packs the four results into the low twelve bytes.
+                Vector128<byte> result = Vector128.LoadUnsafe(ref sourceBase, (nuint)i);
+                result = Vector128_.ShuffleNative(result, padMask);
+                result = TShuffle.Invoke(result);
+                result = Vector128_.ShuffleNative(result, sliceMask);
+
+                // Store exactly twelve bytes so an in-place shuffle does not overwrite the next
+                // source triplet captured by the following iteration.
+                Unsafe.As<byte, Vector64<byte>>(ref Unsafe.Add(ref destinationBase, (nuint)i)) = result.GetLower();
+                Unsafe.As<byte, uint>(ref Unsafe.Add(ref destinationBase, (nuint)(i + 8))) = result.AsUInt32().GetElement(2);
+            }
+        }
+
+        int widenedReadEnd = length - 3;
+
+        for (; i < widenedReadEnd; i += 3)
         {
-            shuffle.Shuffle(source, destination);
+            // The fourth byte belongs to the following pixel, but the operator only contributes the
+            // low three result bytes. This unaligned read replaces three dependent byte loads safely.
+            uint packed = Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)i));
+            uint shuffled = TShuffle.Invoke(packed);
+            Unsafe.As<byte, Byte3>(ref Unsafe.Add(ref destinationBase, (nuint)i)) = Unsafe.As<uint, Byte3>(ref shuffled);
+        }
+
+        if (i < length)
+        {
+            // The final triplet has no fourth readable byte, so construct only this terminal pixel.
+            uint packed =
+                Unsafe.Add(ref sourceBase, (nuint)i) |
+                ((uint)Unsafe.Add(ref sourceBase, (nuint)(i + 1)) << 8) |
+                ((uint)Unsafe.Add(ref sourceBase, (nuint)(i + 2)) << 16);
+
+            uint shuffled = TShuffle.Invoke(packed);
+            Unsafe.As<byte, Byte3>(ref Unsafe.Add(ref destinationBase, (nuint)i)) = Unsafe.As<uint, Byte3>(ref shuffled);
         }
     }
 
@@ -95,22 +255,81 @@ internal static partial class SimdUtils
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source 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> destination,
+        Span<byte> destination)
-        TShuffle shuffle)
         where TShuffle : struct, IPad3Shuffle4
     {
         VerifyPad3Shuffle4SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref destination);
+        ref byte sourceBase = ref MemoryMarshal.GetReference(source);
+        ref byte destinationBase = ref MemoryMarshal.GetReference(destination);
+        int sourceLength = source.Length;
+        int sourceOffset = 0;
+        int destinationOffset = 0;
 
-        // Deal with the remainder:
+        if (Vector128.IsHardwareAccelerated)
-        if (source.Length > 0)
+        {
+            // For source bytes [X0,Y0,Z0,X1,Y1,Z1,...], the indices
+            // [0,1,2,0x80,3,4,5,0x80,...] form four [X,Y,Z,0] pixels. The native
+            // and portable shuffle paths both interpret 0x80 as a zero-producing index.
+            Vector128<byte> padMask = Vector128.Create((byte)0, 1, 2, 0x80, 3, 4, 5, 0x80, 6, 7, 8, 0x80, 9, 10, 11, 0x80);
+
+            // The broadcast ulong has 0xFF in bytes 3 and 7; repeating it across 128 bits
+            // fills W at byte positions 3, 7, 11, and 15 without modifying X, Y, or Z.
+            Vector128<byte> opaqueAlpha = Vector128.Create(0xFF000000FF000000UL).AsByte();
+            ref Vector128<byte> sourceVectors = ref Unsafe.As<byte, Vector128<byte>>(ref sourceBase);
+            ref Vector128<byte> destinationVectors = ref Unsafe.As<byte, Vector128<byte>>(ref destinationBase);
+            nuint sourceVectorCount = (uint)sourceLength / (uint)Vector128<byte>.Count;
+            nuint sourceVectorIndex = 0;
+            nuint destinationVectorIndex = 0;
+
+            for (; sourceVectorIndex + 2 < sourceVectorCount;
+                sourceVectorIndex += 3, destinationVectorIndex += 4)
+            {
+                // Three source registers contain sixteen packed triplets. Aligning at 12, 8, and
+                // 4-byte boundaries produces four registers whose low twelve bytes each hold four pixels.
+                ref Vector128<byte> source0 = ref Unsafe.Add(ref sourceVectors, sourceVectorIndex);
+                Vector128<byte> v0 = source0;
+                Vector128<byte> v1 = Unsafe.Add(ref source0, 1);
+                Vector128<byte> v2 = Unsafe.Add(ref source0, 2);
+                Vector128<byte> v3 = Vector128_.ShiftRightBytesInVector(v2, 4);
+
+                v2 = Vector128_.AlignRight(v2, v1, 8);
+                v1 = Vector128_.AlignRight(v1, v0, 12);
+
+                ref Vector128<byte> destination0 = ref Unsafe.Add(ref destinationVectors, destinationVectorIndex);
+                destination0 = TShuffle.Invoke(Vector128_.ShuffleNative(v0, padMask) | opaqueAlpha);
+                Unsafe.Add(ref destination0, 1) = TShuffle.Invoke(Vector128_.ShuffleNative(v1, padMask) | opaqueAlpha);
+                Unsafe.Add(ref destination0, 2) = TShuffle.Invoke(Vector128_.ShuffleNative(v2, padMask) | opaqueAlpha);
+                Unsafe.Add(ref destination0, 3) = TShuffle.Invoke(Vector128_.ShuffleNative(v3, padMask) | opaqueAlpha);
+            }
+
+            sourceOffset = (int)(sourceVectorIndex * (uint)Vector128<byte>.Count);
+            destinationOffset = (int)(destinationVectorIndex * (uint)Vector128<byte>.Count);
+        }
+
+        int widenedReadEnd = sourceLength - 3;
+
+        for (; sourceOffset < widenedReadEnd; sourceOffset += 3, destinationOffset += 4)
+        {
+            // The widened load intentionally includes the next pixel's first byte. Replacing that
+            // high byte with opaque alpha yields the complete XYZW value with one unaligned read.
+            uint packed = Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)sourceOffset)) | 0xFF000000;
+            Unsafe.As<byte, uint>(ref Unsafe.Add(ref destinationBase, (nuint)destinationOffset)) = TShuffle.Invoke(packed);
+        }
+
+        if (sourceOffset < sourceLength)
         {
-            shuffle.Shuffle(source, destination);
+            // The final triplet cannot use the widened load because no following byte is in range.
+            uint packed =
+                Unsafe.Add(ref sourceBase, (nuint)sourceOffset) |
+                ((uint)Unsafe.Add(ref sourceBase, (nuint)(sourceOffset + 1)) << 8) |
+                ((uint)Unsafe.Add(ref sourceBase, (nuint)(sourceOffset + 2)) << 16) |
+                0xFF000000;
+
+            Unsafe.As<byte, uint>(ref Unsafe.Add(ref destinationBase, (nuint)destinationOffset)) = TShuffle.Invoke(packed);
         }
     }
 
@@ -121,22 +340,103 @@ internal static partial class SimdUtils
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source 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> destination,
+        Span<byte> destination)
-        TShuffle shuffle)
         where TShuffle : struct, IShuffle4Slice3
     {
         VerifyShuffle4Slice3SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref destination);
+        ref byte sourceBase = ref MemoryMarshal.GetReference(source);
+        ref byte destinationBase = ref MemoryMarshal.GetReference(destination);
+        int sourceLength = source.Length;
+        int sourceOffset = 0;
+        int destinationOffset = 0;
 
-        // Deal with the remainder:
+        if (Vector128.IsHardwareAccelerated)
-        if (source.Length > 0)
+        {
+            // Each operator first places the retained components in bytes 0..2 of every four-byte
+            // pixel. The indices [0,1,2,4,5,6,8,9,10,12,13,14] delete each fourth byte and
+            // pack four triplets into the low twelve bytes. Indices 0x80 zero the unused bytes.
+            Vector128<byte> sliceMask = Vector128.Create((byte)0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 0x80, 0x80, 0x80, 0x80);
+
+            // Rotating the mask by twelve moves its packed result four bytes right. Alternating
+            // shifted and unshifted results gives AlignRight the overlap needed to concatenate
+            // four twelve-byte groups into three complete destination registers.
+            Vector128<byte> sliceEndMask = Vector128_.AlignRight(sliceMask, sliceMask, 12);
+            ref Vector128<byte> sourceVectors = ref Unsafe.As<byte, Vector128<byte>>(ref sourceBase);
+            ref Vector128<byte> destinationVectors = ref Unsafe.As<byte, Vector128<byte>>(ref destinationBase);
+            nuint sourceVectorCount = (uint)sourceLength / (uint)Vector128<byte>.Count;
+            nuint sourceVectorIndex = 0;
+            nuint destinationVectorIndex = 0;
+
+            for (; sourceVectorIndex + 3 < sourceVectorCount; sourceVectorIndex += 4, destinationVectorIndex += 3)
+            {
+                // Load and transform all sixteen source pixels before writing the shorter output group.
+                // This preserves forward progress when source and destination begin at the same address.
+                ref Vector128<byte> source0 = ref Unsafe.Add(ref sourceVectors, sourceVectorIndex);
+                Vector128<byte> v0 = TShuffle.Invoke(source0);
+                Vector128<byte> v1 = TShuffle.Invoke(Unsafe.Add(ref source0, 1));
+                Vector128<byte> v2 = TShuffle.Invoke(Unsafe.Add(ref source0, 2));
+                Vector128<byte> v3 = TShuffle.Invoke(Unsafe.Add(ref source0, 3));
+
+                v0 = Vector128_.ShuffleNative(v0, sliceEndMask);
+                v1 = Vector128_.ShuffleNative(v1, sliceMask);
+                v2 = Vector128_.ShuffleNative(v2, sliceEndMask);
+                v3 = Vector128_.ShuffleNative(v3, sliceMask);
+
+                Vector128<byte> destination0 = Vector128_.AlignRight(v1, v0, 4);
+                Vector128<byte> destination2 = Vector128_.AlignRight(v3, v2, 12);
+                v1 = Vector128_.ShiftLeftBytesInVector(v1, 4);
+                v2 = Vector128_.ShiftRightBytesInVector(v2, 4);
+                Vector128<byte> destination1 = Vector128_.AlignRight(v2, v1, 8);
+
+                ref Vector128<byte> destination0Ref = ref Unsafe.Add(ref destinationVectors, destinationVectorIndex);
+                destination0Ref = destination0;
+                Unsafe.Add(ref destination0Ref, 1) = destination1;
+                Unsafe.Add(ref destination0Ref, 2) = destination2;
+            }
+
+            sourceOffset = (int)(sourceVectorIndex * (uint)Vector128<byte>.Count);
+            destinationOffset = (int)(destinationVectorIndex * (uint)Vector128<byte>.Count);
+            int oneTailVectorFromEnd = sourceLength - Vector128<byte>.Count;
+
+            for (; sourceOffset <= oneTailVectorFromEnd; sourceOffset += 16, destinationOffset += 12)
+            {
+                // The operator arranges the three retained components at the front of each pixel.
+                // One fixed shuffle then compacts four pixels into the low twelve vector bytes.
+                Vector128<byte> result = TShuffle.Invoke(Vector128.LoadUnsafe(ref sourceBase, (nuint)sourceOffset));
+
+                result = Vector128_.ShuffleNative(result, sliceMask);
+
+                // The split store writes the exact 12-byte result and remains safe for in-place shrinking.
+                Unsafe.As<byte, Vector64<byte>>(ref Unsafe.Add(ref destinationBase, (nuint)destinationOffset)) = result.GetLower();
+                Unsafe.As<byte, uint>(ref Unsafe.Add(ref destinationBase, (nuint)(destinationOffset + 8))) = result.AsUInt32().GetElement(2);
+            }
+        }
+
+        int fourPixelsFromEnd = sourceLength - 16;
+
+        for (; sourceOffset <= fourPixelsFromEnd; sourceOffset += 16, destinationOffset += 12)
+        {
+            // Transform four complete pixels before the first three-byte store. Keeping the source
+            // values in registers avoids reloads after an in-place shrinking destination advances.
+            uint packed0 = TShuffle.Invoke(Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)sourceOffset)));
+            uint packed1 = TShuffle.Invoke(Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)(sourceOffset + 4))));
+            uint packed2 = TShuffle.Invoke(Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)(sourceOffset + 8))));
+            uint packed3 = TShuffle.Invoke(Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)(sourceOffset + 12))));
+
+            Unsafe.As<byte, Byte3>(ref Unsafe.Add(ref destinationBase, (nuint)destinationOffset)) = Unsafe.As<uint, Byte3>(ref packed0);
+            Unsafe.As<byte, Byte3>(ref Unsafe.Add(ref destinationBase, (nuint)(destinationOffset + 3))) = Unsafe.As<uint, Byte3>(ref packed1);
+            Unsafe.As<byte, Byte3>(ref Unsafe.Add(ref destinationBase, (nuint)(destinationOffset + 6))) = Unsafe.As<uint, Byte3>(ref packed2);
+            Unsafe.As<byte, Byte3>(ref Unsafe.Add(ref destinationBase, (nuint)(destinationOffset + 9))) = Unsafe.As<uint, Byte3>(ref packed3);
+        }
+
+        for (; sourceOffset < sourceLength; sourceOffset += 4, destinationOffset += 3)
         {
-            shuffle.Shuffle(source, destination);
+            uint packed = TShuffle.Invoke(Unsafe.As<byte, uint>(ref Unsafe.Add(ref sourceBase, (nuint)sourceOffset)));
+            Unsafe.As<byte, Byte3>(ref Unsafe.Add(ref destinationBase, (nuint)destinationOffset)) = Unsafe.As<uint, Byte3>(ref packed);
         }
     }
 

src/ImageSharp/Common/Helpers/TensorPrimitives_.Add.cs

@@ -0,0 +1,93 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+internal static partial class TensorPrimitives_
+{
+    /// <summary>
+    /// Computes the element-wise sum of the values in <paramref name="x"/> and <paramref name="y"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="x">The first addends.</param>
+    /// <param name="y">The second addends.</param>
+    /// <param name="destination">The destination for the sums.</param>
+    /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="y"/> do not have the same length.</exception>
+    /// <exception cref="ArgumentException"><paramref name="destination"/> is shorter than the input spans.</exception>
+    /// <exception cref="ArgumentException">
+    /// An input and <paramref name="destination"/> overlap without beginning at the same memory location.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Add<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        => InvokeSpanSpanIntoSpan<T, AddOperator<T>>(x, y, destination);
+
+    /// <summary>
+    /// Computes the element-wise sum of the values in <paramref name="x"/> and the scalar <paramref name="y"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="x">The first addends.</param>
+    /// <param name="y">The scalar second addend.</param>
+    /// <param name="destination">The destination for the sums.</param>
+    /// <exception cref="ArgumentException"><paramref name="destination"/> is shorter than <paramref name="x"/>.</exception>
+    /// <exception cref="ArgumentException">
+    /// <paramref name="x"/> and <paramref name="destination"/> overlap without beginning at the same memory location.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Add<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        => InvokeSpanScalarIntoSpan<T, AddOperator<T>>(x, y, destination);
+
+    /// <summary>
+    /// Adds corresponding values.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private readonly struct AddOperator<T> : IBinaryOperator<T>
+        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether this operation supports vector execution.
+        /// </summary>
+        public static bool Vectorizable => true;
+
+        /// <summary>
+        /// Adds scalar values.
+        /// </summary>
+        /// <param name="x">The first addend.</param>
+        /// <param name="y">The second addend.</param>
+        /// <returns>The sum.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T Invoke(T x, T y) => x + y;
+
+        /// <summary>
+        /// Adds 128-bit vectors.
+        /// </summary>
+        /// <param name="x">The first addends.</param>
+        /// <param name="y">The second addends.</param>
+        /// <returns>The sums.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x + y;
+
+        /// <summary>
+        /// Adds 256-bit vectors.
+        /// </summary>
+        /// <param name="x">The first addends.</param>
+        /// <param name="y">The second addends.</param>
+        /// <returns>The sums.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x + y;
+
+        /// <summary>
+        /// Adds 512-bit vectors.
+        /// </summary>
+        /// <param name="x">The first addends.</param>
+        /// <param name="y">The second addends.</param>
+        /// <returns>The sums.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x + y;
+    }
+}

src/ImageSharp/Common/Helpers/TensorPrimitives_.Clamp.cs

@@ -0,0 +1,322 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+internal static partial class TensorPrimitives_
+{
+    /// <summary>
+    /// Computes the element-wise result of clamping <paramref name="x"/> to the inclusive range specified
+    /// by <paramref name="min"/> and <paramref name="max"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="x">The values to clamp.</param>
+    /// <param name="min">The inclusive lower bound.</param>
+    /// <param name="max">The inclusive upper bound.</param>
+    /// <param name="destination">The destination for the clamped values.</param>
+    /// <exception cref="ArgumentException"><paramref name="destination"/> is shorter than <paramref name="x"/>.</exception>
+    /// <exception cref="ArgumentException">
+    /// <paramref name="x"/> and <paramref name="destination"/> overlap without beginning at the same memory location.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Clamp<T>(ReadOnlySpan<T> x, T min, T max, Span<T> destination)
+        where T : INumber<T>
+        => InvokeSpanScalarScalarIntoSpan<T, ClampOperator<T>>(x, min, max, destination);
+
+    /// <summary>
+    /// Clamps single-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="value">The values to clamp.</param>
+    /// <param name="min">The inclusive lower bounds.</param>
+    /// <param name="max">The inclusive upper bounds.</param>
+    /// <returns>The clamped values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<float> ClampSingle(
+        Vector128<float> value,
+        Vector128<float> min,
+        Vector128<float> max)
+    {
+        // Unlike the native x86 min/max instructions, the normalized runtime operations propagate a NaN in the
+        // first operand and select negative zero when equal values have different signs.
+        Vector128<float> maximum = Vector128.ConditionalSelect(
+            Vector128.LessThan(min, value)
+            | ~Vector128.Equals(value, value)
+            | (Vector128.Equals(value, min) & (min.AsInt32() >> 31).AsSingle()),
+            value,
+            min);
+
+        return Vector128.ConditionalSelect(
+            Vector128.LessThan(maximum, max)
+            | ~Vector128.Equals(maximum, maximum)
+            | (Vector128.Equals(maximum, max) & (maximum.AsInt32() >> 31).AsSingle()),
+            maximum,
+            max);
+    }
+
+    /// <summary>
+    /// Clamps single-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="value">The values to clamp.</param>
+    /// <param name="min">The inclusive lower bounds.</param>
+    /// <param name="max">The inclusive upper bounds.</param>
+    /// <returns>The clamped values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> ClampSingle(
+        Vector256<float> value,
+        Vector256<float> min,
+        Vector256<float> max)
+    {
+        Vector256<float> maximum = Vector256.ConditionalSelect(
+            Vector256.LessThan(min, value)
+            | ~Vector256.Equals(value, value)
+            | (Vector256.Equals(value, min) & (min.AsInt32() >> 31).AsSingle()),
+            value,
+            min);
+
+        return Vector256.ConditionalSelect(
+            Vector256.LessThan(maximum, max)
+            | ~Vector256.Equals(maximum, maximum)
+            | (Vector256.Equals(maximum, max) & (maximum.AsInt32() >> 31).AsSingle()),
+            maximum,
+            max);
+    }
+
+    /// <summary>
+    /// Clamps single-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="value">The values to clamp.</param>
+    /// <param name="min">The inclusive lower bounds.</param>
+    /// <param name="max">The inclusive upper bounds.</param>
+    /// <returns>The clamped values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> ClampSingle(
+        Vector512<float> value,
+        Vector512<float> min,
+        Vector512<float> max)
+    {
+        Vector512<float> maximum = Vector512.ConditionalSelect(
+            Vector512.LessThan(min, value)
+            | ~Vector512.Equals(value, value)
+            | (Vector512.Equals(value, min) & (min.AsInt32() >> 31).AsSingle()),
+            value,
+            min);
+
+        return Vector512.ConditionalSelect(
+            Vector512.LessThan(maximum, max)
+            | ~Vector512.Equals(maximum, maximum)
+            | (Vector512.Equals(maximum, max) & (maximum.AsInt32() >> 31).AsSingle()),
+            maximum,
+            max);
+    }
+
+    /// <summary>
+    /// Clamps double-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="value">The values to clamp.</param>
+    /// <param name="min">The inclusive lower bounds.</param>
+    /// <param name="max">The inclusive upper bounds.</param>
+    /// <returns>The clamped values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<double> ClampDouble(
+        Vector128<double> value,
+        Vector128<double> min,
+        Vector128<double> max)
+    {
+        Vector128<double> maximum = Vector128.ConditionalSelect(
+            Vector128.LessThan(min, value)
+            | ~Vector128.Equals(value, value)
+            | (Vector128.Equals(value, min) & (min.AsInt64() >> 63).AsDouble()),
+            value,
+            min);
+
+        return Vector128.ConditionalSelect(
+            Vector128.LessThan(maximum, max)
+            | ~Vector128.Equals(maximum, maximum)
+            | (Vector128.Equals(maximum, max) & (maximum.AsInt64() >> 63).AsDouble()),
+            maximum,
+            max);
+    }
+
+    /// <summary>
+    /// Clamps double-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="value">The values to clamp.</param>
+    /// <param name="min">The inclusive lower bounds.</param>
+    /// <param name="max">The inclusive upper bounds.</param>
+    /// <returns>The clamped values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<double> ClampDouble(
+        Vector256<double> value,
+        Vector256<double> min,
+        Vector256<double> max)
+    {
+        Vector256<double> maximum = Vector256.ConditionalSelect(
+            Vector256.LessThan(min, value)
+            | ~Vector256.Equals(value, value)
+            | (Vector256.Equals(value, min) & (min.AsInt64() >> 63).AsDouble()),
+            value,
+            min);
+
+        return Vector256.ConditionalSelect(
+            Vector256.LessThan(maximum, max)
+            | ~Vector256.Equals(maximum, maximum)
+            | (Vector256.Equals(maximum, max) & (maximum.AsInt64() >> 63).AsDouble()),
+            maximum,
+            max);
+    }
+
+    /// <summary>
+    /// Clamps double-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="value">The values to clamp.</param>
+    /// <param name="min">The inclusive lower bounds.</param>
+    /// <param name="max">The inclusive upper bounds.</param>
+    /// <returns>The clamped values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<double> ClampDouble(
+        Vector512<double> value,
+        Vector512<double> min,
+        Vector512<double> max)
+    {
+        Vector512<double> maximum = Vector512.ConditionalSelect(
+            Vector512.LessThan(min, value)
+            | ~Vector512.Equals(value, value)
+            | (Vector512.Equals(value, min) & (min.AsInt64() >> 63).AsDouble()),
+            value,
+            min);
+
+        return Vector512.ConditionalSelect(
+            Vector512.LessThan(maximum, max)
+            | ~Vector512.Equals(maximum, maximum)
+            | (Vector512.Equals(maximum, max) & (maximum.AsInt64() >> 63).AsDouble()),
+            maximum,
+            max);
+    }
+
+    /// <summary>
+    /// Clamps values using the complete runtime tensor contract, including signed-zero correction.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private readonly struct ClampOperator<T> : ITernaryOperator<T>
+        where T : INumber<T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether this operation supports vector execution.
+        /// </summary>
+        public static bool Vectorizable => true;
+
+        /// <summary>
+        /// Clamps a scalar value.
+        /// </summary>
+        /// <param name="x">The value.</param>
+        /// <param name="min">The inclusive lower bound.</param>
+        /// <param name="max">The inclusive upper bound.</param>
+        /// <returns>The clamped value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T Invoke(T x, T min, T max)
+            => Vector128<T>.IsSupported ? T.Min(T.Max(x, min), max) : T.Clamp(x, min, max);
+
+        /// <summary>
+        /// Clamps a 128-bit vector.
+        /// </summary>
+        /// <param name="x">The values.</param>
+        /// <param name="min">The inclusive lower bounds.</param>
+        /// <param name="max">The inclusive upper bounds.</param>
+        /// <returns>The clamped values.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> min, Vector128<T> max)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                Vector128<float> result = ClampSingle(
+                    Unsafe.As<Vector128<T>, Vector128<float>>(ref x),
+                    Unsafe.As<Vector128<T>, Vector128<float>>(ref min),
+                    Unsafe.As<Vector128<T>, Vector128<float>>(ref max));
+
+                return Unsafe.As<Vector128<float>, Vector128<T>>(ref result);
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                Vector128<double> result = ClampDouble(
+                    Unsafe.As<Vector128<T>, Vector128<double>>(ref x),
+                    Unsafe.As<Vector128<T>, Vector128<double>>(ref min),
+                    Unsafe.As<Vector128<T>, Vector128<double>>(ref max));
+
+                return Unsafe.As<Vector128<double>, Vector128<T>>(ref result);
+            }
+
+            return Vector128_.Clamp(x, min, max);
+        }
+
+        /// <summary>
+        /// Clamps a 256-bit vector.
+        /// </summary>
+        /// <param name="x">The values.</param>
+        /// <param name="min">The inclusive lower bounds.</param>
+        /// <param name="max">The inclusive upper bounds.</param>
+        /// <returns>The clamped values.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> min, Vector256<T> max)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                Vector256<float> result = ClampSingle(
+                    Unsafe.As<Vector256<T>, Vector256<float>>(ref x),
+                    Unsafe.As<Vector256<T>, Vector256<float>>(ref min),
+                    Unsafe.As<Vector256<T>, Vector256<float>>(ref max));
+
+                return Unsafe.As<Vector256<float>, Vector256<T>>(ref result);
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                Vector256<double> result = ClampDouble(
+                    Unsafe.As<Vector256<T>, Vector256<double>>(ref x),
+                    Unsafe.As<Vector256<T>, Vector256<double>>(ref min),
+                    Unsafe.As<Vector256<T>, Vector256<double>>(ref max));
+
+                return Unsafe.As<Vector256<double>, Vector256<T>>(ref result);
+            }
+
+            return Vector256_.Clamp(x, min, max);
+        }
+
+        /// <summary>
+        /// Clamps a 512-bit vector.
+        /// </summary>
+        /// <param name="x">The values.</param>
+        /// <param name="min">The inclusive lower bounds.</param>
+        /// <param name="max">The inclusive upper bounds.</param>
+        /// <returns>The clamped values.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> min, Vector512<T> max)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                Vector512<float> result = ClampSingle(
+                    Unsafe.As<Vector512<T>, Vector512<float>>(ref x),
+                    Unsafe.As<Vector512<T>, Vector512<float>>(ref min),
+                    Unsafe.As<Vector512<T>, Vector512<float>>(ref max));
+
+                return Unsafe.As<Vector512<float>, Vector512<T>>(ref result);
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                Vector512<double> result = ClampDouble(
+                    Unsafe.As<Vector512<T>, Vector512<double>>(ref x),
+                    Unsafe.As<Vector512<T>, Vector512<double>>(ref min),
+                    Unsafe.As<Vector512<T>, Vector512<double>>(ref max));
+
+                return Unsafe.As<Vector512<double>, Vector512<T>>(ref result);
+            }
+
+            return Vector512_.Clamp(x, min, max);
+        }
+    }
+}

src/ImageSharp/Common/Helpers/TensorPrimitives_.Divide.cs

@@ -0,0 +1,87 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+internal static partial class TensorPrimitives_
+{
+    /// <summary>
+    /// Computes the element-wise result of dividing the values in <paramref name="x"/> by <paramref name="y"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="x">The dividend values.</param>
+    /// <param name="y">The divisor.</param>
+    /// <param name="destination">The destination for the quotient values.</param>
+    /// <exception cref="ArgumentException"><paramref name="destination"/> is shorter than <paramref name="x"/>.</exception>
+    /// <exception cref="ArgumentException">
+    /// <paramref name="x"/> and <paramref name="destination"/> overlap without beginning at the same memory location.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Divide<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+        where T : IDivisionOperators<T, T, T>
+        => InvokeSpanScalarIntoSpanForDivision<T, DivideOperator<T>>(x, y, destination);
+
+    /// <summary>
+    /// Determines whether <typeparamref name="T"/> has the same vector division support as <see cref="int"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <returns><see langword="true"/> when <typeparamref name="T"/> is a 32-bit signed native integer type.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsInt32Like<T>()
+        => typeof(T) == typeof(int) || (IntPtr.Size == 4 && typeof(T) == typeof(nint));
+
+    /// <summary>
+    /// Divides values by a scalar.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private readonly struct DivideOperator<T> : IBinaryOperator<T>
+        where T : IDivisionOperators<T, T, T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether this operation supports vector execution.
+        /// </summary>
+        public static bool Vectorizable => typeof(T) == typeof(float)
+                                        || typeof(T) == typeof(double)
+                                        || (Vector256.IsHardwareAccelerated && IsInt32Like<T>());
+
+        /// <summary>
+        /// Divides scalar values.
+        /// </summary>
+        /// <param name="x">The dividend.</param>
+        /// <param name="y">The divisor.</param>
+        /// <returns>The quotient.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T Invoke(T x, T y) => x / y;
+
+        /// <summary>
+        /// Divides 128-bit vectors.
+        /// </summary>
+        /// <param name="x">The dividends.</param>
+        /// <param name="y">The divisors.</param>
+        /// <returns>The quotients.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x / y;
+
+        /// <summary>
+        /// Divides 256-bit vectors.
+        /// </summary>
+        /// <param name="x">The dividends.</param>
+        /// <param name="y">The divisors.</param>
+        /// <returns>The quotients.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x / y;
+
+        /// <summary>
+        /// Divides 512-bit vectors.
+        /// </summary>
+        /// <param name="x">The dividends.</param>
+        /// <param name="y">The divisors.</param>
+        /// <returns>The quotients.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x / y;
+    }
+}

src/ImageSharp/Common/Helpers/TensorPrimitives_.Helpers.cs

@@ -0,0 +1,900 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+/// <summary>
+/// Provides compatibility implementations for tensor operations that are not available on every target framework.
+/// </summary>
+/// <remarks>
+/// The API shape follows <c>System.Numerics.Tensors.TensorPrimitives</c> so call sites can move to the runtime
+/// implementation when ImageSharp no longer supports target frameworks that predate it.
+/// </remarks>
+internal static partial class TensorPrimitives_
+{
+    /// <summary>
+    /// Defines an element-wise binary operation.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private interface IBinaryOperator<T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether the operation supports vector execution.
+        /// </summary>
+        public static abstract bool Vectorizable { get; }
+
+        /// <summary>
+        /// Applies the operation to scalar values.
+        /// </summary>
+        /// <param name="x">The first value.</param>
+        /// <param name="y">The second value.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract T Invoke(T x, T y);
+
+        /// <summary>
+        /// Applies the operation to 128-bit vectors.
+        /// </summary>
+        /// <param name="x">The first vector.</param>
+        /// <param name="y">The second vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector128<T> Invoke(Vector128<T> x, Vector128<T> y);
+
+        /// <summary>
+        /// Applies the operation to 256-bit vectors.
+        /// </summary>
+        /// <param name="x">The first vector.</param>
+        /// <param name="y">The second vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector256<T> Invoke(Vector256<T> x, Vector256<T> y);
+
+        /// <summary>
+        /// Applies the operation to 512-bit vectors.
+        /// </summary>
+        /// <param name="x">The first vector.</param>
+        /// <param name="y">The second vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector512<T> Invoke(Vector512<T> x, Vector512<T> y);
+    }
+
+    /// <summary>
+    /// Defines an element-wise ternary operation.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private interface ITernaryOperator<T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether the operation supports vector execution.
+        /// </summary>
+        public static abstract bool Vectorizable { get; }
+
+        /// <summary>
+        /// Applies the operation to scalar values.
+        /// </summary>
+        /// <param name="x">The first value.</param>
+        /// <param name="y">The second value.</param>
+        /// <param name="z">The third value.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract T Invoke(T x, T y, T z);
+
+        /// <summary>
+        /// Applies the operation to 128-bit vectors.
+        /// </summary>
+        /// <param name="x">The first vector.</param>
+        /// <param name="y">The second vector.</param>
+        /// <param name="z">The third vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector128<T> Invoke(Vector128<T> x, Vector128<T> y, Vector128<T> z);
+
+        /// <summary>
+        /// Applies the operation to 256-bit vectors.
+        /// </summary>
+        /// <param name="x">The first vector.</param>
+        /// <param name="y">The second vector.</param>
+        /// <param name="z">The third vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z);
+
+        /// <summary>
+        /// Applies the operation to 512-bit vectors.
+        /// </summary>
+        /// <param name="x">The first vector.</param>
+        /// <param name="y">The second vector.</param>
+        /// <param name="z">The third vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z);
+    }
+
+    /// <summary>
+    /// Validates that an input and destination are either disjoint or begin at the same memory location.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="input">The input values.</param>
+    /// <param name="destination">The destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void ValidateInputOutputSpanNonOverlapping<T>(ReadOnlySpan<T> input, Span<T> destination)
+    {
+        // Runtime TensorPrimitives permits exact same-start overlap for in-place operation. A shifted overlap is
+        // rejected because forward SIMD stores could overwrite input elements before a later load consumes them.
+        if (!Unsafe.AreSame(ref MemoryMarshal.GetReference(input), ref MemoryMarshal.GetReference(destination))
+            && input.Overlaps(destination))
+        {
+            ThrowInputAndDestinationSpanMustNotOverlap();
+        }
+    }
+
+    /// <summary>
+    /// Throws when input spans do not have the same length.
+    /// </summary>
+    [DoesNotReturn]
+    private static void ThrowSpansMustHaveSameLength()
+        => throw new ArgumentException("Input span arguments must all have the same length.");
+
+    /// <summary>
+    /// Throws when the destination cannot hold every result.
+    /// </summary>
+    [DoesNotReturn]
+    private static void ThrowDestinationTooShort()
+        => throw new ArgumentException("Destination is too short.", "destination");
+
+    /// <summary>
+    /// Throws when an input and destination overlap without beginning at the same memory location.
+    /// </summary>
+    [DoesNotReturn]
+    private static void ThrowInputAndDestinationSpanMustNotOverlap()
+        => throw new ArgumentException(
+            "The destination span may only overlap with an input span if the two spans start at the same memory location.",
+            "destination");
+
+    /// <summary>
+    /// Performs an element-wise binary operation between two spans.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="x">The first input values.</param>
+    /// <param name="y">The second input values.</param>
+    /// <param name="destination">The destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeSpanSpanIntoSpan<T, TOperator>(
+        ReadOnlySpan<T> x,
+        ReadOnlySpan<T> y,
+        Span<T> destination)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        if (x.Length != y.Length)
+        {
+            ThrowSpansMustHaveSameLength();
+        }
+
+        if (x.Length > destination.Length)
+        {
+            ThrowDestinationTooShort();
+        }
+
+        ValidateInputOutputSpanNonOverlapping(x, destination);
+        ValidateInputOutputSpanNonOverlapping(y, destination);
+
+        ref T xRef = ref MemoryMarshal.GetReference(x);
+        ref T yRef = ref MemoryMarshal.GetReference(y);
+        ref T destinationRef = ref MemoryMarshal.GetReference(destination);
+        nuint length = (uint)x.Length;
+
+        // Runtime main selects the widest supported pipeline once one complete vector is available.
+        // Each pipeline preloads its final inputs when a tail overlaps so same-start in-place operation remains correct.
+        if (TOperator.Vectorizable
+            && Vector512.IsHardwareAccelerated
+            && Vector512<T>.IsSupported
+            && length >= (uint)Vector512<T>.Count)
+        {
+            InvokeVectorized512<T, TOperator>(ref xRef, ref yRef, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && length >= (uint)Vector256<T>.Count)
+        {
+            InvokeVectorized256<T, TOperator>(ref xRef, ref yRef, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && length >= (uint)Vector128<T>.Count)
+        {
+            InvokeVectorized128<T, TOperator>(ref xRef, ref yRef, ref destinationRef, length);
+            return;
+        }
+
+        for (nuint i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref destinationRef, i) = TOperator.Invoke(Unsafe.Add(ref xRef, i), Unsafe.Add(ref yRef, i));
+        }
+    }
+
+    /// <summary>
+    /// Performs an element-wise binary operation between a span and a scalar.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="x">The input values.</param>
+    /// <param name="y">The scalar input.</param>
+    /// <param name="destination">The destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeSpanScalarIntoSpan<T, TOperator>(
+        ReadOnlySpan<T> x,
+        T y,
+        Span<T> destination)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        if (x.Length > destination.Length)
+        {
+            ThrowDestinationTooShort();
+        }
+
+        ValidateInputOutputSpanNonOverlapping(x, destination);
+
+        ref T xRef = ref MemoryMarshal.GetReference(x);
+        ref T destinationRef = ref MemoryMarshal.GetReference(destination);
+        nuint length = (uint)x.Length;
+
+        // Runtime main selects the widest supported pipeline once one complete vector is available.
+        if (TOperator.Vectorizable
+            && Vector512.IsHardwareAccelerated
+            && Vector512<T>.IsSupported
+            && length >= (uint)Vector512<T>.Count)
+        {
+            InvokeVectorized512<T, TOperator>(ref xRef, y, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && length >= (uint)Vector256<T>.Count)
+        {
+            InvokeVectorized256<T, TOperator>(ref xRef, y, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && length >= (uint)Vector128<T>.Count)
+        {
+            InvokeVectorized128<T, TOperator>(ref xRef, y, ref destinationRef, length);
+            return;
+        }
+
+        for (nuint i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref destinationRef, i) = TOperator.Invoke(Unsafe.Add(ref xRef, i), y);
+        }
+    }
+
+    /// <summary>
+    /// Performs element-wise division using the runtime tensor width-selection order.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The division operation to apply.</typeparam>
+    /// <param name="x">The input values.</param>
+    /// <param name="y">The scalar divisor.</param>
+    /// <param name="destination">The destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeSpanScalarIntoSpanForDivision<T, TOperator>(
+        ReadOnlySpan<T> x,
+        T y,
+        Span<T> destination)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        if (x.Length > destination.Length)
+        {
+            ThrowDestinationTooShort();
+        }
+
+        ValidateInputOutputSpanNonOverlapping(x, destination);
+
+        ref T xRef = ref MemoryMarshal.GetReference(x);
+        ref T destinationRef = ref MemoryMarshal.GetReference(destination);
+        nuint length = (uint)x.Length;
+
+        // Runtime main selects the widest supported pipeline once one complete vector is available.
+        if (TOperator.Vectorizable
+            && Vector512.IsHardwareAccelerated
+            && Vector512<T>.IsSupported
+            && length >= (uint)Vector512<T>.Count)
+        {
+            InvokeVectorized512<T, TOperator>(ref xRef, y, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && length >= (uint)Vector256<T>.Count)
+        {
+            InvokeVectorized256<T, TOperator>(ref xRef, y, ref destinationRef, length);
+            return;
+        }
+
+        // Four values fill one 128-bit float vector. Processing exactly one packed prefix before the scalar
+        // remainder avoids the overlapping second vector that regresses the common seven-element normalization.
+        if (TOperator.Vectorizable
+            && Vector128.IsHardwareAccelerated
+            && Vector128<T>.IsSupported
+            && length >= (uint)Vector128<T>.Count)
+        {
+            nuint vectorCount = (uint)Vector128<T>.Count;
+            Vector128<T> yVector = Vector128.Create(y);
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef), yVector).StoreUnsafe(ref destinationRef);
+
+            for (nuint i = vectorCount; i < length; i++)
+            {
+                Unsafe.Add(ref destinationRef, i) = TOperator.Invoke(Unsafe.Add(ref xRef, i), y);
+            }
+
+            return;
+        }
+
+        for (nuint i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref destinationRef, i) = TOperator.Invoke(Unsafe.Add(ref xRef, i), y);
+        }
+    }
+
+    /// <summary>
+    /// Performs an element-wise ternary operation between a span and two scalars.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="x">The input values.</param>
+    /// <param name="y">The first scalar input.</param>
+    /// <param name="z">The second scalar input.</param>
+    /// <param name="destination">The destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeSpanScalarScalarIntoSpan<T, TOperator>(
+        ReadOnlySpan<T> x,
+        T y,
+        T z,
+        Span<T> destination)
+        where TOperator : struct, ITernaryOperator<T>
+    {
+        if (x.Length > destination.Length)
+        {
+            ThrowDestinationTooShort();
+        }
+
+        ValidateInputOutputSpanNonOverlapping(x, destination);
+
+        ref T xRef = ref MemoryMarshal.GetReference(x);
+        ref T destinationRef = ref MemoryMarshal.GetReference(destination);
+        nuint length = (uint)x.Length;
+
+        // This dispatch mirrors the runtime pipeline: large inputs use the widest available registers while
+        // short inputs fall through to a width that fits, keeping the operator contract identical at every length.
+        if (TOperator.Vectorizable && Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && length >= (uint)Vector512<T>.Count)
+        {
+            InvokeVectorized512<T, TOperator>(ref xRef, y, z, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && length >= (uint)Vector256<T>.Count)
+        {
+            InvokeVectorized256<T, TOperator>(ref xRef, y, z, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && length >= (uint)Vector128<T>.Count)
+        {
+            InvokeVectorized128<T, TOperator>(ref xRef, y, z, ref destinationRef, length);
+            return;
+        }
+
+        for (nuint i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref destinationRef, i) = TOperator.Invoke(Unsafe.Add(ref xRef, i), y, z);
+        }
+    }
+
+    /// <summary>
+    /// Applies a binary operation between two spans with 128-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first element of the first input.</param>
+    /// <param name="yRef">The first element of the second input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized128<T, TOperator>(
+        ref T xRef,
+        ref T yRef,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector128<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+
+        // When a tail exists, both final inputs are loaded before any stores. This permits either source to also
+        // be the destination when the tail starts inside the range written by the preceding full vector.
+        Vector128<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector128.LoadUnsafe(ref xRef, length - vectorCount),
+                Vector128.LoadUnsafe(ref yRef, length - vectorCount));
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 0)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 0))).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 1)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 1))).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 2)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 2))).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 3)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 3))).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 4)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 4))).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 5)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 5))).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 6)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 6))).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 7)), Vector128.LoadUnsafe(ref yRef, index + (vectorCount * 7))).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index), Vector128.LoadUnsafe(ref yRef, index)).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a binary operation between two spans with 256-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first element of the first input.</param>
+    /// <param name="yRef">The first element of the second input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized256<T, TOperator>(
+        ref T xRef,
+        ref T yRef,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector256<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector256<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector256.LoadUnsafe(ref xRef, length - vectorCount),
+                Vector256.LoadUnsafe(ref yRef, length - vectorCount));
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 0)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 0))).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 1)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 1))).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 2)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 2))).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 3)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 3))).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 4)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 4))).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 5)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 5))).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 6)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 6))).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 7)), Vector256.LoadUnsafe(ref yRef, index + (vectorCount * 7))).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index), Vector256.LoadUnsafe(ref yRef, index)).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a binary operation between two spans with 512-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first element of the first input.</param>
+    /// <param name="yRef">The first element of the second input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized512<T, TOperator>(
+        ref T xRef,
+        ref T yRef,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector512<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector512<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector512.LoadUnsafe(ref xRef, length - vectorCount),
+                Vector512.LoadUnsafe(ref yRef, length - vectorCount));
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 0)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 0))).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 1)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 1))).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 2)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 2))).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 3)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 3))).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 4)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 4))).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 5)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 5))).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 6)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 6))).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 7)), Vector512.LoadUnsafe(ref yRef, index + (vectorCount * 7))).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index), Vector512.LoadUnsafe(ref yRef, index)).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a binary operation between a span and a scalar with 128-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="y">The scalar input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized128<T, TOperator>(
+        ref T xRef,
+        T y,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector128<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector128<T> yVector = Vector128.Create(y);
+
+        // When a tail exists, preloading its final vector is required for in-place operation because it must
+        // observe the original values before an earlier overlapping store writes them.
+        Vector128<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector128.LoadUnsafe(ref xRef, length - vectorCount),
+                yVector);
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 0)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 1)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 2)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 3)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 4)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 5)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 6)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 7)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index), yVector).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a binary operation with 256-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="y">The scalar input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized256<T, TOperator>(
+        ref T xRef,
+        T y,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector256<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector256<T> yVector = Vector256.Create(y);
+        Vector256<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector256.LoadUnsafe(ref xRef, length - vectorCount),
+                yVector);
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 0)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 1)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 2)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 3)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 4)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 5)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 6)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 7)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index), yVector).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a binary operation with 512-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="y">The scalar input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized512<T, TOperator>(
+        ref T xRef,
+        T y,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, IBinaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector512<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector512<T> yVector = Vector512.Create(y);
+        Vector512<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector512.LoadUnsafe(ref xRef, length - vectorCount),
+                yVector);
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 0)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 1)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 2)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 3)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 4)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 5)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 6)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 7)), yVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index), yVector).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a ternary operation with 128-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="y">The first scalar input.</param>
+    /// <param name="z">The second scalar input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized128<T, TOperator>(
+        ref T xRef,
+        T y,
+        T z,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, ITernaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector128<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector128<T> yVector = Vector128.Create(y);
+        Vector128<T> zVector = Vector128.Create(z);
+        Vector128<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector128.LoadUnsafe(ref xRef, length - vectorCount),
+                yVector,
+                zVector);
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 0)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 1)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 2)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 3)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 4)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 5)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 6)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 7)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index), yVector, zVector).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a ternary operation with 256-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="y">The first scalar input.</param>
+    /// <param name="z">The second scalar input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized256<T, TOperator>(
+        ref T xRef,
+        T y,
+        T z,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, ITernaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector256<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector256<T> yVector = Vector256.Create(y);
+        Vector256<T> zVector = Vector256.Create(z);
+        Vector256<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector256.LoadUnsafe(ref xRef, length - vectorCount),
+                yVector,
+                zVector);
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 0)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 1)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 2)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 3)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 4)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 5)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 6)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 7)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index), yVector, zVector).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a ternary operation with 512-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="y">The first scalar input.</param>
+    /// <param name="z">The second scalar input.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeVectorized512<T, TOperator>(
+        ref T xRef,
+        T y,
+        T z,
+        ref T destinationRef,
+        nuint length)
+        where TOperator : struct, ITernaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector512<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector512<T> yVector = Vector512.Create(y);
+        Vector512<T> zVector = Vector512.Create(z);
+        Vector512<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(
+                Vector512.LoadUnsafe(ref xRef, length - vectorCount),
+                yVector,
+                zVector);
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 0)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 1)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 2)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 3)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 4)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 5)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 6)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 7)), yVector, zVector).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index), yVector, zVector).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+}

src/ImageSharp/Common/Helpers/TensorPrimitives_.Max.cs

@@ -0,0 +1,249 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+internal static partial class TensorPrimitives_
+{
+    /// <summary>
+    /// Computes the element-wise maximum of the values in <paramref name="x"/> and <paramref name="y"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="x">The values to compare.</param>
+    /// <param name="y">The value to compare with each element.</param>
+    /// <param name="destination">The destination for the maximum values.</param>
+    /// <exception cref="ArgumentException"><paramref name="destination"/> is shorter than <paramref name="x"/>.</exception>
+    /// <exception cref="ArgumentException">
+    /// <paramref name="x"/> and <paramref name="destination"/> overlap without beginning at the same memory location.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Max<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+        where T : INumber<T>
+        => InvokeSpanScalarIntoSpan<T, MaxOperator<T>>(x, y, destination);
+
+    /// <summary>
+    /// Selects maximum single-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="x">The first values.</param>
+    /// <param name="y">The second values.</param>
+    /// <returns>The maximum values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<float> MaxSingle(Vector128<float> x, Vector128<float> y)
+    {
+        // The .NET 8 operation already handles ordered unequal values. Correct its second-operand result for a
+        // first-operand NaN, then use bitwise AND for equal values so positive zero wins regardless of operand order.
+        Vector128<float> result = Vector128.Max(x, y);
+        result = Vector128.ConditionalSelect(~Vector128.Equals(x, x), x, result);
+
+        return Vector128.ConditionalSelect(
+            Vector128.Equals(x, y),
+            x & y,
+            result);
+    }
+
+    /// <summary>
+    /// Selects maximum single-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="x">The first values.</param>
+    /// <param name="y">The second values.</param>
+    /// <returns>The maximum values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> MaxSingle(Vector256<float> x, Vector256<float> y)
+    {
+        Vector256<float> result = Vector256.Max(x, y);
+        result = Vector256.ConditionalSelect(~Vector256.Equals(x, x), x, result);
+
+        return Vector256.ConditionalSelect(
+            Vector256.Equals(x, y),
+            x & y,
+            result);
+    }
+
+    /// <summary>
+    /// Selects maximum single-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="x">The first values.</param>
+    /// <param name="y">The second values.</param>
+    /// <returns>The maximum values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> MaxSingle(Vector512<float> x, Vector512<float> y)
+    {
+        Vector512<float> result = Vector512.Max(x, y);
+        result = Vector512.ConditionalSelect(~Vector512.Equals(x, x), x, result);
+
+        return Vector512.ConditionalSelect(
+            Vector512.Equals(x, y),
+            x & y,
+            result);
+    }
+
+    /// <summary>
+    /// Selects maximum double-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="x">The first values.</param>
+    /// <param name="y">The second values.</param>
+    /// <returns>The maximum values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<double> MaxDouble(Vector128<double> x, Vector128<double> y)
+    {
+        Vector128<double> result = Vector128.Max(x, y);
+        result = Vector128.ConditionalSelect(~Vector128.Equals(x, x), x, result);
+
+        return Vector128.ConditionalSelect(
+            Vector128.Equals(x, y),
+            x & y,
+            result);
+    }
+
+    /// <summary>
+    /// Selects maximum double-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="x">The first values.</param>
+    /// <param name="y">The second values.</param>
+    /// <returns>The maximum values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<double> MaxDouble(Vector256<double> x, Vector256<double> y)
+    {
+        Vector256<double> result = Vector256.Max(x, y);
+        result = Vector256.ConditionalSelect(~Vector256.Equals(x, x), x, result);
+
+        return Vector256.ConditionalSelect(
+            Vector256.Equals(x, y),
+            x & y,
+            result);
+    }
+
+    /// <summary>
+    /// Selects maximum double-precision values with the normalized runtime semantics.
+    /// </summary>
+    /// <param name="x">The first values.</param>
+    /// <param name="y">The second values.</param>
+    /// <returns>The maximum values.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<double> MaxDouble(Vector512<double> x, Vector512<double> y)
+    {
+        Vector512<double> result = Vector512.Max(x, y);
+        result = Vector512.ConditionalSelect(~Vector512.Equals(x, x), x, result);
+
+        return Vector512.ConditionalSelect(
+            Vector512.Equals(x, y),
+            x & y,
+            result);
+    }
+
+    /// <summary>
+    /// Selects the maximum corresponding values.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private readonly struct MaxOperator<T> : IBinaryOperator<T>
+        where T : INumber<T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether this operation supports vector execution.
+        /// </summary>
+        public static bool Vectorizable => true;
+
+        /// <summary>
+        /// Selects the maximum scalar value.
+        /// </summary>
+        /// <param name="x">The first value.</param>
+        /// <param name="y">The second value.</param>
+        /// <returns>The maximum value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T Invoke(T x, T y) => T.Max(x, y);
+
+        /// <summary>
+        /// Selects the maximum values from 128-bit vectors.
+        /// </summary>
+        /// <param name="x">The first values.</param>
+        /// <param name="y">The second values.</param>
+        /// <returns>The maximum values.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                Vector128<float> result = MaxSingle(
+                    Unsafe.As<Vector128<T>, Vector128<float>>(ref x),
+                    Unsafe.As<Vector128<T>, Vector128<float>>(ref y));
+
+                return Unsafe.As<Vector128<float>, Vector128<T>>(ref result);
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                Vector128<double> result = MaxDouble(
+                    Unsafe.As<Vector128<T>, Vector128<double>>(ref x),
+                    Unsafe.As<Vector128<T>, Vector128<double>>(ref y));
+
+                return Unsafe.As<Vector128<double>, Vector128<T>>(ref result);
+            }
+
+            return Vector128.Max(x, y);
+        }
+
+        /// <summary>
+        /// Selects the maximum values from 256-bit vectors.
+        /// </summary>
+        /// <param name="x">The first values.</param>
+        /// <param name="y">The second values.</param>
+        /// <returns>The maximum values.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                Vector256<float> result = MaxSingle(
+                    Unsafe.As<Vector256<T>, Vector256<float>>(ref x),
+                    Unsafe.As<Vector256<T>, Vector256<float>>(ref y));
+
+                return Unsafe.As<Vector256<float>, Vector256<T>>(ref result);
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                Vector256<double> result = MaxDouble(
+                    Unsafe.As<Vector256<T>, Vector256<double>>(ref x),
+                    Unsafe.As<Vector256<T>, Vector256<double>>(ref y));
+
+                return Unsafe.As<Vector256<double>, Vector256<T>>(ref result);
+            }
+
+            return Vector256.Max(x, y);
+        }
+
+        /// <summary>
+        /// Selects the maximum values from 512-bit vectors.
+        /// </summary>
+        /// <param name="x">The first values.</param>
+        /// <param name="y">The second values.</param>
+        /// <returns>The maximum values.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                Vector512<float> result = MaxSingle(
+                    Unsafe.As<Vector512<T>, Vector512<float>>(ref x),
+                    Unsafe.As<Vector512<T>, Vector512<float>>(ref y));
+
+                return Unsafe.As<Vector512<float>, Vector512<T>>(ref result);
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                Vector512<double> result = MaxDouble(
+                    Unsafe.As<Vector512<T>, Vector512<double>>(ref x),
+                    Unsafe.As<Vector512<T>, Vector512<double>>(ref y));
+
+                return Unsafe.As<Vector512<double>, Vector512<T>>(ref result);
+            }
+
+            return Vector512.Max(x, y);
+        }
+    }
+}

src/ImageSharp/Common/Helpers/TensorPrimitives_.Multiply.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+internal static partial class TensorPrimitives_
+{
+    /// <summary>
+    /// Computes the element-wise product of the values in <paramref name="x"/> and <paramref name="y"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="x">The multiplicands.</param>
+    /// <param name="y">The multiplier.</param>
+    /// <param name="destination">The destination for the products.</param>
+    /// <exception cref="ArgumentException"><paramref name="destination"/> is shorter than <paramref name="x"/>.</exception>
+    /// <exception cref="ArgumentException">
+    /// <paramref name="x"/> and <paramref name="destination"/> overlap without beginning at the same memory location.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Multiply<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+        where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        => InvokeSpanScalarIntoSpan<T, MultiplyOperator<T>>(x, y, destination);
+
+    /// <summary>
+    /// Multiplies corresponding values.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private readonly struct MultiplyOperator<T> : IBinaryOperator<T>
+        where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether this operation supports vector execution.
+        /// </summary>
+        public static bool Vectorizable => true;
+
+        /// <summary>
+        /// Multiplies scalar values.
+        /// </summary>
+        /// <param name="x">The multiplicand.</param>
+        /// <param name="y">The multiplier.</param>
+        /// <returns>The product.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T Invoke(T x, T y) => x * y;
+
+        /// <summary>
+        /// Multiplies 128-bit vectors.
+        /// </summary>
+        /// <param name="x">The multiplicands.</param>
+        /// <param name="y">The multipliers.</param>
+        /// <returns>The products.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x * y;
+
+        /// <summary>
+        /// Multiplies 256-bit vectors.
+        /// </summary>
+        /// <param name="x">The multiplicands.</param>
+        /// <param name="y">The multipliers.</param>
+        /// <returns>The products.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x * y;
+
+        /// <summary>
+        /// Multiplies 512-bit vectors.
+        /// </summary>
+        /// <param name="x">The multiplicands.</param>
+        /// <param name="y">The multipliers.</param>
+        /// <returns>The products.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x * y;
+    }
+}

src/ImageSharp/Common/Helpers/TensorPrimitives_.Negate.cs

@@ -0,0 +1,332 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+internal static partial class TensorPrimitives_
+{
+    /// <summary>
+    /// Defines an element-wise unary operation.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private interface IUnaryOperator<T>
+    {
+        /// <summary>
+        /// Gets a value indicating whether the operation supports vector execution.
+        /// </summary>
+        public static abstract bool Vectorizable { get; }
+
+        /// <summary>
+        /// Applies the operation to a scalar value.
+        /// </summary>
+        /// <param name="x">The input value.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract T Invoke(T x);
+
+        /// <summary>
+        /// Applies the operation to a 128-bit vector.
+        /// </summary>
+        /// <param name="x">The input vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector128<T> Invoke(Vector128<T> x);
+
+        /// <summary>
+        /// Applies the operation to a 256-bit vector.
+        /// </summary>
+        /// <param name="x">The input vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector256<T> Invoke(Vector256<T> x);
+
+        /// <summary>
+        /// Applies the operation to a 512-bit vector.
+        /// </summary>
+        /// <param name="x">The input vector.</param>
+        /// <returns>The operation result.</returns>
+        public static abstract Vector512<T> Invoke(Vector512<T> x);
+    }
+
+    /// <summary>
+    /// Computes the element-wise negation of the values in <paramref name="x"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="x">The values to negate.</param>
+    /// <param name="destination">The destination for the negated values.</param>
+    /// <exception cref="ArgumentException"><paramref name="destination"/> is shorter than <paramref name="x"/>.</exception>
+    /// <exception cref="ArgumentException">
+    /// <paramref name="x"/> and <paramref name="destination"/> overlap without beginning at the same memory location.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Negate<T>(ReadOnlySpan<T> x, Span<T> destination)
+        where T : IUnaryNegationOperators<T, T>
+        => InvokeSpanIntoSpan<T, NegateOperator<T>>(x, destination);
+
+    /// <summary>
+    /// Performs an element-wise unary operation over a span.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="x">The input values.</param>
+    /// <param name="destination">The destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeSpanIntoSpan<T, TOperator>(ReadOnlySpan<T> x, Span<T> destination)
+        where TOperator : struct, IUnaryOperator<T>
+    {
+        if (x.Length > destination.Length)
+        {
+            ThrowDestinationTooShort();
+        }
+
+        ValidateInputOutputSpanNonOverlapping(x, destination);
+
+        ref T xRef = ref MemoryMarshal.GetReference(x);
+        ref T destinationRef = ref MemoryMarshal.GetReference(destination);
+        nuint length = (uint)x.Length;
+
+        // Runtime main selects the widest supported pipeline once one complete vector is available.
+        if (TOperator.Vectorizable
+            && Vector512.IsHardwareAccelerated
+            && Vector512<T>.IsSupported
+            && length >= (uint)Vector512<T>.Count)
+        {
+            InvokeUnaryVectorized512<T, TOperator>(ref xRef, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && length >= (uint)Vector256<T>.Count)
+        {
+            InvokeUnaryVectorized256<T, TOperator>(ref xRef, ref destinationRef, length);
+            return;
+        }
+
+        if (TOperator.Vectorizable && Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && length >= (uint)Vector128<T>.Count)
+        {
+            InvokeUnaryVectorized128<T, TOperator>(ref xRef, ref destinationRef, length);
+            return;
+        }
+
+        for (nuint i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref destinationRef, i) = TOperator.Invoke(Unsafe.Add(ref xRef, i));
+        }
+    }
+
+    /// <summary>
+    /// Applies a unary operation with 128-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeUnaryVectorized128<T, TOperator>(ref T xRef, ref T destinationRef, nuint length)
+        where TOperator : struct, IUnaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector128<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+
+        // The final vector overlaps the preceding store when the length is not a vector multiple. Loading it
+        // before any stores preserves same-start in-place operation because it captures the original tail.
+        Vector128<T> end = default;
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, length - vectorCount));
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 0))).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 1))).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 2))).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 3))).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 4))).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 5))).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 6))).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index + (vectorCount * 7))).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector128.LoadUnsafe(ref xRef, index)).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a unary operation with 256-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeUnaryVectorized256<T, TOperator>(ref T xRef, ref T destinationRef, nuint length)
+        where TOperator : struct, IUnaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector256<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector256<T> end = default;
+
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, length - vectorCount));
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 0))).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 1))).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 2))).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 3))).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 4))).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 5))).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 6))).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index + (vectorCount * 7))).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, index)).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Applies a unary operation with 512-bit vectors.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TOperator">The operation to apply.</typeparam>
+    /// <param name="xRef">The first input element.</param>
+    /// <param name="destinationRef">The first destination element.</param>
+    /// <param name="length">The number of elements to process.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void InvokeUnaryVectorized512<T, TOperator>(ref T xRef, ref T destinationRef, nuint length)
+        where TOperator : struct, IUnaryOperator<T>
+    {
+        nuint vectorCount = (uint)Vector512<T>.Count;
+        nuint vectorsPerLoop = vectorCount * 8;
+        nuint index = 0;
+        Vector512<T> end = default;
+
+        if ((length % vectorCount) != 0)
+        {
+            end = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, length - vectorCount));
+        }
+
+        while ((length - index) >= vectorsPerLoop)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 0))).StoreUnsafe(ref destinationRef, index + (vectorCount * 0));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 1))).StoreUnsafe(ref destinationRef, index + (vectorCount * 1));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 2))).StoreUnsafe(ref destinationRef, index + (vectorCount * 2));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 3))).StoreUnsafe(ref destinationRef, index + (vectorCount * 3));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 4))).StoreUnsafe(ref destinationRef, index + (vectorCount * 4));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 5))).StoreUnsafe(ref destinationRef, index + (vectorCount * 5));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 6))).StoreUnsafe(ref destinationRef, index + (vectorCount * 6));
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index + (vectorCount * 7))).StoreUnsafe(ref destinationRef, index + (vectorCount * 7));
+
+            index += vectorsPerLoop;
+        }
+
+        while ((length - index) >= vectorCount)
+        {
+            TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, index)).StoreUnsafe(ref destinationRef, index);
+            index += vectorCount;
+        }
+
+        if (index != length)
+        {
+            end.StoreUnsafe(ref destinationRef, length - vectorCount);
+        }
+    }
+
+    /// <summary>
+    /// Implements element-wise negation for scalar and SIMD inputs.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private readonly struct NegateOperator<T> : IUnaryOperator<T>
+        where T : IUnaryNegationOperators<T, T>
+    {
+        /// <inheritdoc />
+        public static bool Vectorizable => true;
+
+        /// <inheritdoc />
+        public static T Invoke(T x) => -x;
+
+        /// <inheritdoc />
+        public static Vector128<T> Invoke(Vector128<T> x)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                // IEEE-754 negation toggles the sign bit. Expressing that operation explicitly avoids the
+                // subtraction-based ARM64 code generated by .NET 8 for generic vector negation, which loses
+                // the sign when +0F is negated and therefore differs from both scalar and runtime-main behavior.
+                return x ^ Vector128.Create(-0F).As<float, T>();
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                // Double-precision values use the same sign-bit representation, with the sign in bit 63.
+                return x ^ Vector128.Create(-0D).As<double, T>();
+            }
+
+            return -x;
+        }
+
+        /// <inheritdoc />
+        public static Vector256<T> Invoke(Vector256<T> x)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                // Keep the operation bitwise at every width so ARM64 preserves signed zero exactly.
+                return x ^ Vector256.Create(-0F).As<float, T>();
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                return x ^ Vector256.Create(-0D).As<double, T>();
+            }
+
+            return -x;
+        }
+
+        /// <inheritdoc />
+        public static Vector512<T> Invoke(Vector512<T> x)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                // Vector512 can be hardware accelerated directly or decomposed by the runtime; the explicit
+                // bit operation provides identical IEEE-754 behavior in either case.
+                return x ^ Vector512.Create(-0F).As<float, T>();
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                return x ^ Vector512.Create(-0D).As<double, T>();
+            }
+
+            return -x;
+        }
+    }
+}

src/ImageSharp/Common/Helpers/Vector128Utilities.cs

@@ -1296,22 +1296,9 @@ internal static class Vector128_
             return PackedSimd.SubtractSaturate(left, right);
         }
 
-        // Widen inputs to 16-bit
+        // Subtracting the smaller operand implements the .NET 10 unsigned contract:
-        (Vector128<ushort> leftLo, Vector128<ushort> leftHi) = Vector128.Widen(left);
+        // lanes where right exceeds left subtract left from itself and therefore saturate at zero.
-        (Vector128<ushort> rightLo, Vector128<ushort> rightHi) = Vector128.Widen(right);
+        return left - Vector128.Min(left, right);
-
-        // Subtract
-        Vector128<ushort> diffLo = leftLo - rightLo;
-        Vector128<ushort> diffHi = leftHi - rightHi;
-
-        // Clamp to signed 8-bit range
-        Vector128<ushort> max = Vector128.Create((ushort)byte.MaxValue);
-
-        diffLo = Clamp(diffLo, Vector128<ushort>.Zero, max);
-        diffHi = Clamp(diffHi, Vector128<ushort>.Zero, max);
-
-        // Narrow back to bytes
-        return Vector128.Narrow(diffLo, diffHi);
     }
 
     /// <summary>

src/ImageSharp/Common/Helpers/Vector256Utilities.cs

@@ -495,9 +495,9 @@ internal static class Vector256_
             return Avx2.SubtractSaturate(left, right);
         }
 
-        return Vector256.Create(
+        // The .NET 10 portable implementation applies the same saturated operation to
-            Vector128_.SubtractSaturate(left.GetLower(), right.GetLower()),
+        // both 128-bit halves, allowing each half to select its native instruction set.
-            Vector128_.SubtractSaturate(left.GetUpper(), right.GetUpper()));
+        return Vector256.Create(Vector128_.SubtractSaturate(left.GetLower(), right.GetLower()), Vector128_.SubtractSaturate(left.GetUpper(), right.GetUpper()));
     }
 
     /// <summary>

src/ImageSharp/Common/Helpers/Vector512Utilities.cs

@@ -129,6 +129,26 @@ internal static class Vector512_
         return Vector512.Create(lower, upper);
     }
 
+    /// <summary>
+    /// Subtracts packed unsigned 8-bit integers in <paramref name="right"/> from
+    /// <paramref name="left"/>, saturating negative lane results to zero.
+    /// </summary>
+    /// <param name="left">The vector from which <paramref name="right"/> is subtracted.</param>
+    /// <param name="right">The vector to subtract from <paramref name="left"/>.</param>
+    /// <returns>The element-wise saturated differences.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> SubtractSaturate(Vector512<byte> left, Vector512<byte> right)
+    {
+        if (Avx512BW.IsSupported)
+        {
+            return Avx512BW.SubtractSaturate(left, right);
+        }
+
+        // This mirrors the .NET 10 portable implementation: recursively processing both
+        // 256-bit halves preserves lane order and lets each half select its available ISA.
+        return Vector512.Create(Vector256_.SubtractSaturate(left.GetLower(), right.GetLower()), Vector256_.SubtractSaturate(left.GetUpper(), right.GetUpper()));
+    }
+
     /// <summary>
     /// Performs a multiplication and a negated addition of the <see cref="Vector512{Single}"/>.
     /// </summary>

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

@@ -0,0 +1,168 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Implements inverted JPEG CMYK conversion for scalar and SIMD lanes.
+    /// </summary>
+    internal readonly struct CmykOperator : IJpegColorConverterOperator
+    {
+        /// <inheritdoc/>
+        public static JpegColorSpace ColorSpace => JpegColorSpace.Cmyk;
+
+        /// <inheritdoc/>
+        public static int ComponentCount => 4;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale)
+        {
+            // Adobe-style CMYK stores inverted component samples. Multiplying K by scale twice folds the
+            // two sample-domain divisions into one factor before it modulates the C, M, and Y planes.
+            float scaledK = c3 * scale * scale;
+            c0 *= scaledK;
+            c1 *= scaledK;
+            c2 *= scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale)
+        {
+            // Each K lane supplies the common modulation factor for the corresponding C, M, and Y lanes.
+            Vector128<float> scaledK = c3 * scale * scale;
+            c0 *= scaledK;
+            c1 *= scaledK;
+            c2 *= scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale)
+        {
+            // Eight independent CMYK samples remain lane-aligned throughout the modulation.
+            Vector256<float> scaledK = c3 * scale * scale;
+            c0 *= scaledK;
+            c1 *= scaledK;
+            c2 *= scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale)
+        {
+            // Sixteen independent CMYK samples remain lane-aligned throughout the modulation.
+            Vector512<float> scaledK = c3 * scale * scale;
+            c0 *= scaledK;
+            c1 *= scaledK;
+            c2 *= scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3)
+        {
+            float c = maximumValue - r;
+            float m = maximumValue - g;
+            float y = maximumValue - b;
+            float k = MathF.Min(c, MathF.Min(m, y));
+
+            // Pure black makes the chromatic divisor zero. In that case chromatic ink is defined as zero;
+            // otherwise remove K and normalize the remaining C, M, and Y contributions.
+            if (k >= maximumValue)
+            {
+                c = 0;
+                m = 0;
+                y = 0;
+            }
+            else
+            {
+                // The same remaining range normalizes every chromatic channel. Computing its reciprocal once
+                // replaces three divisions with one division and three multiplies.
+                float reciprocal = 1F / (maximumValue - k);
+                c = (c - k) * reciprocal;
+                m = (m - k) * reciprocal;
+                y = (y - k) * reciprocal;
+            }
+
+            // JPEG CMYK is inverted, including K, so normalized chromatic values are reflected around max.
+            c0 = maximumValue - (c * maximumValue);
+            c1 = maximumValue - (m * maximumValue);
+            c2 = maximumValue - (y * maximumValue);
+            c3 = maximumValue - k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3)
+        {
+            Vector128<float> c = maximumValue - r;
+            Vector128<float> m = maximumValue - g;
+            Vector128<float> y = maximumValue - b;
+            Vector128<float> k = Vector128.Min(c, Vector128.Min(m, y));
+
+            // The all-bits mask clears the undefined zero-divisor result for pure-black lanes without a branch.
+            Vector128<float> nonBlack = ~Vector128.Equals(k, maximumValue);
+            Vector128<float> reciprocal = Vector128<float>.One / (maximumValue - k);
+            c = ((c - k) * reciprocal) & nonBlack;
+            m = ((m - k) * reciprocal) & nonBlack;
+            y = ((y - k) * reciprocal) & nonBlack;
+
+            c0 = maximumValue - (c * maximumValue);
+            c1 = maximumValue - (m * maximumValue);
+            c2 = maximumValue - (y * maximumValue);
+            c3 = maximumValue - k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3)
+        {
+            Vector256<float> c = maximumValue - r;
+            Vector256<float> m = maximumValue - g;
+            Vector256<float> y = maximumValue - b;
+            Vector256<float> k = Vector256.Min(c, Vector256.Min(m, y));
+
+            // Masking preserves lane independence when a vector mixes pure black with chromatic pixels.
+            Vector256<float> nonBlack = ~Vector256.Equals(k, maximumValue);
+            Vector256<float> reciprocal = Vector256<float>.One / (maximumValue - k);
+            c = ((c - k) * reciprocal) & nonBlack;
+            m = ((m - k) * reciprocal) & nonBlack;
+            y = ((y - k) * reciprocal) & nonBlack;
+
+            c0 = maximumValue - (c * maximumValue);
+            c1 = maximumValue - (m * maximumValue);
+            c2 = maximumValue - (y * maximumValue);
+            c3 = maximumValue - k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3)
+        {
+            Vector512<float> c = maximumValue - r;
+            Vector512<float> m = maximumValue - g;
+            Vector512<float> y = maximumValue - b;
+            Vector512<float> k = Vector512.Min(c, Vector512.Min(m, y));
+
+            // AVX-512 still uses a full floating-point mask value here because bitwise clearing exactly matches
+            // the narrower operator semantics and lets the JIT select the most suitable native instructions.
+            Vector512<float> nonBlack = ~Vector512.Equals(k, maximumValue);
+            Vector512<float> reciprocal = Vector512<float>.One / (maximumValue - k);
+            c = ((c - k) * reciprocal) & nonBlack;
+            m = ((m - k) * reciprocal) & nonBlack;
+            y = ((y - k) * reciprocal) & nonBlack;
+
+            c0 = maximumValue - (c * maximumValue);
+            c1 = maximumValue - (m * maximumValue);
+            c2 = maximumValue - (y * maximumValue);
+            c3 = maximumValue - k;
+        }
+    }
+}

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

@@ -1,116 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.ColorProfiles;
-using SixLabors.ImageSharp.ColorProfiles.Icc;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class CmykScalar : JpegColorConverterScalar
-    {
-        public CmykScalar(int precision)
-            : base(JpegColorSpace.Cmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values) =>
-            ConvertToRgbInPlace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(values, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue)
-        {
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            float scale = 1 / (maxValue * maxValue);
-            for (int i = 0; i < c0.Length; i++)
-            {
-                float c = c0[i];
-                float m = c1[i];
-                float y = c2[i];
-                float k = c3[i];
-
-                k *= scale;
-                c0[i] = c * k;
-                c1[i] = m * k;
-                c2[i] = y * k;
-            }
-        }
-
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            Span<float> c = values.Component0;
-            Span<float> m = values.Component1;
-            Span<float> y = values.Component2;
-            Span<float> k = values.Component3;
-
-            for (int i = 0; i < c.Length; i++)
-            {
-                float ctmp = 255f - rLane[i];
-                float mtmp = 255f - gLane[i];
-                float ytmp = 255f - bLane[i];
-                float ktmp = MathF.Min(MathF.Min(ctmp, mtmp), ytmp);
-
-                if (ktmp >= 255f)
-                {
-                    ctmp = 0f;
-                    mtmp = 0f;
-                    ytmp = 0f;
-                }
-                else
-                {
-                    ctmp = (ctmp - ktmp) / (255f - ktmp);
-                    mtmp = (mtmp - ktmp) / (255f - ktmp);
-                    ytmp = (ytmp - ktmp) / (255f - ktmp);
-                }
-
-                c[i] = maxValue - (ctmp * maxValue);
-                m[i] = maxValue - (mtmp * maxValue);
-                y[i] = maxValue - (ytmp * maxValue);
-                k[i] = maxValue - ktmp;
-            }
-        }
-
-        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
-        {
-            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
-            Span<float> packed = memoryOwner.Memory.Span;
-
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            PackedInvertNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
-
-            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
-            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
-
-            ColorConversionOptions options = new()
-            {
-                SourceIccProfile = profile,
-                TargetIccProfile = CompactSrgbV4Profile.Profile,
-            };
-            ColorProfileConverter converter = new(options);
-            converter.Convert<Cmyk, Rgb>(source, destination);
-
-            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
-        }
-    }
-}

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

@@ -1,100 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class CmykVector128 : JpegColorConverterVector128
-    {
-        public CmykVector128(int precision)
-            : base(JpegColorSpace.Cmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector128<float> c0Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> c1Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> c2Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> c3Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            Vector128<float> scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector128<float> c = ref Unsafe.Add(ref c0Base, i);
-                ref Vector128<float> m = ref Unsafe.Add(ref c1Base, i);
-                ref Vector128<float> y = ref Unsafe.Add(ref c2Base, i);
-                Vector128<float> k = Unsafe.Add(ref c3Base, i);
-
-                k *= scale;
-                c *= k;
-                m *= k;
-                y *= k;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector128<float> destC =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> destM =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> destY =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> destK =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector128<float> srcR =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector128<float> srcG =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector128<float> srcB =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector128<float> scale = Vector128.Create(maxValue);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector128<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector128<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector128<float> ktmp = Vector128.Min(ctmp, Vector128.Min(mtmp, ytmp));
-
-                Vector128<float> kMask = ~Vector128.Equals(ktmp, scale);
-                Vector128<float> divisor = scale - ktmp;
-
-                ctmp = ((ctmp - ktmp) / divisor) & kMask;
-                mtmp = ((mtmp - ktmp) / divisor) & kMask;
-                ytmp = ((ytmp - ktmp) / divisor) & kMask;
-
-                Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
-                Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
-                Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
-                Unsafe.Add(ref destK, i) = scale - ktmp;
-            }
-        }
-    }
-}

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

@@ -1,100 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class CmykVector256 : JpegColorConverterVector256
-    {
-        public CmykVector256(int precision)
-            : base(JpegColorSpace.Cmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector256<float> c0Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> c1Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> c2Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector256<float> c3Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            Vector256<float> scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector256<float> c = ref Unsafe.Add(ref c0Base, i);
-                ref Vector256<float> m = ref Unsafe.Add(ref c1Base, i);
-                ref Vector256<float> y = ref Unsafe.Add(ref c2Base, i);
-                Vector256<float> k = Unsafe.Add(ref c3Base, i);
-
-                k *= scale;
-                c *= k;
-                m *= k;
-                y *= k;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector256<float> destC =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> destM =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> destY =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector256<float> destK =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector256<float> srcR =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector256<float> srcG =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector256<float> srcB =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector256<float> scale = Vector256.Create(maxValue);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector256<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector256<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector256<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector256<float> ktmp = Vector256.Min(ctmp, Vector256.Min(mtmp, ytmp));
-
-                Vector256<float> kMask = ~Vector256.Equals(ktmp, scale);
-                Vector256<float> divisor = scale - ktmp;
-
-                ctmp = ((ctmp - ktmp) / divisor) & kMask;
-                mtmp = ((mtmp - ktmp) / divisor) & kMask;
-                ytmp = ((ytmp - ktmp) / divisor) & kMask;
-
-                Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
-                Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
-                Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
-                Unsafe.Add(ref destK, i) = scale - ktmp;
-            }
-        }
-    }
-}

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

@@ -1,108 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class CmykVector512 : JpegColorConverterVector512
-    {
-        public CmykVector512(int precision)
-            : base(JpegColorSpace.Cmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
-        {
-            ref Vector512<float> c0Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> c1Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> c2Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector512<float> c3Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            Vector512<float> scale = Vector512.Create(1 / (this.MaximumValue * this.MaximumValue));
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector512<float> c = ref Unsafe.Add(ref c0Base, i);
-                ref Vector512<float> m = ref Unsafe.Add(ref c1Base, i);
-                ref Vector512<float> y = ref Unsafe.Add(ref c2Base, i);
-                Vector512<float> k = Unsafe.Add(ref c3Base, i);
-
-                k *= scale;
-                c *= k;
-                m *= k;
-                y *= k;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgbVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
-             => CmykScalar.ConvertToRgbInPlace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => CmykScalar.ConvertFromRgb(values, this.MaximumValue, rLane, gLane, bLane);
-
-        internal static void ConvertFromRgbVectorized(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector512<float> destC =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> destM =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> destY =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector512<float> destK =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector512<float> srcR =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector512<float> srcG =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector512<float> srcB =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector512<float> scale = Vector512.Create(maxValue);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector512<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector512<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector512<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector512<float> ktmp = Vector512.Min(ctmp, Vector512.Min(mtmp, ytmp));
-
-                Vector512<float> kMask = ~Vector512.Equals(ktmp, scale);
-                Vector512<float> divisor = scale - ktmp;
-
-                ctmp = ((ctmp - ktmp) / divisor) & kMask;
-                mtmp = ((mtmp - ktmp) / divisor) & kMask;
-                ytmp = ((ytmp - ktmp) / divisor) & kMask;
-
-                Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
-                Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
-                Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
-                Unsafe.Add(ref destK, i) = scale - ktmp;
-            }
-        }
-    }
-}

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

@@ -0,0 +1,117 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Implements grayscale expansion and RGB luminance reduction for scalar and SIMD lanes.
+    /// </summary>
+    internal readonly struct GrayScaleOperator : IJpegColorConverterOperator
+    {
+        /// <inheritdoc/>
+        public static JpegColorSpace ColorSpace => JpegColorSpace.Grayscale;
+
+        /// <inheritdoc/>
+        public static int ComponentCount => 1;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale)
+        {
+            // JPEG stores luminance in the integer sample domain. Normalize it once, then duplicate the
+            // same value into all three RGB planes. Keeping it local also prevents potentially aliasing
+            // byref stores from forcing the JIT to reload c0 between assignments.
+            float luminance = c0 * scale;
+            c0 = luminance;
+            c1 = luminance;
+            c2 = luminance;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale)
+        {
+            // Each XMM lane is one independent luminance sample. Reusing the normalized vector for R, G,
+            // and B avoids recomputing the scale and keeps it live across potentially aliasing byref stores.
+            Vector128<float> luminance = c0 * scale;
+            c0 = luminance;
+            c1 = luminance;
+            c2 = luminance;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale)
+        {
+            // Eight luminance samples occupy the YMM lanes. The local retains the normalized vector across
+            // all three output stores even when the destination planes alias.
+            Vector256<float> luminance = c0 * scale;
+            c0 = luminance;
+            c1 = luminance;
+            c2 = luminance;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale)
+        {
+            // Sixteen luminance samples occupy the ZMM lanes. The local retains the normalized vector across
+            // all three output stores without shuffles, interleaving, or source reloads.
+            Vector512<float> luminance = c0 * scale;
+            c0 = luminance;
+            c1 = luminance;
+            c2 = luminance;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3)
+        {
+            // Rec.601 luma weights operate directly in the encoder sample domain. Only c0 is stored for a
+            // one-component model; the remaining out values exist solely to satisfy the common operator shape.
+            c0 = (0.299F * r) + (0.587F * g) + (0.114F * b);
+            c1 = 0;
+            c2 = 0;
+            c3 = 0;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3)
+        {
+            // The nested estimate gives each pixel the same multiply-add grouping as the scalar Rec.601 formula.
+            c0 = Vector128_.MultiplyAddEstimate(Vector128.Create(0.299F), r, Vector128_.MultiplyAddEstimate(Vector128.Create(0.587F), g, Vector128.Create(0.114F) * b));
+            c1 = default;
+            c2 = default;
+            c3 = default;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3)
+        {
+            // YMM lanes evaluate the same Rec.601 equation independently, with no horizontal lane reduction.
+            c0 = Vector256_.MultiplyAddEstimate(Vector256.Create(0.299F), r, Vector256_.MultiplyAddEstimate(Vector256.Create(0.587F), g, Vector256.Create(0.114F) * b));
+            c1 = default;
+            c2 = default;
+            c3 = default;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3)
+        {
+            // ZMM lanes retain the same arithmetic order as narrower paths so only SIMD width changes.
+            c0 = Vector512_.MultiplyAddEstimate(Vector512.Create(0.299F), r, Vector512_.MultiplyAddEstimate(Vector512.Create(0.587F), g, Vector512.Create(0.114F) * b));
+            c1 = default;
+            c2 = default;
+            c3 = default;
+        }
+    }
+}

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

@@ -1,97 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.ColorProfiles;
-using SixLabors.ImageSharp.ColorProfiles.Icc;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class GrayScaleScalar : JpegColorConverterScalar
-    {
-        public GrayScaleScalar(int precision)
-            : base(JpegColorSpace.Grayscale, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-            => ConvertToRgbInPlace(in values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgbScalar(values, rLane, gLane, bLane);
-
-        internal static void ConvertToRgbInPlace(in ComponentValues values, float maxValue)
-        {
-            ref float c0Base = ref MemoryMarshal.GetReference(values.Component0);
-            ref float c1Base = ref MemoryMarshal.GetReference(values.Component1);
-            ref float c2Base = ref MemoryMarshal.GetReference(values.Component2);
-
-            float scale = 1F / maxValue;
-            for (nuint i = 0; i < (nuint)values.Component0.Length; i++)
-            {
-                float c = Unsafe.Add(ref c0Base, i) * scale;
-
-                Unsafe.Add(ref c0Base, i) = c;
-                Unsafe.Add(ref c1Base, i) = c;
-                Unsafe.Add(ref c2Base, i) = c;
-            }
-        }
-
-        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
-        {
-            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 3);
-            Span<float> packed = memoryOwner.Memory.Span;
-
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-
-            ref float c0Base = ref MemoryMarshal.GetReference(c0);
-            ref float c1Base = ref MemoryMarshal.GetReference(c1);
-            ref float c2Base = ref MemoryMarshal.GetReference(c2);
-
-            float scale = 1F / maxValue;
-            for (nuint i = 0; i < (nuint)values.Component0.Length; i++)
-            {
-                ref float c = ref Unsafe.Add(ref c0Base, i);
-                c *= scale;
-            }
-
-            Span<Y> source = MemoryMarshal.Cast<float, Y>(values.Component0);
-            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed);
-
-            ColorConversionOptions options = new()
-            {
-                SourceIccProfile = profile,
-                TargetIccProfile = CompactSrgbV4Profile.Profile,
-            };
-            ColorProfileConverter converter = new(options);
-            converter.Convert<Y, Rgb>(source, destination);
-
-            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
-        }
-
-        internal static void ConvertFromRgbScalar(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            Span<float> c0 = values.Component0;
-
-            for (int i = 0; i < c0.Length; i++)
-            {
-                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                c0[i] = (float)((0.299f * rLane[i]) + (0.587f * gLane[i]) + (0.114f * bLane[i]));
-            }
-        }
-    }
-}

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

@@ -1,81 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class GrayScaleVector128 : JpegColorConverterVector128
-    {
-        public GrayScaleVector128(int precision)
-            : base(JpegColorSpace.Grayscale, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => GrayScaleScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector128<float> c0Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector128<float> c1Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-
-            ref Vector128<float> c2Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            // Used for the color conversion
-            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> c = Unsafe.Add(ref c0Base, i) * scale;
-
-                Unsafe.Add(ref c0Base, i) = c;
-                Unsafe.Add(ref c1Base, i) = c;
-                Unsafe.Add(ref c2Base, i) = c;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector128<float> destLuminance =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector128<float> srcRed =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector128<float> srcGreen =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector128<float> srcBlue =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            // Used for the color conversion
-            Vector128<float> f0299 = Vector128.Create(0.299f);
-            Vector128<float> f0587 = Vector128.Create(0.587f);
-            Vector128<float> f0114 = Vector128.Create(0.114f);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector128<float> r = ref Unsafe.Add(ref srcRed, i);
-                ref Vector128<float> g = ref Unsafe.Add(ref srcGreen, i);
-                ref Vector128<float> b = ref Unsafe.Add(ref srcBlue, i);
-
-                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuminance, i) = Vector128_.MultiplyAddEstimate(f0299, r, Vector128_.MultiplyAddEstimate(f0587, g, f0114 * b));
-            }
-        }
-    }
-}

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

@@ -1,81 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class GrayScaleVector256 : JpegColorConverterVector256
-    {
-        public GrayScaleVector256(int precision)
-            : base(JpegColorSpace.Grayscale, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector256<float> c0Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector256<float> c1Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-
-            ref Vector256<float> c2Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            // Used for the color conversion
-            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector256<float> c = Unsafe.Add(ref c0Base, i) * scale;
-
-                Unsafe.Add(ref c0Base, i) = c;
-                Unsafe.Add(ref c1Base, i) = c;
-                Unsafe.Add(ref c2Base, i) = c;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => GrayScaleScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector256<float> destLuminance =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector256<float> srcRed =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector256<float> srcGreen =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector256<float> srcBlue =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            // Used for the color conversion
-            Vector256<float> f0299 = Vector256.Create(0.299f);
-            Vector256<float> f0587 = Vector256.Create(0.587f);
-            Vector256<float> f0114 = Vector256.Create(0.114f);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector256<float> r = ref Unsafe.Add(ref srcRed, i);
-                ref Vector256<float> g = ref Unsafe.Add(ref srcGreen, i);
-                ref Vector256<float> b = ref Unsafe.Add(ref srcBlue, i);
-
-                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuminance, i) = Vector256_.MultiplyAddEstimate(f0299, r, Vector256_.MultiplyAddEstimate(f0587, g, f0114 * b));
-            }
-        }
-    }
-}

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

@@ -1,89 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class GrayScaleVector512 : JpegColorConverterVector512
-    {
-        public GrayScaleVector512(int precision)
-            : base(JpegColorSpace.Grayscale, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => GrayScaleScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
-        {
-            ref Vector512<float> c0Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector512<float> c1Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-
-            ref Vector512<float> c2Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            // Used for the color conversion
-            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector512<float> c = Unsafe.Add(ref c0Base, i) * scale;
-
-                Unsafe.Add(ref c0Base, i) = c;
-                Unsafe.Add(ref c1Base, i) = c;
-                Unsafe.Add(ref c2Base, i) = c;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector512<float> destLuminance =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector512<float> srcRed =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector512<float> srcGreen =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector512<float> srcBlue =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            // Used for the color conversion
-            Vector512<float> f0299 = Vector512.Create(0.299f);
-            Vector512<float> f0587 = Vector512.Create(0.587f);
-            Vector512<float> f0114 = Vector512.Create(0.114f);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector512<float> r = ref Unsafe.Add(ref srcRed, i);
-                ref Vector512<float> g = ref Unsafe.Add(ref srcGreen, i);
-                ref Vector512<float> b = ref Unsafe.Add(ref srcBlue, i);
-
-                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuminance, i) = Vector512_.MultiplyAddEstimate(f0299, r, Vector512_.MultiplyAddEstimate(f0587, g, f0114 * b));
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
-            => GrayScaleScalar.ConvertToRgbInPlace(in values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => GrayScaleScalar.ConvertFromRgbScalar(values, rLane, gLane, bLane);
-    }
-}

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

@@ -0,0 +1,449 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Defines the color-model-specific arithmetic used by <see cref="JpegColorConverter{TOperator}"/>.
+    /// </summary>
+    /// <remarks>
+    /// Each overload describes the same lane-wise transform. The generic traversal selects the widest
+    /// available overload and the JIT resolves these static interface calls for each closed converter type.
+    /// </remarks>
+    internal interface IJpegColorConverterOperator
+    {
+        /// <summary>
+        /// Gets the JPEG color space handled by the operator.
+        /// </summary>
+        public static abstract JpegColorSpace ColorSpace { get; }
+
+        /// <summary>
+        /// Gets the number of component planes used by the color space.
+        /// </summary>
+        public static abstract int ComponentCount { get; }
+
+        /// <summary>
+        /// Converts one JPEG sample to normalized RGB.
+        /// </summary>
+        /// <param name="c0">The first component, replaced by red.</param>
+        /// <param name="c1">The second component, replaced by green.</param>
+        /// <param name="c2">The third component, replaced by blue.</param>
+        /// <param name="c3">The fourth component, or zero for a three-component color space.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/>.</param>
+        public static abstract void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale);
+
+        /// <summary>
+        /// Converts four JPEG samples to normalized RGB.
+        /// </summary>
+        /// <param name="c0">The first component lanes, replaced by red.</param>
+        /// <param name="c1">The second component lanes, replaced by green.</param>
+        /// <param name="c2">The third component lanes, replaced by blue.</param>
+        /// <param name="c3">The fourth component lanes, or zero for a three-component color space.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/> in every lane.</param>
+        public static abstract void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale);
+
+        /// <summary>
+        /// Converts eight JPEG samples to normalized RGB.
+        /// </summary>
+        /// <param name="c0">The first component lanes, replaced by red.</param>
+        /// <param name="c1">The second component lanes, replaced by green.</param>
+        /// <param name="c2">The third component lanes, replaced by blue.</param>
+        /// <param name="c3">The fourth component lanes, or zero for a three-component color space.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/> in every lane.</param>
+        public static abstract void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale);
+
+        /// <summary>
+        /// Converts sixteen JPEG samples to normalized RGB.
+        /// </summary>
+        /// <param name="c0">The first component lanes, replaced by red.</param>
+        /// <param name="c1">The second component lanes, replaced by green.</param>
+        /// <param name="c2">The third component lanes, replaced by blue.</param>
+        /// <param name="c3">The fourth component lanes, or zero for a three-component color space.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/> in every lane.</param>
+        public static abstract void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale);
+
+        /// <summary>
+        /// Converts one RGB sample to JPEG components.
+        /// </summary>
+        /// <param name="r">The red value.</param>
+        /// <param name="g">The green value.</param>
+        /// <param name="b">The blue value.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/>.</param>
+        /// <param name="c0">The first converted component.</param>
+        /// <param name="c1">The second converted component.</param>
+        /// <param name="c2">The third converted component.</param>
+        /// <param name="c3">The fourth converted component, if used.</param>
+        public static abstract void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3);
+
+        /// <summary>
+        /// Converts four RGB samples to JPEG components.
+        /// </summary>
+        /// <param name="r">The red lanes.</param>
+        /// <param name="g">The green lanes.</param>
+        /// <param name="b">The blue lanes.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/> in every lane.</param>
+        /// <param name="c0">The first converted component lanes.</param>
+        /// <param name="c1">The second converted component lanes.</param>
+        /// <param name="c2">The third converted component lanes.</param>
+        /// <param name="c3">The fourth converted component lanes, if used.</param>
+        public static abstract void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3);
+
+        /// <summary>
+        /// Converts eight RGB samples to JPEG components.
+        /// </summary>
+        /// <param name="r">The red lanes.</param>
+        /// <param name="g">The green lanes.</param>
+        /// <param name="b">The blue lanes.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/> in every lane.</param>
+        /// <param name="c0">The first converted component lanes.</param>
+        /// <param name="c1">The second converted component lanes.</param>
+        /// <param name="c2">The third converted component lanes.</param>
+        /// <param name="c3">The fourth converted component lanes, if used.</param>
+        public static abstract void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3);
+
+        /// <summary>
+        /// Converts sixteen RGB samples to JPEG components.
+        /// </summary>
+        /// <param name="r">The red lanes.</param>
+        /// <param name="g">The green lanes.</param>
+        /// <param name="b">The blue lanes.</param>
+        /// <param name="maximumValue">The maximum component value for the configured precision.</param>
+        /// <param name="halfValue">The midpoint component value for the configured precision.</param>
+        /// <param name="scale">The reciprocal of <paramref name="maximumValue"/> in every lane.</param>
+        /// <param name="c0">The first converted component lanes.</param>
+        /// <param name="c1">The second converted component lanes.</param>
+        /// <param name="c2">The third converted component lanes.</param>
+        /// <param name="c3">The fourth converted component lanes, if used.</param>
+        public static abstract void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3);
+    }
+
+    /// <summary>
+    /// Converts a JPEG color model using a single operator-driven traversal for all SIMD widths.
+    /// </summary>
+    /// <typeparam name="TOperator">The color-model-specific arithmetic.</typeparam>
+    internal sealed class JpegColorConverter<TOperator> : JpegColorConverterBase
+        where TOperator : struct, IJpegColorConverterOperator
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JpegColorConverter{TOperator}"/> class.
+        /// </summary>
+        /// <param name="precision">The precision in bits.</param>
+        public JpegColorConverter(int precision)
+            : base(TOperator.ColorSpace, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool IsAvailable => true;
+
+        /// <inheritdoc/>
+        public override int ElementsPerBatch
+            => Vector512.IsHardwareAccelerated ? Vector512<float>.Count : Vector256.IsHardwareAccelerated ? Vector256<float>.Count : Vector128.IsHardwareAccelerated ? Vector128<float>.Count : 1;
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+        {
+            // JPEG component processors own equally sized planar buffers. Capturing their first elements
+            // as byrefs lets every width share the same offset without introducing Span bounds checks in
+            // the hot loops. Component3 may be empty; its byref is only dereferenced for four-component operators.
+            ref float c0Base = ref MemoryMarshal.GetReference(values.Component0);
+            ref float c1Base = ref MemoryMarshal.GetReference(values.Component1);
+            ref float c2Base = ref MemoryMarshal.GetReference(values.Component2);
+            ref float c3Base = ref MemoryMarshal.GetReference(values.Component3);
+
+            int length = values.Component0.Length;
+            int i = 0;
+            float scale = 1F / this.MaximumValue;
+
+            // Descending widths keep one traversal while allowing an AVX-512 machine to process
+            // an eight-pixel JPEG block with AVX2 rather than sending the entire block to scalar code.
+            if (Vector512.IsHardwareAccelerated)
+            {
+                // Subtracting the lane count turns the loop condition into a single signed comparison.
+                // A negative value naturally skips this width, and i <= end proves every unaligned
+                // 64-byte reinterpretation remains entirely inside its component buffer.
+                int oneVectorFromEnd = length - Vector512<float>.Count;
+
+                if (i <= oneVectorFromEnd)
+                {
+                    // Precision-derived values are broadcast only when this width has work. Keeping them outside
+                    // the loop avoids repeated setup without penalizing rows handled entirely by narrower widths.
+                    Vector512<float> maximumValue = Vector512.Create(this.MaximumValue);
+                    Vector512<float> halfValue = Vector512.Create(this.HalfValue);
+                    Vector512<float> scaleVector = Vector512.Create(scale);
+
+                    for (; i <= oneVectorFromEnd; i += Vector512<float>.Count)
+                    {
+                        ref Vector512<float> c0 = ref Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c0Base, i));
+                        ref Vector512<float> c1 = ref Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c1Base, i));
+                        ref Vector512<float> c2 = ref Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c2Base, i));
+
+                        // ComponentCount is a static property on the closed operator type, so the JIT removes
+                        // this choice. Three-component models never dereference the empty Component3 byref.
+                        Vector512<float> c3 = TOperator.ComponentCount == 4 ? Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c3Base, i)) : default;
+
+                        // c0-c2 alias the planar source vectors and are replaced in place with normalized RGB.
+                        // c3 is passed by value because the fourth JPEG component must remain unchanged.
+                        TOperator.ConvertToRgb(ref c0, ref c1, ref c2, c3, maximumValue, halfValue, scaleVector);
+                    }
+                }
+            }
+
+            if (Vector256.IsHardwareAccelerated)
+            {
+                // The shared offset continues where AVX-512 stopped. At this point fewer than sixteen
+                // samples remain, so this stage consumes the complete eight-sample remainder when present.
+                int oneVectorFromEnd = length - Vector256<float>.Count;
+
+                if (i <= oneVectorFromEnd)
+                {
+                    // YMM precision state is materialized only for an eight-sample remainder or an AVX2-only loop.
+                    Vector256<float> maximumValue = Vector256.Create(this.MaximumValue);
+                    Vector256<float> halfValue = Vector256.Create(this.HalfValue);
+                    Vector256<float> scaleVector = Vector256.Create(scale);
+
+                    for (; i <= oneVectorFromEnd; i += Vector256<float>.Count)
+                    {
+                        ref Vector256<float> c0 = ref Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c0Base, i));
+                        ref Vector256<float> c1 = ref Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c1Base, i));
+                        ref Vector256<float> c2 = ref Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c2Base, i));
+
+                        // The closed operator makes this a compile-time color-model choice, not a per-vector
+                        // runtime abstraction or interface dispatch.
+                        Vector256<float> c3 = TOperator.ComponentCount == 4 ? Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c3Base, i)) : default;
+
+                        TOperator.ConvertToRgb(ref c0, ref c1, ref c2, c3, maximumValue, halfValue, scaleVector);
+                    }
+                }
+            }
+
+            if (Vector128.IsHardwareAccelerated)
+            {
+                // SSE/AdvSimd handles the final four complete samples. This also gives non-AVX machines
+                // the same traversal without duplicating the control flow for another register width.
+                int oneVectorFromEnd = length - Vector128<float>.Count;
+
+                if (i <= oneVectorFromEnd)
+                {
+                    // XMM state is likewise created only when four samples remain for this stage.
+                    Vector128<float> maximumValue = Vector128.Create(this.MaximumValue);
+                    Vector128<float> halfValue = Vector128.Create(this.HalfValue);
+                    Vector128<float> scaleVector = Vector128.Create(scale);
+
+                    for (; i <= oneVectorFromEnd; i += Vector128<float>.Count)
+                    {
+                        ref Vector128<float> c0 = ref Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c0Base, i));
+                        ref Vector128<float> c1 = ref Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c1Base, i));
+                        ref Vector128<float> c2 = ref Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c2Base, i));
+
+                        // As at the wider stages, the fourth vector is loaded only for CMYK-shaped operators.
+                        Vector128<float> c3 = TOperator.ComponentCount == 4 ? Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c3Base, i)) : default;
+
+                        TOperator.ConvertToRgb(ref c0, ref c1, ref c2, c3, maximumValue, halfValue, scaleVector);
+                    }
+                }
+            }
+
+            // Fewer than four samples remain after the SIMD cascade. Processing from the shared offset
+            // guarantees each sample is visited exactly once for arbitrary test lengths and JPEG block rows.
+            for (; i < length; i++)
+            {
+                float c3 = TOperator.ComponentCount == 4 ? Unsafe.Add(ref c3Base, i) : 0;
+
+                TOperator.ConvertToRgb(ref Unsafe.Add(ref c0Base, i), ref Unsafe.Add(ref c1Base, i), ref Unsafe.Add(ref c2Base, i), c3, this.MaximumValue, this.HalfValue, scale);
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            // The encoder supplies equally sized RGB planes and destination component planes. Byrefs preserve
+            // contiguous access and allow the same proven vector boundary to govern every participating lane.
+            // Component3 is empty for three-component formats and is only written by four-component operators.
+            ref float c0Base = ref MemoryMarshal.GetReference(values.Component0);
+            ref float c1Base = ref MemoryMarshal.GetReference(values.Component1);
+            ref float c2Base = ref MemoryMarshal.GetReference(values.Component2);
+            ref float c3Base = ref MemoryMarshal.GetReference(values.Component3);
+            ref float rBase = ref MemoryMarshal.GetReference(rLane);
+            ref float gBase = ref MemoryMarshal.GetReference(gLane);
+            ref float bBase = ref MemoryMarshal.GetReference(bLane);
+
+            int length = values.Component0.Length;
+            int i = 0;
+            float scale = 1F / this.MaximumValue;
+
+            // Each vector overload returns planar component vectors. Storing them here keeps the
+            // operator concerned only with color arithmetic and preserves contiguous lane access.
+            if (Vector512.IsHardwareAccelerated)
+            {
+                // The end offset proves all three 64-byte RGB reads and all component writes are in range.
+                // A short row yields a negative end and falls through to the next supported width.
+                int oneVectorFromEnd = length - Vector512<float>.Count;
+
+                if (i <= oneVectorFromEnd)
+                {
+                    // Operators receive width-matched precision state only when this width has work, keeping
+                    // invariant broadcasts outside the loop without charging narrower or scalar rows for them.
+                    Vector512<float> maximumValue = Vector512.Create(this.MaximumValue);
+                    Vector512<float> halfValue = Vector512.Create(this.HalfValue);
+                    Vector512<float> scaleVector = Vector512.Create(scale);
+
+                    for (; i <= oneVectorFromEnd; i += Vector512<float>.Count)
+                    {
+                        Vector512<float> r = Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref rBase, i));
+                        Vector512<float> g = Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref gBase, i));
+                        Vector512<float> b = Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref bBase, i));
+
+                        TOperator.ConvertFromRgb(r, g, b, maximumValue, halfValue, scaleVector, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3);
+
+                        // Outputs remain planar: each vector contains sixteen consecutive samples from one
+                        // JPEG component. Static count checks prevent grayscale from touching absent planes
+                        // while disappearing completely from three- and four-component specializations.
+                        Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c0Base, i)) = c0;
+
+                        if (TOperator.ComponentCount >= 2)
+                        {
+                            Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c1Base, i)) = c1;
+                        }
+
+                        if (TOperator.ComponentCount >= 3)
+                        {
+                            Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c2Base, i)) = c2;
+                        }
+
+                        if (TOperator.ComponentCount >= 4)
+                        {
+                            Unsafe.As<float, Vector512<float>>(ref Unsafe.Add(ref c3Base, i)) = c3;
+                        }
+                    }
+                }
+            }
+
+            if (Vector256.IsHardwareAccelerated)
+            {
+                // Continue from the AVX-512 offset so an eight-sample tail stays vectorized on AVX-512 CPUs.
+                int oneVectorFromEnd = length - Vector256<float>.Count;
+
+                if (i <= oneVectorFromEnd)
+                {
+                    // Materialize YMM state only for an eight-sample remainder or an AVX2-only loop.
+                    Vector256<float> maximumValue = Vector256.Create(this.MaximumValue);
+                    Vector256<float> halfValue = Vector256.Create(this.HalfValue);
+                    Vector256<float> scaleVector = Vector256.Create(scale);
+
+                    for (; i <= oneVectorFromEnd; i += Vector256<float>.Count)
+                    {
+                        Vector256<float> r = Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref rBase, i));
+                        Vector256<float> g = Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref gBase, i));
+                        Vector256<float> b = Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref bBase, i));
+
+                        TOperator.ConvertFromRgb(r, g, b, maximumValue, halfValue, scaleVector, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3);
+
+                        // Static count checks write only planes owned by this color model.
+                        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c0Base, i)) = c0;
+
+                        if (TOperator.ComponentCount >= 2)
+                        {
+                            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c1Base, i)) = c1;
+                        }
+
+                        if (TOperator.ComponentCount >= 3)
+                        {
+                            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c2Base, i)) = c2;
+                        }
+
+                        if (TOperator.ComponentCount >= 4)
+                        {
+                            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref c3Base, i)) = c3;
+                        }
+                    }
+                }
+            }
+
+            if (Vector128.IsHardwareAccelerated)
+            {
+                // The final SIMD stage consumes four complete RGB samples on SSE or AdvSimd hardware.
+                int oneVectorFromEnd = length - Vector128<float>.Count;
+
+                if (i <= oneVectorFromEnd)
+                {
+                    // Materialize XMM state only when the final SIMD stage can consume four samples.
+                    Vector128<float> maximumValue = Vector128.Create(this.MaximumValue);
+                    Vector128<float> halfValue = Vector128.Create(this.HalfValue);
+                    Vector128<float> scaleVector = Vector128.Create(scale);
+
+                    for (; i <= oneVectorFromEnd; i += Vector128<float>.Count)
+                    {
+                        Vector128<float> r = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref rBase, i));
+                        Vector128<float> g = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref gBase, i));
+                        Vector128<float> b = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref bBase, i));
+
+                        TOperator.ConvertFromRgb(r, g, b, maximumValue, halfValue, scaleVector, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3);
+
+                        // Four results are stored only for the planes represented by the closed operator.
+                        Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c0Base, i)) = c0;
+
+                        if (TOperator.ComponentCount >= 2)
+                        {
+                            Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c1Base, i)) = c1;
+                        }
+
+                        if (TOperator.ComponentCount >= 3)
+                        {
+                            Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c2Base, i)) = c2;
+                        }
+
+                        if (TOperator.ComponentCount >= 4)
+                        {
+                            Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref c3Base, i)) = c3;
+                        }
+                    }
+                }
+            }
+
+            // Scalar conversion is reserved for the zero-to-three samples that cannot fill Vector128.
+            for (; i < length; i++)
+            {
+                TOperator.ConvertFromRgb(Unsafe.Add(ref rBase, i), Unsafe.Add(ref gBase, i), Unsafe.Add(ref bBase, i), this.MaximumValue, this.HalfValue, scale, out float c0, out float c1, out float c2, out float c3);
+
+                Unsafe.Add(ref c0Base, i) = c0;
+
+                if (TOperator.ComponentCount >= 2)
+                {
+                    Unsafe.Add(ref c1Base, i) = c1;
+                }
+
+                if (TOperator.ComponentCount >= 3)
+                {
+                    Unsafe.Add(ref c2Base, i) = c2;
+                }
+
+                if (TOperator.ComponentCount >= 4)
+                {
+                    Unsafe.Add(ref c3Base, i) = c3;
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,305 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Normalizes three planar component lanes and interleaves them into packed XYZ values.
+    /// </summary>
+    /// <param name="xLane">The planar X components.</param>
+    /// <param name="yLane">The planar Y components.</param>
+    /// <param name="zLane">The planar Z components.</param>
+    /// <param name="packed">The destination ordered as consecutive XYZ triples.</param>
+    /// <param name="scale">The normalization factor applied to every component.</param>
+    public static void PackedNormalizeInterleave3(ReadOnlySpan<float> xLane, ReadOnlySpan<float> yLane, ReadOnlySpan<float> zLane, Span<float> packed, float scale)
+    {
+        DebugGuard.IsTrue(packed.Length % 3 == 0, "Packed length must be divisible by 3.");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 3, xLane.Length, nameof(packed));
+
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+        int i = 0;
+
+        if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<float> scaleVector = Vector128.Create(scale);
+            int oneVectorFromEnd = xLane.Length - Vector128<float>.Count;
+
+            for (; i <= oneVectorFromEnd; i += Vector128<float>.Count)
+            {
+                // Each source vector contains four consecutive samples from one plane:
+                //   x = [X0 X1 X2 X3]
+                //   y = [Y0 Y1 Y2 Y3]
+                //   z = [Z0 Z1 Z2 Z3]
+                // Shifting X by one sample supplies the value that follows each XYZ triple:
+                //   shiftedX = [X1 X2 X3 0]
+                // The transpose therefore produces overlapping rows [Xn Yn Zn Xn+1].
+                // AlignRight joins those rows into three complete destination vectors, avoiding
+                // the scalar-sized stores that writing four independent Vector3 values requires.
+                Vector128<float> x = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref xLaneRef, i)) * scaleVector;
+                Vector128<float> y = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref yLaneRef, i)) * scaleVector;
+                Vector128<float> z = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref zLaneRef, i)) * scaleVector;
+                Vector128<float> shiftedX = Vector128_.ShiftRightBytesInVector(x.AsByte(), sizeof(float)).AsSingle();
+
+                Transpose4(x, y, z, shiftedX, out Vector128<float> pixel0, out Vector128<float> pixel1, out Vector128<float> pixel2, out Vector128<float> pixel3);
+
+                // Dropping pixel2.X lets [Y2] complete [Y1 Z1 X2] from pixel1.
+                Vector128<byte> shiftedPixel2 = Vector128_.ShiftRightBytesInVector(pixel2.AsByte(), sizeof(float));
+                Vector128<float> packed1 = Vector128_.AlignRight(shiftedPixel2, pixel1.AsByte(), sizeof(float)).AsSingle();
+
+                // Dropping pixel3.X leaves [Y3 Z3] to complete [Z2 X3] from pixel2.
+                Vector128<byte> shiftedPixel3 = Vector128_.ShiftRightBytesInVector(pixel3.AsByte(), sizeof(float));
+                Vector128<float> packed2 = Vector128_.AlignRight(shiftedPixel3, pixel2.AsByte(), sizeof(float) * 2).AsSingle();
+
+                ref Vector128<float> destination = ref Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref packedRef, (uint)i * 3));
+
+                destination = pixel0;
+                Unsafe.Add(ref destination, 1) = packed1;
+                Unsafe.Add(ref destination, 2) = packed2;
+            }
+        }
+
+        // Fewer than four pixels remain after SIMD, or every pixel reaches this path
+        // when the runtime cannot accelerate the cross-vector transpose.
+        for (; i < xLane.Length; i++)
+        {
+            nuint sourceOffset = (uint)i;
+            nuint packedOffset = sourceOffset * 3;
+            Unsafe.Add(ref packedRef, packedOffset) = Unsafe.Add(ref xLaneRef, sourceOffset) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 1) = Unsafe.Add(ref yLaneRef, sourceOffset) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 2) = Unsafe.Add(ref zLaneRef, sourceOffset) * scale;
+        }
+    }
+
+    /// <summary>
+    /// Deinterleaves packed XYZ values into three planar component lanes.
+    /// </summary>
+    /// <param name="packed">The source ordered as consecutive XYZ triples.</param>
+    /// <param name="xLane">The destination X components.</param>
+    /// <param name="yLane">The destination Y components.</param>
+    /// <param name="zLane">The destination Z components.</param>
+    public static void UnpackDeinterleave3(ReadOnlySpan<Vector3> packed, Span<float> xLane, Span<float> yLane, Span<float> zLane)
+    {
+        DebugGuard.IsTrue(packed.Length == xLane.Length, nameof(packed), "Channels must be of same size!");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+
+        ref float packedRef = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<Vector3, float>(packed));
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        int i = 0;
+
+        if (Vector128.IsHardwareAccelerated)
+        {
+            int oneVectorFromEnd = packed.Length - Vector128<float>.Count;
+
+            for (; i <= oneVectorFromEnd; i += Vector128<float>.Count)
+            {
+                // A Vector3 occupies twelve contiguous bytes, so a sixteen-byte load beginning
+                // at one pixel also reads the X component of the following pixel:
+                //   pixel0 = [X0 Y0 Z0 X1]
+                //   pixel1 = [X1 Y1 Z1 X2]
+                // The transpose discards this fourth column, making the overlap useful padding
+                // and avoiding two insert instructions per pixel. The final row needs explicit
+                // zero padding only when pixel3 is the last element in the source span.
+                nuint packedOffset = (uint)i * 3;
+                Vector128<float> pixel0 = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref packedRef, packedOffset));
+                Vector128<float> pixel1 = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref packedRef, packedOffset + 3));
+                Vector128<float> pixel2 = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref packedRef, packedOffset + 6));
+                ref float pixel3Ref = ref Unsafe.Add(ref packedRef, packedOffset + 9);
+                Vector128<float> pixel3 = i + Vector128<float>.Count < packed.Length ? Unsafe.As<float, Vector128<float>>(ref pixel3Ref) : Unsafe.As<float, Vector3>(ref pixel3Ref).AsVector128();
+
+                Transpose4(pixel0, pixel1, pixel2, pixel3, out Vector128<float> x, out Vector128<float> y, out Vector128<float> z, out _);
+
+                Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref xLaneRef, i)) = x;
+                Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref yLaneRef, i)) = y;
+                Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref zLaneRef, i)) = z;
+            }
+        }
+
+        // The scalar remainder preserves the original scatter behavior for zero to
+        // three pixels and provides the complete fallback on unsupported hardware.
+        for (; i < packed.Length; i++)
+        {
+            nuint packedOffset = (uint)i * 3;
+            Unsafe.Add(ref xLaneRef, i) = Unsafe.Add(ref packedRef, packedOffset);
+            Unsafe.Add(ref yLaneRef, i) = Unsafe.Add(ref packedRef, packedOffset + 1);
+            Unsafe.Add(ref zLaneRef, i) = Unsafe.Add(ref packedRef, packedOffset + 2);
+        }
+    }
+
+    /// <summary>
+    /// Normalizes four planar component lanes and interleaves them into packed XYZW values.
+    /// </summary>
+    /// <param name="xLane">The planar X components.</param>
+    /// <param name="yLane">The planar Y components.</param>
+    /// <param name="zLane">The planar Z components.</param>
+    /// <param name="wLane">The planar W components.</param>
+    /// <param name="packed">The destination ordered as consecutive XYZW groups.</param>
+    /// <param name="maxValue">The maximum component value used to normalize each component.</param>
+    public static void PackedNormalizeInterleave4(ReadOnlySpan<float> xLane, ReadOnlySpan<float> yLane, ReadOnlySpan<float> zLane, ReadOnlySpan<float> wLane, Span<float> packed, float maxValue)
+    {
+        DebugGuard.IsTrue(packed.Length % 4 == 0, "Packed length must be divisible by 4.");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(wLane.Length == xLane.Length, nameof(wLane), "Channels must be of same size!");
+        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 4, xLane.Length, nameof(packed));
+
+        float scale = 1F / maxValue;
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+        int i = 0;
+
+        if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<float> scaleVector = Vector128.Create(scale);
+            int oneVectorFromEnd = xLane.Length - Vector128<float>.Count;
+
+            for (; i <= oneVectorFromEnd; i += Vector128<float>.Count)
+            {
+                // Four planar vectors form the rows of a 4x4 matrix. Transposition
+                // converts them into four complete [Xn Yn Zn Wn] pixel vectors, so
+                // normalization and interleaving require only four loads, four
+                // multiplies, the register transpose, and four contiguous stores.
+                Vector128<float> x = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref xLaneRef, i)) * scaleVector;
+                Vector128<float> y = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref yLaneRef, i)) * scaleVector;
+                Vector128<float> z = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref zLaneRef, i)) * scaleVector;
+                Vector128<float> w = Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref wLaneRef, i)) * scaleVector;
+
+                Transpose4(x, y, z, w, out Vector128<float> pixel0, out Vector128<float> pixel1, out Vector128<float> pixel2, out Vector128<float> pixel3);
+
+                ref Vector128<float> destination = ref Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref packedRef, (uint)i * 4));
+
+                destination = pixel0;
+                Unsafe.Add(ref destination, 1) = pixel1;
+                Unsafe.Add(ref destination, 2) = pixel2;
+                Unsafe.Add(ref destination, 3) = pixel3;
+            }
+        }
+
+        // Process the zero-to-three trailing pixels with the same normalization
+        // and component order as the vector transpose.
+        for (; i < xLane.Length; i++)
+        {
+            nuint sourceOffset = (uint)i;
+            nuint packedOffset = sourceOffset * 4;
+            Unsafe.Add(ref packedRef, packedOffset) = Unsafe.Add(ref xLaneRef, sourceOffset) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 1) = Unsafe.Add(ref yLaneRef, sourceOffset) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 2) = Unsafe.Add(ref zLaneRef, sourceOffset) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 3) = Unsafe.Add(ref wLaneRef, sourceOffset) * scale;
+        }
+    }
+
+    /// <summary>
+    /// Inverts and normalizes four planar component lanes before interleaving them into packed XYZW values.
+    /// </summary>
+    /// <param name="xLane">The inverted planar X components.</param>
+    /// <param name="yLane">The inverted planar Y components.</param>
+    /// <param name="zLane">The inverted planar Z components.</param>
+    /// <param name="wLane">The inverted planar W components.</param>
+    /// <param name="packed">The destination ordered as consecutive conventional XYZW groups.</param>
+    /// <param name="maxValue">The maximum component value used for inversion and normalization.</param>
+    public static void PackedInvertNormalizeInterleave4(ReadOnlySpan<float> xLane, ReadOnlySpan<float> yLane, ReadOnlySpan<float> zLane, ReadOnlySpan<float> wLane, Span<float> packed, float maxValue)
+    {
+        DebugGuard.IsTrue(packed.Length % 4 == 0, "Packed length must be divisible by 4.");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(wLane.Length == xLane.Length, nameof(wLane), "Channels must be of same size!");
+        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 4, xLane.Length, nameof(packed));
+
+        float scale = 1F / maxValue;
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+        int i = 0;
+
+        if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<float> maximumVector = Vector128.Create(maxValue);
+            Vector128<float> scaleVector = Vector128.Create(scale);
+            int oneVectorFromEnd = xLane.Length - Vector128<float>.Count;
+
+            for (; i <= oneVectorFromEnd; i += Vector128<float>.Count)
+            {
+                // Adobe JPEG stores all four components inverted in the sample
+                // domain. Reflecting and normalizing the planar vectors before the
+                // transpose keeps both arithmetic operations lane-wise and leaves
+                // the transpose responsible only for the planar-to-packed layout.
+                Vector128<float> x = (maximumVector - Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref xLaneRef, i))) * scaleVector;
+                Vector128<float> y = (maximumVector - Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref yLaneRef, i))) * scaleVector;
+                Vector128<float> z = (maximumVector - Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref zLaneRef, i))) * scaleVector;
+                Vector128<float> w = (maximumVector - Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref wLaneRef, i))) * scaleVector;
+
+                Transpose4(x, y, z, w, out Vector128<float> pixel0, out Vector128<float> pixel1, out Vector128<float> pixel2, out Vector128<float> pixel3);
+
+                ref Vector128<float> destination = ref Unsafe.As<float, Vector128<float>>(ref Unsafe.Add(ref packedRef, (uint)i * 4));
+
+                destination = pixel0;
+                Unsafe.Add(ref destination, 1) = pixel1;
+                Unsafe.Add(ref destination, 2) = pixel2;
+                Unsafe.Add(ref destination, 3) = pixel3;
+            }
+        }
+
+        // Preserve the original operation order for the zero-to-three trailing pixels:
+        // subtract in the sample domain, then multiply by the reciprocal maximum.
+        for (; i < xLane.Length; i++)
+        {
+            nuint sourceOffset = (uint)i;
+            nuint packedOffset = sourceOffset * 4;
+            Unsafe.Add(ref packedRef, packedOffset) = (maxValue - Unsafe.Add(ref xLaneRef, sourceOffset)) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 1) = (maxValue - Unsafe.Add(ref yLaneRef, sourceOffset)) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 2) = (maxValue - Unsafe.Add(ref zLaneRef, sourceOffset)) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 3) = (maxValue - Unsafe.Add(ref wLaneRef, sourceOffset)) * scale;
+        }
+    }
+
+    /// <summary>
+    /// Transposes four four-lane rows into four four-lane columns.
+    /// </summary>
+    /// <param name="row0">The first matrix row.</param>
+    /// <param name="row1">The second matrix row.</param>
+    /// <param name="row2">The third matrix row.</param>
+    /// <param name="row3">The fourth matrix row.</param>
+    /// <param name="column0">The first matrix column.</param>
+    /// <param name="column1">The second matrix column.</param>
+    /// <param name="column2">The third matrix column.</param>
+    /// <param name="column3">The fourth matrix column.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void Transpose4(Vector128<float> row0, Vector128<float> row1, Vector128<float> row2, Vector128<float> row3, out Vector128<float> column0, out Vector128<float> column1, out Vector128<float> column2, out Vector128<float> column3)
+    {
+        // The first unpack interleaves adjacent 32-bit lanes from rows 0/1 and 2/3:
+        //   row01Low = [r0c0 r1c0 r0c1 r1c1]
+        //   row23Low = [r2c0 r3c0 r2c1 r3c1]
+        // A second unpack treats each adjacent pair as one 64-bit lane and combines
+        // the row01 and row23 pairs into complete columns. The integer views only
+        // expose the cross-platform unpack helpers; every floating-point bit is preserved.
+        Vector128<int> row01Low = Vector128_.UnpackLow(row0.AsInt32(), row1.AsInt32());
+        Vector128<int> row01High = Vector128_.UnpackHigh(row0.AsInt32(), row1.AsInt32());
+        Vector128<int> row23Low = Vector128_.UnpackLow(row2.AsInt32(), row3.AsInt32());
+        Vector128<int> row23High = Vector128_.UnpackHigh(row2.AsInt32(), row3.AsInt32());
+
+        column0 = Vector128_.UnpackLow(row01Low.AsInt64(), row23Low.AsInt64()).AsSingle();
+        column1 = Vector128_.UnpackHigh(row01Low.AsInt64(), row23Low.AsInt64()).AsSingle();
+        column2 = Vector128_.UnpackLow(row01High.AsInt64(), row23High.AsInt64()).AsSingle();
+        column3 = Vector128_.UnpackHigh(row01High.AsInt64(), row23High.AsInt64()).AsSingle();
+    }
+}

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

@@ -0,0 +1,107 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Implements direct JPEG RGB normalization and planar RGB copying for scalar and SIMD lanes.
+    /// </summary>
+    internal readonly struct RgbOperator : IJpegColorConverterOperator
+    {
+        /// <inheritdoc/>
+        public static JpegColorSpace ColorSpace => JpegColorSpace.RGB;
+
+        /// <inheritdoc/>
+        public static int ComponentCount => 3;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale)
+        {
+            // The JPEG planes already represent R, G, and B. Conversion therefore consists only of moving
+            // each integer-domain sample into the normalized floating-point domain consumed by pixel packing.
+            c0 *= scale;
+            c1 *= scale;
+            c2 *= scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale)
+        {
+            // Four samples from each planar channel remain in their lanes while sharing one normalization vector.
+            c0 *= scale;
+            c1 *= scale;
+            c2 *= scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale)
+        {
+            // Eight samples per plane are normalized independently without channel shuffles.
+            c0 *= scale;
+            c1 *= scale;
+            c2 *= scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale)
+        {
+            // Sixteen samples per plane are normalized independently without changing planar ordering.
+            c0 *= scale;
+            c1 *= scale;
+            c2 *= scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3)
+        {
+            // Encoder RGB lanes already use the JPEG sample domain, so the direct color model copies them.
+            c0 = r;
+            c1 = g;
+            c2 = b;
+            c3 = 0;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3)
+        {
+            // The planar vectors map one-to-one to JPEG components; the fourth result is statically discarded.
+            c0 = r;
+            c1 = g;
+            c2 = b;
+            c3 = default;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3)
+        {
+            // The planar vectors map one-to-one to JPEG components; no arithmetic or rearrangement is required.
+            c0 = r;
+            c1 = g;
+            c2 = b;
+            c3 = default;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3)
+        {
+            // The widest path is likewise a register-to-register planar copy for sixteen pixels.
+            c0 = r;
+            c1 = g;
+            c2 = b;
+            c3 = default;
+        }
+    }
+}

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

@@ -1,84 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.ColorProfiles;
-using SixLabors.ImageSharp.ColorProfiles.Icc;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class RgbScalar : JpegColorConverterScalar
-    {
-        public RgbScalar(int precision)
-            : base(JpegColorSpace.RGB, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-            => ConvertToRgbInPlace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(values, rLane, gLane, bLane);
-
-        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
-        {
-            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 3);
-            Span<float> packed = memoryOwner.Memory.Span;
-
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-
-            PackedNormalizeInterleave3(c0, c1, c2, packed, 1F / maxValue);
-
-            Span<Rgb> source = MemoryMarshal.Cast<float, Rgb>(packed);
-            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed);
-
-            ColorConversionOptions options = new()
-            {
-                SourceIccProfile = profile,
-                TargetIccProfile = CompactSrgbV4Profile.Profile,
-            };
-            ColorProfileConverter converter = new(options);
-            converter.Convert<Rgb, Rgb>(source, destination);
-
-            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
-        }
-
-        internal static void ConvertToRgbInPlace(ComponentValues values, float maxValue)
-        {
-            ref float c0Base = ref MemoryMarshal.GetReference(values.Component0);
-            ref float c1Base = ref MemoryMarshal.GetReference(values.Component1);
-            ref float c2Base = ref MemoryMarshal.GetReference(values.Component2);
-
-            float scale = 1F / maxValue;
-
-            for (nuint i = 0; i < (nuint)values.Component0.Length; i++)
-            {
-                Unsafe.Add(ref c0Base, i) *= scale;
-                Unsafe.Add(ref c1Base, i) *= scale;
-                Unsafe.Add(ref c2Base, i) *= scale;
-            }
-        }
-
-        internal static void ConvertFromRgb(ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // TODO: This doesn't seem correct. We should be scaling to the maximum value here.
-            rLane.CopyTo(values.Component0);
-            gLane.CopyTo(values.Component1);
-            bLane.CopyTo(values.Component2);
-        }
-    }
-}

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

@@ -1,56 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class RgbVector128 : JpegColorConverterVector128
-    {
-        public RgbVector128(int precision)
-            : base(JpegColorSpace.RGB, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector128<float> rBase =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> gBase =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> bBase =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            // Used for the color conversion
-            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector128<float> r = ref Unsafe.Add(ref rBase, i);
-                ref Vector128<float> g = ref Unsafe.Add(ref gBase, i);
-                ref Vector128<float> b = ref Unsafe.Add(ref bBase, i);
-                r *= scale;
-                g *= scale;
-                b *= scale;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => RgbScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            rLane.CopyTo(values.Component0);
-            gLane.CopyTo(values.Component1);
-            bLane.CopyTo(values.Component2);
-        }
-    }
-}

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

@@ -1,56 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class RgbVector256 : JpegColorConverterVector256
-    {
-        public RgbVector256(int precision)
-            : base(JpegColorSpace.RGB, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector256<float> rBase =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> gBase =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> bBase =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            // Used for the color conversion
-            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector256<float> r = ref Unsafe.Add(ref rBase, i);
-                ref Vector256<float> g = ref Unsafe.Add(ref gBase, i);
-                ref Vector256<float> b = ref Unsafe.Add(ref bBase, i);
-                r *= scale;
-                g *= scale;
-                b *= scale;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => RgbScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            rLane.CopyTo(values.Component0);
-            gLane.CopyTo(values.Component1);
-            bLane.CopyTo(values.Component2);
-        }
-    }
-}

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

@@ -1,64 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class RgbVector512 : JpegColorConverterVector512
-    {
-        public RgbVector512(int precision)
-            : base(JpegColorSpace.RGB, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
-        {
-            ref Vector512<float> rBase =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> gBase =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> bBase =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            // Used for the color conversion
-            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector512<float> r = ref Unsafe.Add(ref rBase, i);
-                ref Vector512<float> g = ref Unsafe.Add(ref gBase, i);
-                ref Vector512<float> b = ref Unsafe.Add(ref bBase, i);
-                r *= scale;
-                g *= scale;
-                b *= scale;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => RgbScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            rLane.CopyTo(values.Component0);
-            gLane.CopyTo(values.Component1);
-            bLane.CopyTo(values.Component2);
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
-            => RgbScalar.ConvertToRgbInPlace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => RgbScalar.ConvertFromRgb(values, rLane, gLane, bLane);
-    }
-}

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

@@ -0,0 +1,154 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Implements non-inverted TIFF JPEG CMYK conversion for scalar and SIMD lanes.
+    /// </summary>
+    internal readonly struct TiffCmykOperator : IJpegColorConverterOperator
+    {
+        /// <inheritdoc/>
+        public static JpegColorSpace ColorSpace => JpegColorSpace.TiffCmyk;
+
+        /// <inheritdoc/>
+        public static int ComponentCount => 4;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale)
+        {
+            // TIFF stores conventional CMYK rather than Adobe's inverted representation. Normalize every
+            // component, invert C/M/Y, and let the remaining light after K modulate each RGB channel.
+            float k = 1F - (c3 * scale);
+            c0 = (1F - (c0 * scale)) * k;
+            c1 = (1F - (c1 * scale)) * k;
+            c2 = (1F - (c2 * scale)) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale)
+        {
+            // K remains lane-aligned with its C/M/Y sample while one-minus performs the non-inverted CMYK mapping.
+            Vector128<float> k = Vector128<float>.One - (c3 * scale);
+            c0 = (Vector128<float>.One - (c0 * scale)) * k;
+            c1 = (Vector128<float>.One - (c1 * scale)) * k;
+            c2 = (Vector128<float>.One - (c2 * scale)) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale)
+        {
+            // Eight conventional CMYK samples convert independently without channel rearrangement.
+            Vector256<float> k = Vector256<float>.One - (c3 * scale);
+            c0 = (Vector256<float>.One - (c0 * scale)) * k;
+            c1 = (Vector256<float>.One - (c1 * scale)) * k;
+            c2 = (Vector256<float>.One - (c2 * scale)) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale)
+        {
+            // Sixteen conventional CMYK samples convert independently without channel rearrangement.
+            Vector512<float> k = Vector512<float>.One - (c3 * scale);
+            c0 = (Vector512<float>.One - (c0 * scale)) * k;
+            c1 = (Vector512<float>.One - (c1 * scale)) * k;
+            c2 = (Vector512<float>.One - (c2 * scale)) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3)
+        {
+            float c = maximumValue - r;
+            float m = maximumValue - g;
+            float y = maximumValue - b;
+            float k = MathF.Min(c, MathF.Min(m, y));
+
+            // Removing the shared black contribution requires division by the remaining range. Pure black
+            // consumes that range completely, so its chromatic components are defined as zero.
+            if (k >= maximumValue)
+            {
+                c = 0;
+                m = 0;
+                y = 0;
+            }
+            else
+            {
+                // One reciprocal normalizes C, M, and Y against their shared remaining range.
+                float reciprocal = 1F / (maximumValue - k);
+                c = (c - k) * reciprocal;
+                m = (m - k) * reciprocal;
+                y = (y - k) * reciprocal;
+            }
+
+            // TIFF stores conventional CMYK: scale normalized C/M/Y back into the sample domain and retain K.
+            c0 = c * maximumValue;
+            c1 = m * maximumValue;
+            c2 = y * maximumValue;
+            c3 = k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3)
+        {
+            Vector128<float> c = maximumValue - r;
+            Vector128<float> m = maximumValue - g;
+            Vector128<float> y = maximumValue - b;
+            Vector128<float> k = Vector128.Min(c, Vector128.Min(m, y));
+
+            // The all-bits mask clears the undefined zero-divisor result only in pure-black lanes.
+            Vector128<float> nonBlack = ~Vector128.Equals(k, maximumValue);
+            Vector128<float> reciprocal = Vector128<float>.One / (maximumValue - k);
+            c0 = (((c - k) * reciprocal) & nonBlack) * maximumValue;
+            c1 = (((m - k) * reciprocal) & nonBlack) * maximumValue;
+            c2 = (((y - k) * reciprocal) & nonBlack) * maximumValue;
+            c3 = k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3)
+        {
+            Vector256<float> c = maximumValue - r;
+            Vector256<float> m = maximumValue - g;
+            Vector256<float> y = maximumValue - b;
+            Vector256<float> k = Vector256.Min(c, Vector256.Min(m, y));
+
+            // Eight lanes independently clear the pure-black singularity before returning conventional CMYK.
+            Vector256<float> nonBlack = ~Vector256.Equals(k, maximumValue);
+            Vector256<float> reciprocal = Vector256<float>.One / (maximumValue - k);
+            c0 = (((c - k) * reciprocal) & nonBlack) * maximumValue;
+            c1 = (((m - k) * reciprocal) & nonBlack) * maximumValue;
+            c2 = (((y - k) * reciprocal) & nonBlack) * maximumValue;
+            c3 = k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3)
+        {
+            Vector512<float> c = maximumValue - r;
+            Vector512<float> m = maximumValue - g;
+            Vector512<float> y = maximumValue - b;
+            Vector512<float> k = Vector512.Min(c, Vector512.Min(m, y));
+
+            // Sixteen lanes retain the same branchless singularity handling and component layout.
+            Vector512<float> nonBlack = ~Vector512.Equals(k, maximumValue);
+            Vector512<float> reciprocal = Vector512<float>.One / (maximumValue - k);
+            c0 = (((c - k) * reciprocal) & nonBlack) * maximumValue;
+            c1 = (((m - k) * reciprocal) & nonBlack) * maximumValue;
+            c2 = (((y - k) * reciprocal) & nonBlack) * maximumValue;
+            c3 = k;
+        }
+    }
+}

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

@@ -1,118 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.ColorProfiles;
-using SixLabors.ImageSharp.ColorProfiles.Icc;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// Color converter for tiff images, which use the jpeg compression and CMYK colorspace.
-    /// </summary>
-    internal sealed class TiffCmykScalar : JpegColorConverterScalar
-    {
-        public TiffCmykScalar(int precision)
-            : base(JpegColorSpace.TiffCmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-            => ConvertToRgbInPlace(in values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue)
-        {
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            float scale = 1 / maxValue;
-            for (int i = 0; i < c0.Length; i++)
-            {
-                float c = c0[i] * scale;
-                float m = c1[i] * scale;
-                float y = c2[i] * scale;
-                float k = 1 - (c3[i] * scale);
-
-                c0[i] = (1 - c) * k;
-                c1[i] = (1 - m) * k;
-                c2[i] = (1 - y) * k;
-            }
-        }
-
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            Span<float> c = values.Component0;
-            Span<float> m = values.Component1;
-            Span<float> y = values.Component2;
-            Span<float> k = values.Component3;
-
-            for (int i = 0; i < c.Length; i++)
-            {
-                float ctmp = 255F - rLane[i];
-                float mtmp = 255F - gLane[i];
-                float ytmp = 255F - bLane[i];
-                float ktmp = MathF.Min(MathF.Min(ctmp, mtmp), ytmp);
-
-                if (ktmp >= 255F)
-                {
-                    ctmp = 0F;
-                    mtmp = 0F;
-                    ytmp = 0F;
-                }
-                else
-                {
-                    float divisor = 1 / (255F - ktmp);
-                    ctmp = (ctmp - ktmp) * divisor;
-                    mtmp = (mtmp - ktmp) * divisor;
-                    ytmp = (ytmp - ktmp) * divisor;
-                }
-
-                c[i] = ctmp * maxValue;
-                m[i] = mtmp * maxValue;
-                y[i] = ytmp * maxValue;
-                k[i] = ktmp;
-            }
-        }
-
-        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
-        {
-            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
-            Span<float> packed = memoryOwner.Memory.Span;
-
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            PackedNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
-
-            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
-            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
-
-            ColorConversionOptions options = new()
-            {
-                SourceIccProfile = profile,
-                TargetIccProfile = CompactSrgbV4Profile.Profile,
-            };
-            ColorProfileConverter converter = new(options);
-            converter.Convert<Cmyk, Rgb>(source, destination);
-
-            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
-        }
-    }
-}

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

@@ -1,99 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class TiffCmykVector128 : JpegColorConverterVector128
-    {
-        public TiffCmykVector128(int precision)
-            : base(JpegColorSpace.TiffCmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector128<float> c0Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> c1Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> c2Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> c3Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector128<float> c = ref Unsafe.Add(ref c0Base, i);
-                ref Vector128<float> m = ref Unsafe.Add(ref c1Base, i);
-                ref Vector128<float> y = ref Unsafe.Add(ref c2Base, i);
-                Vector128<float> k = Unsafe.Add(ref c3Base, i);
-
-                k = Vector128<float>.One - (k * scale);
-                c = (Vector128<float>.One - (c * scale)) * k;
-                m = (Vector128<float>.One - (m * scale)) * k;
-                y = (Vector128<float>.One - (y * scale)) * k;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => TiffCmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector128<float> destC =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> destM =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> destY =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> destK =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector128<float> srcR =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector128<float> srcG =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector128<float> srcB =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector128<float> scale = Vector128.Create(maxValue);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector128<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector128<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector128<float> ktmp = Vector128.Min(ctmp, Vector128.Min(mtmp, ytmp));
-
-                Vector128<float> kMask = ~Vector128.Equals(ktmp, scale);
-                Vector128<float> divisor = Vector128<float>.One / (scale - ktmp);
-
-                ctmp = ((ctmp - ktmp) * divisor) & kMask;
-                mtmp = ((mtmp - ktmp) * divisor) & kMask;
-                ytmp = ((ytmp - ktmp) * divisor) & kMask;
-
-                Unsafe.Add(ref destC, i) = ctmp * scale;
-                Unsafe.Add(ref destM, i) = mtmp * scale;
-                Unsafe.Add(ref destY, i) = ytmp * scale;
-                Unsafe.Add(ref destK, i) = ktmp;
-            }
-        }
-    }
-}

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

@@ -1,99 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class TiffCmykVector256 : JpegColorConverterVector256
-    {
-        public TiffCmykVector256(int precision)
-            : base(JpegColorSpace.TiffCmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector256<float> c0Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> c1Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> c2Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector256<float> c3Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector256<float> c = ref Unsafe.Add(ref c0Base, i);
-                ref Vector256<float> m = ref Unsafe.Add(ref c1Base, i);
-                ref Vector256<float> y = ref Unsafe.Add(ref c2Base, i);
-                Vector256<float> k = Unsafe.Add(ref c3Base, i);
-
-                k = Vector256<float>.One - (k * scale);
-                c = (Vector256<float>.One - (c * scale)) * k;
-                m = (Vector256<float>.One - (m * scale)) * k;
-                y = (Vector256<float>.One - (y * scale)) * k;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector256<float> destC =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> destM =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> destY =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector256<float> destK =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector256<float> srcR =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector256<float> srcG =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector256<float> srcB =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector256<float> scale = Vector256.Create(maxValue);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector256<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector256<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector256<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector256<float> ktmp = Vector256.Min(ctmp, Vector256.Min(mtmp, ytmp));
-
-                Vector256<float> kMask = ~Vector256.Equals(ktmp, scale);
-                Vector256<float> divisor = Vector256<float>.One / (scale - ktmp);
-
-                ctmp = ((ctmp - ktmp) * divisor) & kMask;
-                mtmp = ((mtmp - ktmp) * divisor) & kMask;
-                ytmp = ((ytmp - ktmp) * divisor) & kMask;
-
-                Unsafe.Add(ref destC, i) = ctmp * scale;
-                Unsafe.Add(ref destM, i) = mtmp * scale;
-                Unsafe.Add(ref destY, i) = ytmp * scale;
-                Unsafe.Add(ref destK, i) = ktmp;
-            }
-        }
-    }
-}

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

@@ -1,108 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class TiffCmykVector512 : JpegColorConverterVector512
-    {
-        public TiffCmykVector512(int precision)
-            : base(JpegColorSpace.TiffCmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => TiffCmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
-        {
-            ref Vector512<float> c0Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> c1Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> c2Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector512<float> c3Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector512<float> c = ref Unsafe.Add(ref c0Base, i);
-                ref Vector512<float> m = ref Unsafe.Add(ref c1Base, i);
-                ref Vector512<float> y = ref Unsafe.Add(ref c2Base, i);
-                Vector512<float> k = Unsafe.Add(ref c3Base, i);
-
-                k = Vector512<float>.One - (k * scale);
-                c = (Vector512<float>.One - (c * scale)) * k;
-                m = (Vector512<float>.One - (m * scale)) * k;
-                y = (Vector512<float>.One - (y * scale)) * k;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgbVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
-             => TiffCmykScalar.ConvertToRgbInPlace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => TiffCmykScalar.ConvertFromRgb(values, this.MaximumValue, rLane, gLane, bLane);
-
-        internal static void ConvertFromRgbVectorized(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector512<float> destC =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> destM =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> destY =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector512<float> destK =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector512<float> srcR =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector512<float> srcG =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector512<float> srcB =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector512<float> scale = Vector512.Create(maxValue);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector512<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector512<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector512<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector512<float> ktmp = Vector512.Min(ctmp, Vector512.Min(mtmp, ytmp));
-
-                Vector512<float> kMask = ~Vector512.Equals(ktmp, scale);
-                Vector512<float> divisor = Vector512<float>.One / (scale - ktmp);
-
-                ctmp = ((ctmp - ktmp) * divisor) & kMask;
-                mtmp = ((mtmp - ktmp) * divisor) & kMask;
-                ytmp = ((ytmp - ktmp) * divisor) & kMask;
-
-                Unsafe.Add(ref destC, i) = ctmp * scale;
-                Unsafe.Add(ref destM, i) = mtmp * scale;
-                Unsafe.Add(ref destY, i) = ytmp * scale;
-                Unsafe.Add(ref destK, i) = ktmp;
-            }
-        }
-    }
-}

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

@@ -0,0 +1,182 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Implements non-inverted TIFF JPEG YccK conversion for scalar and SIMD lanes.
+    /// </summary>
+    internal readonly struct TiffYccKOperator : IJpegColorConverterOperator
+    {
+        private const float SourceScale = 1F / 255F;
+
+        /// <inheritdoc/>
+        public static JpegColorSpace ColorSpace => JpegColorSpace.TiffYccK;
+
+        /// <inheritdoc/>
+        public static int ComponentCount => 4;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale)
+        {
+            float y = c0 * scale;
+            float cb = (c1 - halfValue) * scale;
+            float cr = (c2 - halfValue) * scale;
+            float k = 1F - (c3 * scale);
+
+            // TIFF YccK is non-inverted: decode normalized YCbCr without integer rounding, then let the
+            // remaining light after K modulate all three channels.
+            c0 = (y + (YCbCrOperator.RCrMult * cr)) * k;
+            c1 = (y - (YCbCrOperator.GCbMult * cb) - (YCbCrOperator.GCrMult * cr)) * k;
+            c2 = (y + (YCbCrOperator.BCbMult * cb)) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale)
+        {
+            Vector128<float> y = c0 * scale;
+            Vector128<float> cb = (c1 - halfValue) * scale;
+            Vector128<float> cr = (c2 - halfValue) * scale;
+            Vector128<float> k = Vector128<float>.One - (c3 * scale);
+
+            // Four lanes apply the non-rounded YCbCr matrix before their lane-aligned K modulation.
+            c0 = Vector128_.MultiplyAddEstimate(cr, Vector128.Create(YCbCrOperator.RCrMult), y) * k;
+            c1 = Vector128_.MultiplyAddEstimate(cr, Vector128.Create(-YCbCrOperator.GCrMult), Vector128_.MultiplyAddEstimate(cb, Vector128.Create(-YCbCrOperator.GCbMult), y)) * k;
+            c2 = Vector128_.MultiplyAddEstimate(cb, Vector128.Create(YCbCrOperator.BCbMult), y) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale)
+        {
+            Vector256<float> y = c0 * scale;
+            Vector256<float> cb = (c1 - halfValue) * scale;
+            Vector256<float> cr = (c2 - halfValue) * scale;
+            Vector256<float> k = Vector256<float>.One - (c3 * scale);
+
+            // Eight lanes apply the non-rounded YCbCr matrix before their lane-aligned K modulation.
+            c0 = Vector256_.MultiplyAddEstimate(cr, Vector256.Create(YCbCrOperator.RCrMult), y) * k;
+            c1 = Vector256_.MultiplyAddEstimate(cr, Vector256.Create(-YCbCrOperator.GCrMult), Vector256_.MultiplyAddEstimate(cb, Vector256.Create(-YCbCrOperator.GCbMult), y)) * k;
+            c2 = Vector256_.MultiplyAddEstimate(cb, Vector256.Create(YCbCrOperator.BCbMult), y) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale)
+        {
+            Vector512<float> y = c0 * scale;
+            Vector512<float> cb = (c1 - halfValue) * scale;
+            Vector512<float> cr = (c2 - halfValue) * scale;
+            Vector512<float> k = Vector512<float>.One - (c3 * scale);
+
+            // Sixteen lanes apply the non-rounded YCbCr matrix before their lane-aligned K modulation.
+            c0 = Vector512_.MultiplyAddEstimate(cr, Vector512.Create(YCbCrOperator.RCrMult), y) * k;
+            c1 = Vector512_.MultiplyAddEstimate(cr, Vector512.Create(-YCbCrOperator.GCrMult), Vector512_.MultiplyAddEstimate(cb, Vector512.Create(-YCbCrOperator.GCbMult), y)) * k;
+            c2 = Vector512_.MultiplyAddEstimate(cb, Vector512.Create(YCbCrOperator.BCbMult), y) * k;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3)
+        {
+            r *= SourceScale;
+            g *= SourceScale;
+            b *= SourceScale;
+            float k = 1F - MathF.Max(r, MathF.Max(g, b));
+
+            // Dividing by the brightest channel removes K before YCbCr projection. Pure black has no
+            // chromatic direction, so it maps to zero luma and the neutral chroma midpoint.
+            if (k >= 1F)
+            {
+                c0 = 0;
+                c1 = halfValue;
+                c2 = halfValue;
+                c3 = maximumValue;
+                return;
+            }
+
+            float divisor = 1F / (1F - k);
+            r *= divisor;
+            g *= divisor;
+            b *= divisor;
+            c0 = ((0.299F * r) + (0.587F * g) + (0.114F * b)) * maximumValue;
+            c1 = halfValue + (((-0.168736F * r) + (-0.331264F * g) + (0.5F * b)) * maximumValue);
+            c2 = halfValue + (((0.5F * r) + (-0.418688F * g) + (-0.081312F * b)) * maximumValue);
+            c3 = k * maximumValue;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3)
+        {
+            Vector128<float> sourceScale = Vector128.Create(SourceScale);
+            r *= sourceScale;
+            g *= sourceScale;
+            b *= sourceScale;
+            Vector128<float> k = Vector128<float>.One - Vector128.Max(r, Vector128.Max(g, b));
+
+            // The mask assigns no chromatic direction to pure-black lanes while preserving neighboring pixels.
+            Vector128<float> nonBlack = ~Vector128.Equals(k, Vector128<float>.One);
+            Vector128<float> divisor = Vector128<float>.One / (Vector128<float>.One - k);
+            r = (r * divisor) & nonBlack;
+            g = (g * divisor) & nonBlack;
+            b = (b * divisor) & nonBlack;
+            c0 = Vector128_.MultiplyAddEstimate(Vector128.Create(0.299F), r, Vector128_.MultiplyAddEstimate(Vector128.Create(0.587F), g, Vector128.Create(0.114F) * b)) * maximumValue;
+            c1 = halfValue + (Vector128_.MultiplyAddEstimate(Vector128.Create(-0.168736F), r, Vector128_.MultiplyAddEstimate(Vector128.Create(-0.331264F), g, Vector128.Create(0.5F) * b)) * maximumValue);
+            c2 = halfValue + (Vector128_.MultiplyAddEstimate(Vector128.Create(0.5F), r, Vector128_.MultiplyAddEstimate(Vector128.Create(-0.418688F), g, Vector128.Create(-0.081312F) * b)) * maximumValue);
+            c3 = k * maximumValue;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3)
+        {
+            Vector256<float> sourceScale = Vector256.Create(SourceScale);
+            r *= sourceScale;
+            g *= sourceScale;
+            b *= sourceScale;
+            Vector256<float> k = Vector256<float>.One - Vector256.Max(r, Vector256.Max(g, b));
+
+            // Eight lanes normalize chromatic direction independently and retain neutral chroma for black.
+            Vector256<float> nonBlack = ~Vector256.Equals(k, Vector256<float>.One);
+            Vector256<float> divisor = Vector256<float>.One / (Vector256<float>.One - k);
+            r = (r * divisor) & nonBlack;
+            g = (g * divisor) & nonBlack;
+            b = (b * divisor) & nonBlack;
+            c0 = Vector256_.MultiplyAddEstimate(Vector256.Create(0.299F), r, Vector256_.MultiplyAddEstimate(Vector256.Create(0.587F), g, Vector256.Create(0.114F) * b)) * maximumValue;
+            c1 = halfValue + (Vector256_.MultiplyAddEstimate(Vector256.Create(-0.168736F), r, Vector256_.MultiplyAddEstimate(Vector256.Create(-0.331264F), g, Vector256.Create(0.5F) * b)) * maximumValue);
+            c2 = halfValue + (Vector256_.MultiplyAddEstimate(Vector256.Create(0.5F), r, Vector256_.MultiplyAddEstimate(Vector256.Create(-0.418688F), g, Vector256.Create(-0.081312F) * b)) * maximumValue);
+            c3 = k * maximumValue;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3)
+        {
+            Vector512<float> sourceScale = Vector512.Create(SourceScale);
+            r *= sourceScale;
+            g *= sourceScale;
+            b *= sourceScale;
+            Vector512<float> k = Vector512<float>.One - Vector512.Max(r, Vector512.Max(g, b));
+
+            // Sixteen lanes normalize chromatic direction independently and retain neutral chroma for black.
+            Vector512<float> nonBlack = ~Vector512.Equals(k, Vector512<float>.One);
+            Vector512<float> divisor = Vector512<float>.One / (Vector512<float>.One - k);
+            r = (r * divisor) & nonBlack;
+            g = (g * divisor) & nonBlack;
+            b = (b * divisor) & nonBlack;
+            c0 = Vector512_.MultiplyAddEstimate(Vector512.Create(0.299F), r, Vector512_.MultiplyAddEstimate(Vector512.Create(0.587F), g, Vector512.Create(0.114F) * b)) * maximumValue;
+            c1 = halfValue + (Vector512_.MultiplyAddEstimate(Vector512.Create(-0.168736F), r, Vector512_.MultiplyAddEstimate(Vector512.Create(-0.331264F), g, Vector512.Create(0.5F) * b)) * maximumValue);
+            c2 = halfValue + (Vector512_.MultiplyAddEstimate(Vector512.Create(0.5F), r, Vector512_.MultiplyAddEstimate(Vector512.Create(-0.418688F), g, Vector512.Create(-0.081312F) * b)) * maximumValue);
+            c3 = k * maximumValue;
+        }
+    }
+}

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

@@ -1,153 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.ColorProfiles;
-using SixLabors.ImageSharp.ColorProfiles.Icc;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// Color converter for tiff images, which use the jpeg compression and CMYK colorspace.
-    /// </summary>
-    internal sealed class TiffYccKScalar : JpegColorConverterScalar
-    {
-        // Derived from ITU-T Rec. T.871
-        internal const float RCrMult = 1.402f;
-        internal const float GCbMult = (float)(0.114 * 1.772 / 0.587);
-        internal const float GCrMult = (float)(0.299 * 1.402 / 0.587);
-        internal const float BCbMult = 1.772f;
-
-        public TiffYccKScalar(int precision)
-            : base(JpegColorSpace.TiffYccK, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-            => ConvertToRgbInPlace(in values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue, float halfValue)
-        {
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            float scale = 1F / maxValue;
-            halfValue *= scale;
-
-            for (int i = 0; i < values.Component0.Length; i++)
-            {
-                float y = c0[i] * scale;
-                float cb = (c1[i] * scale) - halfValue;
-                float cr = (c2[i] * scale) - halfValue;
-                float scaledK = 1 - (c3[i] * scale);
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                c0[i] = (y + (RCrMult * cr)) * scaledK;
-                c1[i] = (y - (GCbMult * cb) - (GCrMult * cr)) * scaledK;
-                c2[i] = (y + (BCbMult * cb)) * scaledK;
-            }
-        }
-
-        public static void ConvertFromRgb(in ComponentValues values, float halfValue, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            Span<float> y = values.Component0;
-            Span<float> cb = values.Component1;
-            Span<float> cr = values.Component2;
-            Span<float> k = values.Component3;
-
-            for (int i = 0; i < cr.Length; i++)
-            {
-                // Scale down to [0-1]
-                const float divisor = 1F / 255F;
-                float r = rLane[i] * divisor;
-                float g = gLane[i] * divisor;
-                float b = bLane[i] * divisor;
-
-                float ytmp;
-                float cbtmp;
-                float crtmp;
-                float ktmp = 1F - MathF.Max(r, MathF.Max(g, b));
-
-                if (ktmp >= 1F)
-                {
-                    ytmp = 0F;
-                    cbtmp = 0.5F;
-                    crtmp = 0.5F;
-                    ktmp = maxValue;
-                }
-                else
-                {
-                    float kmask = 1F / (1F - ktmp);
-                    r *= kmask;
-                    g *= kmask;
-                    b *= kmask;
-
-                    // Scale to [0-maxValue]
-                    ytmp = ((0.299f * r) + (0.587f * g) + (0.114f * b)) * maxValue;
-                    cbtmp = halfValue - (((0.168736f * r) - (0.331264f * g) + (0.5f * b)) * maxValue);
-                    crtmp = halfValue + (((0.5f * r) - (0.418688f * g) - (0.081312f * b)) * maxValue);
-                    ktmp *= maxValue;
-                }
-
-                y[i] = ytmp;
-                cb[i] = cbtmp;
-                cr[i] = crtmp;
-                k[i] = ktmp;
-            }
-        }
-
-        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
-        {
-            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
-            Span<float> packed = memoryOwner.Memory.Span;
-
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            PackedNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
-
-            ColorProfileConverter converter = new();
-            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
-
-            // YccK is not a defined ICC color space � it's a JPEG-specific encoding used in Adobe-style CMYK JPEGs.
-            // ICC profiles expect colorimetric CMYK values, so we must first convert YccK to CMYK using a hardcoded inverse transform.
-            // This transform assumes Rec.601 YCbCr coefficients and an inverted K channel.
-            //
-            // The YccK => Cmyk conversion is independent of any embedded ICC profile.
-            // Since the same RGB working space is used during conversion to and from XYZ,
-            // colorimetric accuracy is preserved.
-            converter.Convert<YccK, Cmyk>(MemoryMarshal.Cast<Cmyk, YccK>(source), source);
-
-            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
-
-            ColorConversionOptions options = new()
-            {
-                SourceIccProfile = profile,
-                TargetIccProfile = CompactSrgbV4Profile.Profile,
-            };
-            converter = new ColorProfileConverter(options);
-            converter.Convert<Cmyk, Rgb>(source, destination);
-
-            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
-        }
-    }
-}

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

@@ -1,131 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class TiffYccKVector128 : JpegColorConverterVector128
-    {
-        public TiffYccKVector128(int precision)
-            : base(JpegColorSpace.TiffYccK, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector128<float> c0Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> c1Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> c2Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> c3Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector128<float> scale = Vector128.Create(1F / this.MaximumValue);
-            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue) * scale;
-            Vector128<float> rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
-            Vector128<float> gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
-            Vector128<float> gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
-            Vector128<float> bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector128<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                ref Vector128<float> c3 = ref Unsafe.Add(ref c3Base, i);
-
-                Vector128<float> y = c0 * scale;
-                Vector128<float> cb = (c1 * scale) - chromaOffset;
-                Vector128<float> cr = (c2 * scale) - chromaOffset;
-                Vector128<float> scaledK = Vector128<float>.One - (c3 * scale);
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector128<float> r = Vector128_.MultiplyAddEstimate(cr, rCrMult, y) * scaledK;
-                Vector128<float> g = Vector128_.MultiplyAddEstimate(cr, gCrMult, Vector128_.MultiplyAddEstimate(cb, gCbMult, y)) * scaledK;
-                Vector128<float> b = Vector128_.MultiplyAddEstimate(cb, bCbMult, y) * scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => TiffYccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector128<float> srcR =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector128<float> srcG =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector128<float> srcB =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            ref Vector128<float> destY =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> destCb =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> destCr =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> destK =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector128<float> maxSourceValue = Vector128.Create(1 / 255F);
-            Vector128<float> maxSampleValue = Vector128.Create(this.MaximumValue);
-            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue);
-
-            Vector128<float> f0299 = Vector128.Create(0.299f);
-            Vector128<float> f0587 = Vector128.Create(0.587f);
-            Vector128<float> f0114 = Vector128.Create(0.114f);
-            Vector128<float> fn0168736 = Vector128.Create(-0.168736f);
-            Vector128<float> fn0331264 = Vector128.Create(-0.331264f);
-            Vector128<float> fn0418688 = Vector128.Create(-0.418688f);
-            Vector128<float> fn0081312F = Vector128.Create(-0.081312F);
-            Vector128<float> f05 = Vector128.Create(0.5f);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> r = Unsafe.Add(ref srcR, i) * maxSourceValue;
-                Vector128<float> g = Unsafe.Add(ref srcG, i) * maxSourceValue;
-                Vector128<float> b = Unsafe.Add(ref srcB, i) * maxSourceValue;
-                Vector128<float> ktmp = Vector128<float>.One - Vector128.Max(r, Vector128.Min(g, b));
-
-                Vector128<float> kMask = ~Vector128.Equals(ktmp, Vector128<float>.One);
-                Vector128<float> divisor = Vector128<float>.One / (Vector128<float>.One - ktmp);
-
-                r = (r * divisor) & kMask;
-                g = (g * divisor) & kMask;
-                b = (b * divisor) & kMask;
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector128<float> y = Vector128_.MultiplyAddEstimate(f0299, r, Vector128_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAddEstimate(fn0168736, r, Vector128_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAddEstimate(f05, r, Vector128_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y * maxSampleValue;
-                Unsafe.Add(ref destCb, i) = chromaOffset + (cb * maxSampleValue);
-                Unsafe.Add(ref destCr, i) = chromaOffset + (cr * maxSampleValue);
-                Unsafe.Add(ref destK, i) = ktmp * maxSampleValue;
-            }
-        }
-    }
-}

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

@@ -1,131 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class TiffYccKVector256 : JpegColorConverterVector256
-    {
-        public TiffYccKVector256(int precision)
-            : base(JpegColorSpace.TiffYccK, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector256<float> c0Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> c1Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> c2Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector256<float> c3Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector256<float> scale = Vector256.Create(1F / this.MaximumValue);
-            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue) * scale;
-            Vector256<float> rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
-            Vector256<float> gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
-            Vector256<float> gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
-            Vector256<float> bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                ref Vector256<float> c3 = ref Unsafe.Add(ref c3Base, i);
-
-                Vector256<float> y = c0 * scale;
-                Vector256<float> cb = (c1 * scale) - chromaOffset;
-                Vector256<float> cr = (c2 * scale) - chromaOffset;
-                Vector256<float> scaledK = Vector256<float>.One - (c3 * scale);
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector256<float> r = Vector256_.MultiplyAddEstimate(cr, rCrMult, y) * scaledK;
-                Vector256<float> g = Vector256_.MultiplyAddEstimate(cr, gCrMult, Vector256_.MultiplyAddEstimate(cb, gCbMult, y)) * scaledK;
-                Vector256<float> b = Vector256_.MultiplyAddEstimate(cb, bCbMult, y) * scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => TiffYccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector256<float> srcR =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector256<float> srcG =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector256<float> srcB =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            ref Vector256<float> destY =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> destCb =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> destCr =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector256<float> destK =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector256<float> maxSourceValue = Vector256.Create(255F);
-            Vector256<float> maxSampleValue = Vector256.Create(this.MaximumValue);
-            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue);
-
-            Vector256<float> f0299 = Vector256.Create(0.299f);
-            Vector256<float> f0587 = Vector256.Create(0.587f);
-            Vector256<float> f0114 = Vector256.Create(0.114f);
-            Vector256<float> fn0168736 = Vector256.Create(-0.168736f);
-            Vector256<float> fn0331264 = Vector256.Create(-0.331264f);
-            Vector256<float> fn0418688 = Vector256.Create(-0.418688f);
-            Vector256<float> fn0081312F = Vector256.Create(-0.081312F);
-            Vector256<float> f05 = Vector256.Create(0.5f);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector256<float> r = Unsafe.Add(ref srcR, i) / maxSourceValue;
-                Vector256<float> g = Unsafe.Add(ref srcG, i) / maxSourceValue;
-                Vector256<float> b = Unsafe.Add(ref srcB, i) / maxSourceValue;
-                Vector256<float> ktmp = Vector256<float>.One - Vector256.Max(r, Vector256.Min(g, b));
-
-                Vector256<float> kMask = ~Vector256.Equals(ktmp, Vector256<float>.One);
-                Vector256<float> divisor = Vector256<float>.One / (Vector256<float>.One - ktmp);
-
-                r = (r * divisor) & kMask;
-                g = (g * divisor) & kMask;
-                b = (b * divisor) & kMask;
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector256<float> y = Vector256_.MultiplyAddEstimate(f0299, r, Vector256_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAddEstimate(fn0168736, r, Vector256_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAddEstimate(f05, r, Vector256_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y * maxSampleValue;
-                Unsafe.Add(ref destCb, i) = chromaOffset + (cb * maxSampleValue);
-                Unsafe.Add(ref destCr, i) = chromaOffset + (cr * maxSampleValue);
-                Unsafe.Add(ref destK, i) = ktmp * maxSampleValue;
-            }
-        }
-    }
-}

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

@@ -1,142 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class TiffYccKVector512 : JpegColorConverterVector512
-    {
-        public TiffYccKVector512(int precision)
-            : base(JpegColorSpace.TiffYccK, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => TiffYccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
-        {
-            ref Vector512<float> c0Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> c1Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> c2Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector512<float> c3Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector512<float> scale = Vector512.Create(1F / this.MaximumValue);
-            Vector512<float> chromaOffset = Vector512.Create(this.HalfValue) * scale;
-            Vector512<float> rCrMult = Vector512.Create(YCbCrScalar.RCrMult);
-            Vector512<float> gCbMult = Vector512.Create(-YCbCrScalar.GCbMult);
-            Vector512<float> gCrMult = Vector512.Create(-YCbCrScalar.GCrMult);
-            Vector512<float> bCbMult = Vector512.Create(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector512<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector512<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector512<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                ref Vector512<float> c3 = ref Unsafe.Add(ref c3Base, i);
-
-                Vector512<float> y = c0 * scale;
-                Vector512<float> cb = (c1 * scale) - chromaOffset;
-                Vector512<float> cr = (c2 * scale) - chromaOffset;
-                Vector512<float> scaledK = Vector512<float>.One - (c3 * scale);
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector512<float> r = Vector512_.MultiplyAddEstimate(cr, rCrMult, y) * scaledK;
-                Vector512<float> g = Vector512_.MultiplyAddEstimate(cr, gCrMult, Vector512_.MultiplyAddEstimate(cb, gCbMult, y)) * scaledK;
-                Vector512<float> b = Vector512_.MultiplyAddEstimate(cb, bCbMult, y) * scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgbVectorized(in values, this.MaximumValue, this.HalfValue, rLane, gLane, bLane);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
-             => TiffYccKScalar.ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => TiffYccKScalar.ConvertFromRgb(values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
-
-        internal static void ConvertFromRgbVectorized(in ComponentValues values, float maxValue, float halfValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector512<float> srcR =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector512<float> srcG =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector512<float> srcB =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            ref Vector512<float> destY =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> destCb =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> destCr =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector512<float> destK =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            Vector512<float> maxSourceValue = Vector512.Create(255F);
-            Vector512<float> maxSampleValue = Vector512.Create(maxValue);
-            Vector512<float> chromaOffset = Vector512.Create(halfValue);
-
-            Vector512<float> f0299 = Vector512.Create(0.299f);
-            Vector512<float> f0587 = Vector512.Create(0.587f);
-            Vector512<float> f0114 = Vector512.Create(0.114f);
-            Vector512<float> fn0168736 = Vector512.Create(-0.168736f);
-            Vector512<float> fn0331264 = Vector512.Create(-0.331264f);
-            Vector512<float> fn0418688 = Vector512.Create(-0.418688f);
-            Vector512<float> fn0081312F = Vector512.Create(-0.081312F);
-            Vector512<float> f05 = Vector512.Create(0.5f);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector512<float> r = Unsafe.Add(ref srcR, i) / maxSourceValue;
-                Vector512<float> g = Unsafe.Add(ref srcG, i) / maxSourceValue;
-                Vector512<float> b = Unsafe.Add(ref srcB, i) / maxSourceValue;
-                Vector512<float> ktmp = Vector512<float>.One - Vector512.Max(r, Vector512.Min(g, b));
-
-                Vector512<float> kMask = ~Vector512.Equals(ktmp, Vector512<float>.One);
-                Vector512<float> divisor = Vector512<float>.One / (Vector512<float>.One - ktmp);
-
-                r = (r * divisor) & kMask;
-                g = (g * divisor) & kMask;
-                b = (b * divisor) & kMask;
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector512<float> y = Vector512_.MultiplyAddEstimate(f0299, r, Vector512_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAddEstimate(fn0168736, r, Vector512_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAddEstimate(f05, r, Vector512_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y * maxSampleValue;
-                Unsafe.Add(ref destCb, i) = chromaOffset + (cb * maxSampleValue);
-                Unsafe.Add(ref destCr, i) = chromaOffset + (cr * maxSampleValue);
-                Unsafe.Add(ref destK, i) = ktmp * maxSampleValue;
-            }
-        }
-    }
-}

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

@@ -0,0 +1,170 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Implements the JPEG YCbCr conversion formula for scalar and SIMD lanes.
+    /// </summary>
+    internal readonly struct YCbCrOperator : IJpegColorConverterOperator
+    {
+        /// <summary>
+        /// The BT.601 red contribution from centered Cr.
+        /// </summary>
+        public const float RCrMult = 1.402F;
+
+        /// <summary>
+        /// The BT.601 green contribution from centered Cb.
+        /// </summary>
+        public const float GCbMult = (float)(0.114 * 1.772 / 0.587);
+
+        /// <summary>
+        /// The BT.601 green contribution from centered Cr.
+        /// </summary>
+        public const float GCrMult = (float)(0.299 * 1.402 / 0.587);
+
+        /// <summary>
+        /// The BT.601 blue contribution from centered Cb.
+        /// </summary>
+        public const float BCbMult = 1.772F;
+
+        /// <inheritdoc/>
+        public static JpegColorSpace ColorSpace => JpegColorSpace.YCbCr;
+
+        /// <inheritdoc/>
+        public static int ComponentCount => 3;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale)
+        {
+            float y = c0;
+            float cb = c1 - halfValue;
+            float cr = c2 - halfValue;
+
+            // c0/c1/c2 initially mean Y/Cb/Cr. Chroma is centered around zero before applying
+            // the BT.601 matrix, then integer-domain RGB is rounded away from zero and normalized
+            // to [nominally] 0..1. Values intentionally remain unclamped because quantizing RGB into the
+            // destination pixel format owns saturation; retaining overshoot avoids discarding color information.
+            c0 = MathF.Round(y + (RCrMult * cr), MidpointRounding.AwayFromZero) * scale;
+            c1 = MathF.Round(y - (GCbMult * cb) - (GCrMult * cr), MidpointRounding.AwayFromZero) * scale;
+            c2 = MathF.Round(y + (BCbMult * cb), MidpointRounding.AwayFromZero) * scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale)
+        {
+            Vector128<float> y = c0;
+            Vector128<float> cb = c1 - halfValue;
+            Vector128<float> cr = c2 - halfValue;
+
+            // Lanes are four independent Y/Cb/Cr samples. MultiplyAddEstimate maps to FMA where available:
+            // R uses Cr, B uses Cb, and G subtracts both chroma contributions. Rounding occurs in the sample
+            // domain before the common normalization scale so all precisions use integer JPEG sample semantics.
+            Vector128<float> r = Vector128_.MultiplyAddEstimate(cr, Vector128.Create(RCrMult), y);
+            Vector128<float> g = Vector128_.MultiplyAddEstimate(cr, Vector128.Create(-GCrMult), Vector128_.MultiplyAddEstimate(cb, Vector128.Create(-GCbMult), y));
+            Vector128<float> b = Vector128_.MultiplyAddEstimate(cb, Vector128.Create(BCbMult), y);
+
+            c0 = Vector128_.RoundToNearestInteger(r) * scale;
+            c1 = Vector128_.RoundToNearestInteger(g) * scale;
+            c2 = Vector128_.RoundToNearestInteger(b) * scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale)
+        {
+            Vector256<float> y = c0;
+            Vector256<float> cb = c1 - halfValue;
+            Vector256<float> cr = c2 - halfValue;
+
+            // These eight lanes have the same layout and BT.601 arithmetic as the Vector128 overload.
+            // Keeping an explicit overload allows the JIT to emit native YMM operations without a width
+            // switch or decomposing the vector into smaller values.
+            Vector256<float> r = Vector256_.MultiplyAddEstimate(cr, Vector256.Create(RCrMult), y);
+            Vector256<float> g = Vector256_.MultiplyAddEstimate(cr, Vector256.Create(-GCrMult), Vector256_.MultiplyAddEstimate(cb, Vector256.Create(-GCbMult), y));
+            Vector256<float> b = Vector256_.MultiplyAddEstimate(cb, Vector256.Create(BCbMult), y);
+
+            c0 = Vector256_.RoundToNearestInteger(r) * scale;
+            c1 = Vector256_.RoundToNearestInteger(g) * scale;
+            c2 = Vector256_.RoundToNearestInteger(b) * scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale)
+        {
+            Vector512<float> y = c0;
+            Vector512<float> cb = c1 - halfValue;
+            Vector512<float> cr = c2 - halfValue;
+
+            // Sixteen independent samples occupy the ZMM lanes. The explicit constants are broadcasts;
+            // assembly inspection verifies the JIT hoists them from the loop and retains fused operations.
+            // The formula and rounding order remain identical to the narrower overloads.
+            Vector512<float> r = Vector512_.MultiplyAddEstimate(cr, Vector512.Create(RCrMult), y);
+            Vector512<float> g = Vector512_.MultiplyAddEstimate(cr, Vector512.Create(-GCrMult), Vector512_.MultiplyAddEstimate(cb, Vector512.Create(-GCbMult), y));
+            Vector512<float> b = Vector512_.MultiplyAddEstimate(cb, Vector512.Create(BCbMult), y);
+
+            c0 = Vector512_.RoundToNearestInteger(r) * scale;
+            c1 = Vector512_.RoundToNearestInteger(g) * scale;
+            c2 = Vector512_.RoundToNearestInteger(b) * scale;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3)
+        {
+            // The RGB inputs are unnormalized 0..255 encoder lanes. The BT.601 luma weights form Y,
+            // while the signed chroma projections are biased by halfValue into the JPEG sample domain.
+            // YCbCr has no fourth component, so c3 is a compile-time-unused placeholder for the shared loop.
+            c0 = (0.299F * r) + (0.587F * g) + (0.114F * b);
+            c1 = halfValue - (0.168736F * r) - (0.331264F * g) + (0.5F * b);
+            c2 = halfValue + (0.5F * r) - (0.418688F * g) - (0.081312F * b);
+            c3 = 0;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3)
+        {
+            // Each vector holds four consecutive values from one RGB plane. The nested multiply-add sequence
+            // produces four Y lanes, four Cb lanes, and four Cr lanes without transposition. The association
+            // exposes two FMA opportunities per output while preserving the scalar formula's term grouping.
+            c0 = Vector128_.MultiplyAddEstimate(Vector128.Create(0.299F), r, Vector128_.MultiplyAddEstimate(Vector128.Create(0.587F), g, Vector128.Create(0.114F) * b));
+            c1 = halfValue + Vector128_.MultiplyAddEstimate(Vector128.Create(-0.168736F), r, Vector128_.MultiplyAddEstimate(Vector128.Create(-0.331264F), g, Vector128.Create(0.5F) * b));
+            c2 = halfValue + Vector128_.MultiplyAddEstimate(Vector128.Create(0.5F), r, Vector128_.MultiplyAddEstimate(Vector128.Create(-0.418688F), g, Vector128.Create(-0.081312F) * b));
+            c3 = default;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3)
+        {
+            // Eight planar RGB samples use the identical association as Vector128, allowing direct YMM FMA
+            // generation while preserving the component-per-vector output layout.
+            c0 = Vector256_.MultiplyAddEstimate(Vector256.Create(0.299F), r, Vector256_.MultiplyAddEstimate(Vector256.Create(0.587F), g, Vector256.Create(0.114F) * b));
+            c1 = halfValue + Vector256_.MultiplyAddEstimate(Vector256.Create(-0.168736F), r, Vector256_.MultiplyAddEstimate(Vector256.Create(-0.331264F), g, Vector256.Create(0.5F) * b));
+            c2 = halfValue + Vector256_.MultiplyAddEstimate(Vector256.Create(0.5F), r, Vector256_.MultiplyAddEstimate(Vector256.Create(-0.418688F), g, Vector256.Create(-0.081312F) * b));
+            c3 = default;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3)
+        {
+            // Sixteen planar RGB samples use the same nested form. Constants are lane broadcasts and c3 is
+            // deliberately zero because the shared traversal removes the unused fourth store for this operator.
+            c0 = Vector512_.MultiplyAddEstimate(Vector512.Create(0.299F), r, Vector512_.MultiplyAddEstimate(Vector512.Create(0.587F), g, Vector512.Create(0.114F) * b));
+            c1 = halfValue + Vector512_.MultiplyAddEstimate(Vector512.Create(-0.168736F), r, Vector512_.MultiplyAddEstimate(Vector512.Create(-0.331264F), g, Vector512.Create(0.5F) * b));
+            c2 = halfValue + Vector512_.MultiplyAddEstimate(Vector512.Create(0.5F), r, Vector512_.MultiplyAddEstimate(Vector512.Create(-0.418688F), g, Vector512.Create(-0.081312F) * b));
+            c3 = default;
+        }
+    }
+}

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

@@ -1,121 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.ColorProfiles;
-using SixLabors.ImageSharp.ColorProfiles.Icc;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YCbCrScalar : JpegColorConverterScalar
-    {
-        // derived from ITU-T Rec. T.871
-        internal const float RCrMult = 1.402f;
-        internal const float GCbMult = (float)(0.114 * 1.772 / 0.587);
-        internal const float GCrMult = (float)(0.299 * 1.402 / 0.587);
-        internal const float BCbMult = 1.772f;
-
-        public YCbCrScalar(int precision)
-            : base(JpegColorSpace.YCbCr, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-            => ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(values, this.HalfValue, rLane, gLane, bLane);
-
-        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue, float halfValue)
-        {
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-
-            float scale = 1 / maxValue;
-
-            for (int i = 0; i < c0.Length; i++)
-            {
-                float y = c0[i];
-                float cb = c1[i] - halfValue;
-                float cr = c2[i] - halfValue;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                c0[i] = MathF.Round(y + (RCrMult * cr), MidpointRounding.AwayFromZero) * scale;
-                c1[i] = MathF.Round(y - (GCbMult * cb) - (GCrMult * cr), MidpointRounding.AwayFromZero) * scale;
-                c2[i] = MathF.Round(y + (BCbMult * cb), MidpointRounding.AwayFromZero) * scale;
-            }
-        }
-
-        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
-        {
-            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 3);
-            Span<float> packed = memoryOwner.Memory.Span;
-
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-
-            // Although YCbCr is a defined ICC color space, in practice ICC profiles
-            // do not implement transforms from it.
-            // Therefore, we first convert JPEG YCbCr to RGB manually, then perform
-            // color-managed conversion to the target profile.
-            //
-            // The YCbCr => RGB conversion is based on BT.601 and is independent of any embedded ICC profile.
-            // Since the same RGB working space is used during conversion to and from XYZ,
-            // colorimetric accuracy is preserved.
-            ColorProfileConverter converter = new();
-
-            PackedNormalizeInterleave3(c0, c1, c2, packed, 1F / maxValue);
-
-            Span<YCbCr> source = MemoryMarshal.Cast<float, YCbCr>(packed);
-            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed);
-
-            converter.Convert<YCbCr, Rgb>(source, destination);
-
-            ColorConversionOptions options = new()
-            {
-                SourceIccProfile = profile,
-                TargetIccProfile = CompactSrgbV4Profile.Profile,
-            };
-            converter = new ColorProfileConverter(options);
-            converter.Convert<Rgb, Rgb>(destination, destination);
-
-            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
-        }
-
-        public static void ConvertFromRgb(in ComponentValues values, float halfValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            Span<float> y = values.Component0;
-            Span<float> cb = values.Component1;
-            Span<float> cr = values.Component2;
-
-            for (int i = 0; i < y.Length; i++)
-            {
-                float r = rLane[i];
-                float g = gLane[i];
-                float b = bLane[i];
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                y[i] = (0.299f * r) + (0.587f * g) + (0.114f * b);
-                cb[i] = halfValue - (0.168736f * r) - (0.331264f * g) + (0.5f * b);
-                cr[i] = halfValue + (0.5f * r) - (0.418688f * g) - (0.081312f * b);
-            }
-        }
-    }
-}

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

@@ -1,121 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YCbCrVector128 : JpegColorConverterVector128
-    {
-        public YCbCrVector128(int precision)
-            : base(JpegColorSpace.YCbCr, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector128<float> c0Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> c1Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> c2Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            Vector128<float> chromaOffset = Vector128.Create(-this.HalfValue);
-            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
-            Vector128<float> rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
-            Vector128<float> gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
-            Vector128<float> gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
-            Vector128<float> bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
-
-            // Walking 8 elements at one step:
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector128<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
-
-                Vector128<float> y = c0;
-                Vector128<float> cb = c1 + chromaOffset;
-                Vector128<float> cr = c2 + chromaOffset;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector128<float> r = Vector128_.MultiplyAddEstimate(cr, rCrMult, y);
-                Vector128<float> g = Vector128_.MultiplyAddEstimate(cr, gCrMult, Vector128_.MultiplyAddEstimate(cb, gCbMult, y));
-                Vector128<float> b = Vector128_.MultiplyAddEstimate(cb, bCbMult, y);
-
-                r = Vector128_.RoundToNearestInteger(r) * scale;
-                g = Vector128_.RoundToNearestInteger(g) * scale;
-                b = Vector128_.RoundToNearestInteger(b) * scale;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => YCbCrScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector128<float> destY =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> destCb =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> destCr =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector128<float> srcR =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector128<float> srcG =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector128<float> srcB =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue);
-            Vector128<float> f0299 = Vector128.Create(0.299f);
-            Vector128<float> f0587 = Vector128.Create(0.587f);
-            Vector128<float> f0114 = Vector128.Create(0.114f);
-            Vector128<float> fn0168736 = Vector128.Create(-0.168736f);
-            Vector128<float> fn0331264 = Vector128.Create(-0.331264f);
-            Vector128<float> fn0418688 = Vector128.Create(-0.418688f);
-            Vector128<float> fn0081312F = Vector128.Create(-0.081312F);
-            Vector128<float> f05 = Vector128.Create(0.5f);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> r = Unsafe.Add(ref srcR, i);
-                Vector128<float> g = Unsafe.Add(ref srcG, i);
-                Vector128<float> b = Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector128<float> y = Vector128_.MultiplyAddEstimate(f0299, r, Vector128_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAddEstimate(fn0168736, r, Vector128_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAddEstimate(f05, r, Vector128_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y;
-                Unsafe.Add(ref destCb, i) = cb;
-                Unsafe.Add(ref destCr, i) = cr;
-            }
-        }
-    }
-}

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

@@ -1,121 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YCbCrVector256 : JpegColorConverterVector256
-    {
-        public YCbCrVector256(int precision)
-            : base(JpegColorSpace.YCbCr, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector256<float> c0Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> c1Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> c2Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            Vector256<float> chromaOffset = Vector256.Create(-this.HalfValue);
-            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
-            Vector256<float> rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
-            Vector256<float> gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
-            Vector256<float> gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
-            Vector256<float> bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
-
-            // Walking 8 elements at one step:
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
-
-                Vector256<float> y = c0;
-                Vector256<float> cb = c1 + chromaOffset;
-                Vector256<float> cr = c2 + chromaOffset;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector256<float> r = Vector256_.MultiplyAddEstimate(cr, rCrMult, y);
-                Vector256<float> g = Vector256_.MultiplyAddEstimate(cr, gCrMult, Vector256_.MultiplyAddEstimate(cb, gCbMult, y));
-                Vector256<float> b = Vector256_.MultiplyAddEstimate(cb, bCbMult, y);
-
-                r = Vector256_.RoundToNearestInteger(r) * scale;
-                g = Vector256_.RoundToNearestInteger(g) * scale;
-                b = Vector256_.RoundToNearestInteger(b) * scale;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => YCbCrScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector256<float> destY =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> destCb =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> destCr =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector256<float> srcR =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector256<float> srcG =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector256<float> srcB =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue);
-            Vector256<float> f0299 = Vector256.Create(0.299f);
-            Vector256<float> f0587 = Vector256.Create(0.587f);
-            Vector256<float> f0114 = Vector256.Create(0.114f);
-            Vector256<float> fn0168736 = Vector256.Create(-0.168736f);
-            Vector256<float> fn0331264 = Vector256.Create(-0.331264f);
-            Vector256<float> fn0418688 = Vector256.Create(-0.418688f);
-            Vector256<float> fn0081312F = Vector256.Create(-0.081312F);
-            Vector256<float> f05 = Vector256.Create(0.5f);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector256<float> r = Unsafe.Add(ref srcR, i);
-                Vector256<float> g = Unsafe.Add(ref srcG, i);
-                Vector256<float> b = Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector256<float> y = Vector256_.MultiplyAddEstimate(f0299, r, Vector256_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAddEstimate(fn0168736, r, Vector256_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAddEstimate(f05, r, Vector256_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y;
-                Unsafe.Add(ref destCb, i) = cb;
-                Unsafe.Add(ref destCr, i) = cr;
-            }
-        }
-    }
-}

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

@@ -1,128 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YCbCrVector512 : JpegColorConverterVector512
-    {
-        public YCbCrVector512(int precision)
-            : base(JpegColorSpace.YCbCr, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => YCbCrScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
-        {
-            ref Vector512<float> c0Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> c1Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> c2Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            Vector512<float> chromaOffset = Vector512.Create(-this.HalfValue);
-            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
-            Vector512<float> rCrMult = Vector512.Create(YCbCrScalar.RCrMult);
-            Vector512<float> gCbMult = Vector512.Create(-YCbCrScalar.GCbMult);
-            Vector512<float> gCrMult = Vector512.Create(-YCbCrScalar.GCrMult);
-            Vector512<float> bCbMult = Vector512.Create(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                ref Vector512<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector512<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector512<float> c2 = ref Unsafe.Add(ref c2Base, i);
-
-                Vector512<float> y = c0;
-                Vector512<float> cb = c1 + chromaOffset;
-                Vector512<float> cr = c2 + chromaOffset;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector512<float> r = Vector512_.MultiplyAddEstimate(cr, rCrMult, y);
-                Vector512<float> g = Vector512_.MultiplyAddEstimate(cr, gCrMult, Vector512_.MultiplyAddEstimate(cb, gCbMult, y));
-                Vector512<float> b = Vector512_.MultiplyAddEstimate(cb, bCbMult, y);
-
-                r = Vector512_.RoundToNearestInteger(r) * scale;
-                g = Vector512_.RoundToNearestInteger(g) * scale;
-                b = Vector512_.RoundToNearestInteger(b) * scale;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector512<float> destY =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> destCb =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> destCr =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector512<float> srcR =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector512<float> srcG =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector512<float> srcB =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            Vector512<float> chromaOffset = Vector512.Create(this.HalfValue);
-            Vector512<float> f0299 = Vector512.Create(0.299f);
-            Vector512<float> f0587 = Vector512.Create(0.587f);
-            Vector512<float> f0114 = Vector512.Create(0.114f);
-            Vector512<float> fn0168736 = Vector512.Create(-0.168736f);
-            Vector512<float> fn0331264 = Vector512.Create(-0.331264f);
-            Vector512<float> fn0418688 = Vector512.Create(-0.418688f);
-            Vector512<float> fn0081312F = Vector512.Create(-0.081312F);
-            Vector512<float> f05 = Vector512.Create(0.5f);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector512<float> r = Unsafe.Add(ref srcR, i);
-                Vector512<float> g = Unsafe.Add(ref srcG, i);
-                Vector512<float> b = Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector512<float> y = Vector512_.MultiplyAddEstimate(f0299, r, Vector512_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAddEstimate(fn0168736, r, Vector512_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAddEstimate(f05, r, Vector512_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y;
-                Unsafe.Add(ref destCb, i) = cb;
-                Unsafe.Add(ref destCr, i) = cr;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
-            => YCbCrScalar.ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => YCbCrScalar.ConvertFromRgb(values, this.HalfValue, rLane, gLane, bLane);
-    }
-}

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

@@ -0,0 +1,134 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Implements inverted JPEG YccK conversion for scalar and SIMD lanes.
+    /// </summary>
+    internal readonly struct YccKOperator : IJpegColorConverterOperator
+    {
+        /// <inheritdoc/>
+        public static JpegColorSpace ColorSpace => JpegColorSpace.Ycck;
+
+        /// <inheritdoc/>
+        public static int ComponentCount => 4;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref float c0, ref float c1, ref float c2, float c3, float maximumValue, float halfValue, float scale)
+        {
+            float y = c0;
+            float cb = c1 - halfValue;
+            float cr = c2 - halfValue;
+            float scaledK = c3 * scale * scale;
+
+            // YccK first reconstructs inverted RGB in the integer sample domain. Rounding must occur before
+            // subtracting from max and applying K because changing that order changes encoded JPEG semantics.
+            c0 = (maximumValue - MathF.Round(y + (YCbCrOperator.RCrMult * cr), MidpointRounding.AwayFromZero)) * scaledK;
+            c1 = (maximumValue - MathF.Round(y - (YCbCrOperator.GCbMult * cb) - (YCbCrOperator.GCrMult * cr), MidpointRounding.AwayFromZero)) * scaledK;
+            c2 = (maximumValue - MathF.Round(y + (YCbCrOperator.BCbMult * cb), MidpointRounding.AwayFromZero)) * scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector128<float> c0, ref Vector128<float> c1, ref Vector128<float> c2, Vector128<float> c3, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale)
+        {
+            Vector128<float> y = c0;
+            Vector128<float> cb = c1 - halfValue;
+            Vector128<float> cr = c2 - halfValue;
+            Vector128<float> scaledK = c3 * scale * scale;
+
+            // Four lanes reconstruct YCbCr concurrently; each rounded result is inverted and modulated by its K lane.
+            Vector128<float> r = Vector128_.MultiplyAddEstimate(cr, Vector128.Create(YCbCrOperator.RCrMult), y);
+            Vector128<float> g = Vector128_.MultiplyAddEstimate(cr, Vector128.Create(-YCbCrOperator.GCrMult), Vector128_.MultiplyAddEstimate(cb, Vector128.Create(-YCbCrOperator.GCbMult), y));
+            Vector128<float> b = Vector128_.MultiplyAddEstimate(cb, Vector128.Create(YCbCrOperator.BCbMult), y);
+            c0 = (maximumValue - Vector128_.RoundToNearestInteger(r)) * scaledK;
+            c1 = (maximumValue - Vector128_.RoundToNearestInteger(g)) * scaledK;
+            c2 = (maximumValue - Vector128_.RoundToNearestInteger(b)) * scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector256<float> c0, ref Vector256<float> c1, ref Vector256<float> c2, Vector256<float> c3, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale)
+        {
+            Vector256<float> y = c0;
+            Vector256<float> cb = c1 - halfValue;
+            Vector256<float> cr = c2 - halfValue;
+            Vector256<float> scaledK = c3 * scale * scale;
+
+            // Eight lanes retain planar alignment from Y/Cb/Cr/K through normalized RGB.
+            Vector256<float> r = Vector256_.MultiplyAddEstimate(cr, Vector256.Create(YCbCrOperator.RCrMult), y);
+            Vector256<float> g = Vector256_.MultiplyAddEstimate(cr, Vector256.Create(-YCbCrOperator.GCrMult), Vector256_.MultiplyAddEstimate(cb, Vector256.Create(-YCbCrOperator.GCbMult), y));
+            Vector256<float> b = Vector256_.MultiplyAddEstimate(cb, Vector256.Create(YCbCrOperator.BCbMult), y);
+            c0 = (maximumValue - Vector256_.RoundToNearestInteger(r)) * scaledK;
+            c1 = (maximumValue - Vector256_.RoundToNearestInteger(g)) * scaledK;
+            c2 = (maximumValue - Vector256_.RoundToNearestInteger(b)) * scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertToRgb(ref Vector512<float> c0, ref Vector512<float> c1, ref Vector512<float> c2, Vector512<float> c3, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale)
+        {
+            Vector512<float> y = c0;
+            Vector512<float> cb = c1 - halfValue;
+            Vector512<float> cr = c2 - halfValue;
+            Vector512<float> scaledK = c3 * scale * scale;
+
+            // Sixteen lanes use the same matrix, rounding, inversion, and K modulation order as scalar code.
+            Vector512<float> r = Vector512_.MultiplyAddEstimate(cr, Vector512.Create(YCbCrOperator.RCrMult), y);
+            Vector512<float> g = Vector512_.MultiplyAddEstimate(cr, Vector512.Create(-YCbCrOperator.GCrMult), Vector512_.MultiplyAddEstimate(cb, Vector512.Create(-YCbCrOperator.GCbMult), y));
+            Vector512<float> b = Vector512_.MultiplyAddEstimate(cb, Vector512.Create(YCbCrOperator.BCbMult), y);
+            c0 = (maximumValue - Vector512_.RoundToNearestInteger(r)) * scaledK;
+            c1 = (maximumValue - Vector512_.RoundToNearestInteger(g)) * scaledK;
+            c2 = (maximumValue - Vector512_.RoundToNearestInteger(b)) * scaledK;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(float r, float g, float b, float maximumValue, float halfValue, float scale, out float c0, out float c1, out float c2, out float c3)
+        {
+            // CMYK extraction supplies inverted chromatic samples and K. Reflecting the first three results
+            // reconstructs the chromatic RGB that YCbCr encodes, while K passes through untouched.
+            CmykOperator.ConvertFromRgb(r, g, b, maximumValue, halfValue, scale, out float c, out float m, out float y, out c3);
+
+            YCbCrOperator.ConvertFromRgb(maximumValue - c, maximumValue - m, maximumValue - y, maximumValue, halfValue, scale, out c0, out c1, out c2, out _);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector128<float> r, Vector128<float> g, Vector128<float> b, Vector128<float> maximumValue, Vector128<float> halfValue, Vector128<float> scale, out Vector128<float> c0, out Vector128<float> c1, out Vector128<float> c2, out Vector128<float> c3)
+        {
+            // Static constrained calls inline both stages, keeping four pixels in registers without materializing CMYK planes.
+            CmykOperator.ConvertFromRgb(r, g, b, maximumValue, halfValue, scale, out Vector128<float> c, out Vector128<float> m, out Vector128<float> y, out c3);
+
+            YCbCrOperator.ConvertFromRgb(maximumValue - c, maximumValue - m, maximumValue - y, maximumValue, halfValue, scale, out c0, out c1, out c2, out _);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector256<float> r, Vector256<float> g, Vector256<float> b, Vector256<float> maximumValue, Vector256<float> halfValue, Vector256<float> scale, out Vector256<float> c0, out Vector256<float> c1, out Vector256<float> c2, out Vector256<float> c3)
+        {
+            // Eight pixels flow through CMYK extraction and YCbCr projection entirely in YMM registers.
+            CmykOperator.ConvertFromRgb(r, g, b, maximumValue, halfValue, scale, out Vector256<float> c, out Vector256<float> m, out Vector256<float> y, out c3);
+
+            YCbCrOperator.ConvertFromRgb(maximumValue - c, maximumValue - m, maximumValue - y, maximumValue, halfValue, scale, out c0, out c1, out c2, out _);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ConvertFromRgb(Vector512<float> r, Vector512<float> g, Vector512<float> b, Vector512<float> maximumValue, Vector512<float> halfValue, Vector512<float> scale, out Vector512<float> c0, out Vector512<float> c1, out Vector512<float> c2, out Vector512<float> c3)
+        {
+            // Sixteen pixels flow through both mathematical stages in registers without materializing intermediate planes.
+            CmykOperator.ConvertFromRgb(r, g, b, maximumValue, halfValue, scale, out Vector512<float> c, out Vector512<float> m, out Vector512<float> y, out c3);
+
+            YCbCrOperator.ConvertFromRgb(maximumValue - c, maximumValue - m, maximumValue - y, maximumValue, halfValue, scale, out c0, out c1, out c2, out _);
+        }
+    }
+}

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

@@ -1,125 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.ColorProfiles;
-using SixLabors.ImageSharp.ColorProfiles.Icc;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKScalar : JpegColorConverterScalar
-    {
-        // Derived from ITU-T Rec. T.871
-        internal const float RCrMult = 1.402f;
-        internal const float GCbMult = (float)(0.114 * 1.772 / 0.587);
-        internal const float GCrMult = (float)(0.299 * 1.402 / 0.587);
-        internal const float BCbMult = 1.772f;
-
-        public YccKScalar(int precision)
-            : base(JpegColorSpace.Ycck, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-            => ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => ConvertFromRgb(values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
-
-        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue, float halfValue)
-        {
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            float scale = 1 / (maxValue * maxValue);
-
-            for (int i = 0; i < values.Component0.Length; i++)
-            {
-                float y = c0[i];
-                float cb = c1[i] - halfValue;
-                float cr = c2[i] - halfValue;
-                float scaledK = c3[i] * scale;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                c0[i] = (maxValue - MathF.Round(y + (RCrMult * cr), MidpointRounding.AwayFromZero)) * scaledK;
-                c1[i] = (maxValue - MathF.Round(y - (GCbMult * cb) - (GCrMult * cr), MidpointRounding.AwayFromZero)) * scaledK;
-                c2[i] = (maxValue - MathF.Round(y + (BCbMult * cb), MidpointRounding.AwayFromZero)) * scaledK;
-            }
-        }
-
-        public static void ConvertFromRgb(in ComponentValues values, float halfValue, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykScalar.ConvertFromRgb(in values, maxValue, rLane, gLane, bLane);
-
-            // cmyk -> ycck
-            Span<float> c = values.Component0;
-            Span<float> m = values.Component1;
-            Span<float> y = values.Component2;
-
-            for (int i = 0; i < y.Length; i++)
-            {
-                float r = maxValue - c[i];
-                float g = maxValue - m[i];
-                float b = maxValue - y[i];
-
-                // k value is passed untouched from rgb -> cmyk conversion
-                c[i] = (0.299f * r) + (0.587f * g) + (0.114f * b);
-                m[i] = halfValue - (0.168736f * r) - (0.331264f * g) + (0.5f * b);
-                y[i] = halfValue + (0.5f * r) - (0.418688f * g) - (0.081312f * b);
-            }
-        }
-
-        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
-        {
-            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
-            Span<float> packed = memoryOwner.Memory.Span;
-
-            Span<float> c0 = values.Component0;
-            Span<float> c1 = values.Component1;
-            Span<float> c2 = values.Component2;
-            Span<float> c3 = values.Component3;
-
-            PackedInvertNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
-
-            ColorProfileConverter converter = new();
-            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
-
-            // YccK is not a defined ICC color space — it's a JPEG-specific encoding used in Adobe-style CMYK JPEGs.
-            // ICC profiles expect colorimetric CMYK values, so we must first convert YccK to CMYK using a hardcoded inverse transform.
-            // This transform assumes Rec.601 YCbCr coefficients and an inverted K channel.
-            //
-            // The YccK => Cmyk conversion is independent of any embedded ICC profile.
-            // Since the same RGB working space is used during conversion to and from XYZ,
-            // colorimetric accuracy is preserved.
-            converter.Convert<YccK, Cmyk>(MemoryMarshal.Cast<Cmyk, YccK>(source), source);
-
-            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
-
-            ColorConversionOptions options = new()
-            {
-                SourceIccProfile = profile,
-                TargetIccProfile = CompactSrgbV4Profile.Profile,
-            };
-            converter = new ColorProfileConverter(options);
-            converter.Convert<Cmyk, Rgb>(source, destination);
-
-            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
-        }
-    }
-}

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

@@ -1,135 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKVector128 : JpegColorConverterVector128
-    {
-        public YccKVector128(int precision)
-            : base(JpegColorSpace.Ycck, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector128<float> c0Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> c1Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> c2Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> kBase =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            Vector128<float> chromaOffset = Vector128.Create(-this.HalfValue);
-            Vector128<float> scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
-            Vector128<float> max = Vector128.Create(this.MaximumValue);
-            Vector128<float> rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
-            Vector128<float> gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
-            Vector128<float> gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
-            Vector128<float> bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
-
-            // Walking 8 elements at one step:
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                // k = kVals[i] / 256F;
-                ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector128<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                Vector128<float> y = c0;
-                Vector128<float> cb = c1 + chromaOffset;
-                Vector128<float> cr = c2 + chromaOffset;
-                Vector128<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector128<float> r = Vector128_.MultiplyAddEstimate(cr, rCrMult, y);
-                Vector128<float> g = Vector128_.MultiplyAddEstimate(cr, gCrMult, Vector128_.MultiplyAddEstimate(cb, gCbMult, y));
-                Vector128<float> b = Vector128_.MultiplyAddEstimate(cb, bCbMult, y);
-
-                r = max - Vector128_.RoundToNearestInteger(r);
-                g = max - Vector128_.RoundToNearestInteger(g);
-                b = max - Vector128_.RoundToNearestInteger(b);
-
-                r *= scaledK;
-                g *= scaledK;
-                b *= scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => YccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykVector128.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-            // cmyk -> ycck
-            ref Vector128<float> destY =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> destCb =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> destCr =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector128<float> srcR = ref destY;
-            ref Vector128<float> srcG = ref destCb;
-            ref Vector128<float> srcB = ref destCr;
-
-            // Used for the color conversion
-            Vector128<float> maxSampleValue = Vector128.Create(this.MaximumValue);
-
-            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue);
-
-            Vector128<float> f0299 = Vector128.Create(0.299f);
-            Vector128<float> f0587 = Vector128.Create(0.587f);
-            Vector128<float> f0114 = Vector128.Create(0.114f);
-            Vector128<float> fn0168736 = Vector128.Create(-0.168736f);
-            Vector128<float> fn0331264 = Vector128.Create(-0.331264f);
-            Vector128<float> fn0418688 = Vector128.Create(-0.418688f);
-            Vector128<float> fn0081312F = Vector128.Create(-0.081312F);
-            Vector128<float> f05 = Vector128.Create(0.5f);
-
-            nuint n = values.Component0.Vector128Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
-                Vector128<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
-                Vector128<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector128<float> y = Vector128_.MultiplyAddEstimate(f0299, r, Vector128_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAddEstimate(fn0168736, r, Vector128_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAddEstimate(f05, r, Vector128_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y;
-                Unsafe.Add(ref destCb, i) = cb;
-                Unsafe.Add(ref destCr, i) = cr;
-            }
-        }
-    }
-}

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

@@ -1,135 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKVector256 : JpegColorConverterVector256
-    {
-        public YccKVector256(int precision)
-            : base(JpegColorSpace.Ycck, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            ref Vector256<float> c0Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> c1Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> c2Base =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector256<float> kBase =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            Vector256<float> chromaOffset = Vector256.Create(-this.HalfValue);
-            Vector256<float> scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
-            Vector256<float> max = Vector256.Create(this.MaximumValue);
-            Vector256<float> rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
-            Vector256<float> gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
-            Vector256<float> gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
-            Vector256<float> bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
-
-            // Walking 8 elements at one step:
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                // k = kVals[i] / 256F;
-                ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                Vector256<float> y = c0;
-                Vector256<float> cb = c1 + chromaOffset;
-                Vector256<float> cr = c2 + chromaOffset;
-                Vector256<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector256<float> r = Vector256_.MultiplyAddEstimate(cr, rCrMult, y);
-                Vector256<float> g = Vector256_.MultiplyAddEstimate(cr, gCrMult, Vector256_.MultiplyAddEstimate(cb, gCbMult, y));
-                Vector256<float> b = Vector256_.MultiplyAddEstimate(cb, bCbMult, y);
-
-                r = max - Vector256_.RoundToNearestInteger(r);
-                g = max - Vector256_.RoundToNearestInteger(g);
-                b = max - Vector256_.RoundToNearestInteger(b);
-
-                r *= scaledK;
-                g *= scaledK;
-                b *= scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => YccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykVector256.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-            // cmyk -> ycck
-            ref Vector256<float> destY =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector256<float> destCb =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector256<float> destCr =
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector256<float> srcR = ref destY;
-            ref Vector256<float> srcG = ref destCb;
-            ref Vector256<float> srcB = ref destCr;
-
-            // Used for the color conversion
-            Vector256<float> maxSampleValue = Vector256.Create(this.MaximumValue);
-
-            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue);
-
-            Vector256<float> f0299 = Vector256.Create(0.299f);
-            Vector256<float> f0587 = Vector256.Create(0.587f);
-            Vector256<float> f0114 = Vector256.Create(0.114f);
-            Vector256<float> fn0168736 = Vector256.Create(-0.168736f);
-            Vector256<float> fn0331264 = Vector256.Create(-0.331264f);
-            Vector256<float> fn0418688 = Vector256.Create(-0.418688f);
-            Vector256<float> fn0081312F = Vector256.Create(-0.081312F);
-            Vector256<float> f05 = Vector256.Create(0.5f);
-
-            nuint n = values.Component0.Vector256Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector256<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
-                Vector256<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
-                Vector256<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector256<float> y = Vector256_.MultiplyAddEstimate(f0299, r, Vector256_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAddEstimate(fn0168736, r, Vector256_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAddEstimate(f05, r, Vector256_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y;
-                Unsafe.Add(ref destCb, i) = cb;
-                Unsafe.Add(ref destCr, i) = cr;
-            }
-        }
-    }
-}

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

@@ -1,143 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.Common.Helpers;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKVector512 : JpegColorConverterVector512
-    {
-        public YccKVector512(int precision)
-            : base(JpegColorSpace.Ycck, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
-        {
-            ref Vector512<float> c0Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> c1Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> c2Base =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector512<float> kBase =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            Vector512<float> chromaOffset = Vector512.Create(-this.HalfValue);
-            Vector512<float> scale = Vector512.Create(1 / (this.MaximumValue * this.MaximumValue));
-            Vector512<float> max = Vector512.Create(this.MaximumValue);
-            Vector512<float> rCrMult = Vector512.Create(YCbCrScalar.RCrMult);
-            Vector512<float> gCbMult = Vector512.Create(-YCbCrScalar.GCbMult);
-            Vector512<float> gCrMult = Vector512.Create(-YCbCrScalar.GCrMult);
-            Vector512<float> bCbMult = Vector512.Create(YCbCrScalar.BCbMult);
-
-            // Walking 8 elements at one step:
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                // k = kVals[i] / 256F;
-                ref Vector512<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector512<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector512<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                Vector512<float> y = c0;
-                Vector512<float> cb = c1 + chromaOffset;
-                Vector512<float> cr = c2 + chromaOffset;
-                Vector512<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector512<float> r = Vector512_.MultiplyAddEstimate(cr, rCrMult, y);
-                Vector512<float> g = Vector512_.MultiplyAddEstimate(cr, gCrMult, Vector512_.MultiplyAddEstimate(cb, gCbMult, y));
-                Vector512<float> b = Vector512_.MultiplyAddEstimate(cb, bCbMult, y);
-
-                r = max - Vector512_.RoundToNearestInteger(r);
-                g = max - Vector512_.RoundToNearestInteger(g);
-                b = max - Vector512_.RoundToNearestInteger(b);
-
-                r *= scaledK;
-                g *= scaledK;
-                b *= scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
-            => YccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
-            => YccKScalar.ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykVector512.ConvertFromRgbVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
-
-            // cmyk -> ycck
-            ref Vector512<float> destY =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector512<float> destCb =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector512<float> destCr =
-                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector512<float> srcR = ref destY;
-            ref Vector512<float> srcG = ref destCb;
-            ref Vector512<float> srcB = ref destCr;
-
-            // Used for the color conversion
-            Vector512<float> maxSampleValue = Vector512.Create(this.MaximumValue);
-
-            Vector512<float> chromaOffset = Vector512.Create(this.HalfValue);
-
-            Vector512<float> f0299 = Vector512.Create(0.299f);
-            Vector512<float> f0587 = Vector512.Create(0.587f);
-            Vector512<float> f0114 = Vector512.Create(0.114f);
-            Vector512<float> fn0168736 = Vector512.Create(-0.168736f);
-            Vector512<float> fn0331264 = Vector512.Create(-0.331264f);
-            Vector512<float> fn0418688 = Vector512.Create(-0.418688f);
-            Vector512<float> fn0081312F = Vector512.Create(-0.081312F);
-            Vector512<float> f05 = Vector512.Create(0.5f);
-
-            nuint n = values.Component0.Vector512Count<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector512<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
-                Vector512<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
-                Vector512<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector512<float> y = Vector512_.MultiplyAddEstimate(f0299, r, Vector512_.MultiplyAddEstimate(f0587, g, f0114 * b));
-                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAddEstimate(fn0168736, r, Vector512_.MultiplyAddEstimate(fn0331264, g, f05 * b));
-                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAddEstimate(f05, r, Vector512_.MultiplyAddEstimate(fn0418688, g, fn0081312F * b));
-
-                Unsafe.Add(ref destY, i) = y;
-                Unsafe.Add(ref destCb, i) = cb;
-                Unsafe.Add(ref destCr, i) = cr;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-            => YccKScalar.ConvertFromRgb(in values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.Icc.cs

@@ -0,0 +1,140 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space in-place using the given ICC profile.
+    /// </summary>
+    /// <param name="configuration">The configuration instance to use for the conversion.</param>
+    /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct.</param>
+    /// <param name="profile">The ICC profile to use for the conversion.</param>
+    public void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+    {
+        Span<float> c0 = values.Component0;
+        Span<float> c1 = values.Component1;
+        Span<float> c2 = values.Component2;
+        int length = c0.Length;
+
+        // Four-component JPEG models need room for an interleaved CMYK or YccK source. Every conversion
+        // finishes with three packed RGB floats, which safely occupy the start of the same temporary buffer.
+        bool hasFourthComponent = this.ColorSpace is JpegColorSpace.Ycck
+            or JpegColorSpace.Cmyk
+            or JpegColorSpace.TiffYccK
+            or JpegColorSpace.TiffCmyk;
+        int packedComponentCount = hasFourthComponent ? 4 : 3;
+
+        using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(length * packedComponentCount);
+        Span<float> packed = memoryOwner.Memory.Span;
+
+        if (this.ColorSpace == JpegColorSpace.Grayscale)
+        {
+            // The single luminance plane is the ICC source, so it is normalized in place. The temporary
+            // buffer is still RGB-sized because the profile conversion expands each Y sample to three lanes.
+            TensorPrimitives_.Multiply(c0, 1F / this.MaximumValue, c0);
+
+            Span<Y> source = MemoryMarshal.Cast<float, Y>(c0);
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed);
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+
+            ColorProfileConverter converter = new(options);
+            converter.Convert<Y, Rgb>(source, destination);
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..length], c0, c1, c2);
+            return;
+        }
+
+        // RGB and YCbCr become packed RGB before the profile transform. CMYK models remain packed CMYK,
+        // because their source profile describes that four-component space rather than an intermediate RGB space.
+        bool profileSourceIsCmyk = false;
+
+        switch (this.ColorSpace)
+        {
+            case JpegColorSpace.RGB:
+                // JPEG RGB planes use the integer sample domain; ICC RGB values use normalized interleaved lanes.
+                PackedNormalizeInterleave3(c0, c1, c2, packed, 1F / this.MaximumValue);
+                break;
+
+            case JpegColorSpace.YCbCr:
+                // ICC profiles rarely expose YCbCr transforms. BT.601 therefore produces RGB in the profile's
+                // source space first, and that packed RGB becomes the input to the profile transform below.
+                PackedNormalizeInterleave3(c0, c1, c2, packed, 1F / this.MaximumValue);
+
+                ColorProfileConverter yCbCrConverter = new();
+                Span<YCbCr> yCbCr = MemoryMarshal.Cast<float, YCbCr>(packed);
+                Span<Rgb> yCbCrDestination = MemoryMarshal.Cast<float, Rgb>(packed);
+                yCbCrConverter.Convert<YCbCr, Rgb>(yCbCr, yCbCrDestination);
+                break;
+
+            case JpegColorSpace.Cmyk:
+                // Adobe-style JPEG CMYK stores inverted samples, while ICC consumes conventional normalized CMYK.
+                PackedInvertNormalizeInterleave4(c0, c1, c2, values.Component3, packed, this.MaximumValue);
+                profileSourceIsCmyk = true;
+                break;
+
+            case JpegColorSpace.TiffCmyk:
+                // TIFF JPEG CMYK is already non-inverted, so only normalization and interleaving are required.
+                PackedNormalizeInterleave4(c0, c1, c2, values.Component3, packed, this.MaximumValue);
+                profileSourceIsCmyk = true;
+                break;
+
+            case JpegColorSpace.Ycck:
+                // Adobe-style JPEG YccK is inverted before its format-defined YccK-to-CMYK transform.
+                PackedInvertNormalizeInterleave4(c0, c1, c2, values.Component3, packed, this.MaximumValue);
+
+                ColorProfileConverter yccKConverter = new();
+                Span<Cmyk> yccKCmyk = MemoryMarshal.Cast<float, Cmyk>(packed);
+                yccKConverter.Convert<YccK, Cmyk>(MemoryMarshal.Cast<Cmyk, YccK>(yccKCmyk), yccKCmyk);
+                profileSourceIsCmyk = true;
+                break;
+
+            case JpegColorSpace.TiffYccK:
+                // TIFF JPEG YccK is non-inverted, but otherwise uses the same YccK-to-CMYK transform.
+                PackedNormalizeInterleave4(c0, c1, c2, values.Component3, packed, this.MaximumValue);
+
+                ColorProfileConverter tiffYccKConverter = new();
+                Span<Cmyk> tiffYccKCmyk = MemoryMarshal.Cast<float, Cmyk>(packed);
+                tiffYccKConverter.Convert<YccK, Cmyk>(MemoryMarshal.Cast<Cmyk, YccK>(tiffYccKCmyk), tiffYccKCmyk);
+                profileSourceIsCmyk = true;
+                break;
+        }
+
+        ColorConversionOptions profileOptions = new()
+        {
+            SourceIccProfile = profile,
+            TargetIccProfile = CompactSrgbV4Profile.Profile,
+        };
+
+        ColorProfileConverter profileConverter = new(profileOptions);
+        Span<Rgb> rgb = MemoryMarshal.Cast<float, Rgb>(packed)[..length];
+
+        if (profileSourceIsCmyk)
+        {
+            // The destination aliases the first three floats of each four-float source item. The converter
+            // supports this established in-place contraction, and the source span retains its original length.
+            profileConverter.Convert<Cmyk, Rgb>(MemoryMarshal.Cast<float, Cmyk>(packed), rgb);
+        }
+        else
+        {
+            profileConverter.Convert<Rgb, Rgb>(rgb, rgb);
+        }
+
+        // Only the packed RGB prefix is meaningful after four-component conversion; scatter it back to the
+        // decoder's three planar output buffers while leaving the fourth source component untouched.
+        UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..length], c0, c1, c2);
+    }
+}

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

@@ -2,11 +2,7 @@
 // Licensed under the Six Labors Split License.
 #nullable disable
 
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
@@ -84,14 +80,6 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
     public abstract void ConvertToRgbInPlace(in ComponentValues values);
 
-    /// <summary>
-    /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space in-place using the given ICC profile.
-    /// </summary>
-    /// <param name="configuration">The configuration instance to use for the conversion.</param>
-    /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct.</param>
-    /// <param name="profile">The ICC profile to use for the conversion.</param>
-    public abstract void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile);
-
     /// <summary>
     /// Converts RGB lanes to jpeg component values.
     /// </summary>
@@ -101,124 +89,6 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="bLane">Blue colors lane.</param>
     public abstract void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
 
-    public static void PackedNormalizeInterleave3(
-        ReadOnlySpan<float> xLane,
-        ReadOnlySpan<float> yLane,
-        ReadOnlySpan<float> zLane,
-        Span<float> packed,
-        float scale)
-    {
-        DebugGuard.IsTrue(packed.Length % 3 == 0, "Packed length must be divisible by 3.");
-        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
-        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
-        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 3, xLane.Length, nameof(packed));
-
-        // TODO: Investigate SIMD version of this.
-        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
-        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
-        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
-        ref float packedRef = ref MemoryMarshal.GetReference(packed);
-
-        for (nuint i = 0; i < (nuint)xLane.Length; i++)
-        {
-            nuint baseIdx = i * 3;
-            Unsafe.Add(ref packedRef, baseIdx) = Unsafe.Add(ref xLaneRef, i) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 1) = Unsafe.Add(ref yLaneRef, i) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 2) = Unsafe.Add(ref zLaneRef, i) * scale;
-        }
-    }
-
-    public static void UnpackDeinterleave3(
-        ReadOnlySpan<Vector3> packed,
-        Span<float> xLane,
-        Span<float> yLane,
-        Span<float> zLane)
-    {
-        DebugGuard.IsTrue(packed.Length == xLane.Length, nameof(packed), "Channels must be of same size!");
-        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
-        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
-
-        // TODO: Investigate SIMD version of this.
-        ref float packedRef = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<Vector3, float>(packed));
-        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
-        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
-        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
-
-        for (nuint i = 0; i < (nuint)packed.Length; i++)
-        {
-            nuint baseIdx = i * 3;
-            Unsafe.Add(ref xLaneRef, i) = Unsafe.Add(ref packedRef, baseIdx);
-            Unsafe.Add(ref yLaneRef, i) = Unsafe.Add(ref packedRef, baseIdx + 1);
-            Unsafe.Add(ref zLaneRef, i) = Unsafe.Add(ref packedRef, baseIdx + 2);
-        }
-    }
-
-    public static void PackedNormalizeInterleave4(
-        ReadOnlySpan<float> xLane,
-        ReadOnlySpan<float> yLane,
-        ReadOnlySpan<float> zLane,
-        ReadOnlySpan<float> wLane,
-        Span<float> packed,
-        float maxValue)
-    {
-        DebugGuard.IsTrue(packed.Length % 4 == 0, "Packed length must be divisible by 4.");
-        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
-        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
-        DebugGuard.IsTrue(wLane.Length == xLane.Length, nameof(wLane), "Channels must be of same size!");
-        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 4, xLane.Length, nameof(packed));
-
-        float scale = 1F / maxValue;
-
-        // TODO: Investigate SIMD version of this.
-        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
-        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
-        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
-        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
-        ref float packedRef = ref MemoryMarshal.GetReference(packed);
-
-        for (nuint i = 0; i < (nuint)xLane.Length; i++)
-        {
-            nuint baseIdx = i * 4;
-            Unsafe.Add(ref packedRef, baseIdx) = Unsafe.Add(ref xLaneRef, i) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 1) = Unsafe.Add(ref yLaneRef, i) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 2) = Unsafe.Add(ref zLaneRef, i) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 3) = Unsafe.Add(ref wLaneRef, i) * scale;
-        }
-    }
-
-    public static void PackedInvertNormalizeInterleave4(
-        ReadOnlySpan<float> xLane,
-        ReadOnlySpan<float> yLane,
-        ReadOnlySpan<float> zLane,
-        ReadOnlySpan<float> wLane,
-        Span<float> packed,
-        float maxValue)
-    {
-        DebugGuard.IsTrue(packed.Length % 4 == 0, "Packed length must be divisible by 4.");
-        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
-        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
-        DebugGuard.IsTrue(wLane.Length == xLane.Length, nameof(wLane), "Channels must be of same size!");
-        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 4, xLane.Length, nameof(packed));
-
-        float scale = 1F / maxValue;
-
-        // TODO: Investigate SIMD version of this.
-        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
-        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
-        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
-        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
-        ref float packedRef = ref MemoryMarshal.GetReference(packed);
-
-        for (nuint i = 0; i < (nuint)xLane.Length; i++)
-        {
-            nuint baseIdx = i * 4;
-            Unsafe.Add(ref packedRef, baseIdx) = (maxValue - Unsafe.Add(ref xLaneRef, i)) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 1) = (maxValue - Unsafe.Add(ref yLaneRef, i)) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 2) = (maxValue - Unsafe.Add(ref zLaneRef, i)) * scale;
-            Unsafe.Add(ref packedRef, baseIdx + 3) = (maxValue - Unsafe.Add(ref wLaneRef, i)) * scale;
-        }
-    }
-
     /// <summary>
     /// Returns the <see cref="JpegColorConverterBase"/>s for all supported color spaces and precisions.
     /// </summary>
@@ -248,161 +118,50 @@ internal abstract partial class JpegColorConverterBase
     /// Returns the <see cref="JpegColorConverterBase"/>s for the YCbCr colorspace.
     /// </summary>
     /// <param name="precision">The precision in bits.</param>
-    private static JpegColorConverterBase GetYCbCrConverter(int precision)
+    private static JpegColorConverter<YCbCrOperator> GetYCbCrConverter(int precision)
-    {
+        => new JpegColorConverter<YCbCrOperator>(precision);
-        if (JpegColorConverterVector512.IsSupported)
-        {
-            return new YCbCrVector512(precision);
-        }
-
-        if (JpegColorConverterVector256.IsSupported)
-        {
-            return new YCbCrVector256(precision);
-        }
-
-        if (JpegColorConverterVector128.IsSupported)
-        {
-            return new YCbCrVector128(precision);
-        }
-
-        return new YCbCrScalar(precision);
-    }
 
     /// <summary>
     /// Returns the <see cref="JpegColorConverterBase"/>s for the YccK colorspace.
     /// </summary>
     /// <param name="precision">The precision in bits.</param>
-    private static JpegColorConverterBase GetYccKConverter(int precision)
+    private static JpegColorConverter<YccKOperator> GetYccKConverter(int precision)
-    {
+        => new JpegColorConverter<YccKOperator>(precision);
-        if (JpegColorConverterVector512.IsSupported)
-        {
-            return new YccKVector512(precision);
-        }
-
-        if (JpegColorConverterVector256.IsSupported)
-        {
-            return new YccKVector256(precision);
-        }
-
-        if (JpegColorConverterVector128.IsSupported)
-        {
-            return new YccKVector128(precision);
-        }
-
-        return new YccKScalar(precision);
-    }
 
     /// <summary>
     /// Returns the <see cref="JpegColorConverterBase"/>s for the CMYK colorspace.
     /// </summary>
     /// <param name="precision">The precision in bits.</param>
-    private static JpegColorConverterBase GetCmykConverter(int precision)
+    private static JpegColorConverter<CmykOperator> GetCmykConverter(int precision)
-    {
+        => new JpegColorConverter<CmykOperator>(precision);
-        if (JpegColorConverterVector512.IsSupported)
-        {
-            return new CmykVector512(precision);
-        }
-
-        if (JpegColorConverterVector256.IsSupported)
-        {
-            return new CmykVector256(precision);
-        }
-
-        if (JpegColorConverterVector128.IsSupported)
-        {
-            return new CmykVector128(precision);
-        }
-
-        return new CmykScalar(precision);
-    }
 
     /// <summary>
     /// Returns the <see cref="JpegColorConverterBase"/>s for the gray scale colorspace.
     /// </summary>
     /// <param name="precision">The precision in bits.</param>
-    private static JpegColorConverterBase GetGrayScaleConverter(int precision)
+    private static JpegColorConverter<GrayScaleOperator> GetGrayScaleConverter(int precision)
-    {
+        => new JpegColorConverter<GrayScaleOperator>(precision);
-        if (JpegColorConverterVector512.IsSupported)
-        {
-            return new GrayScaleVector512(precision);
-        }
-
-        if (JpegColorConverterVector256.IsSupported)
-        {
-            return new GrayScaleVector256(precision);
-        }
-
-        if (JpegColorConverterVector128.IsSupported)
-        {
-            return new GrayScaleVector128(precision);
-        }
-
-        return new GrayScaleScalar(precision);
-    }
 
     /// <summary>
     /// Returns the <see cref="JpegColorConverterBase"/>s for the RGB colorspace.
     /// </summary>
     /// <param name="precision">The precision in bits.</param>
-    private static JpegColorConverterBase GetRgbConverter(int precision)
+    private static JpegColorConverter<RgbOperator> GetRgbConverter(int precision)
-    {
+        => new JpegColorConverter<RgbOperator>(precision);
-        if (JpegColorConverterVector512.IsSupported)
-        {
-            return new RgbVector512(precision);
-        }
-
-        if (JpegColorConverterVector256.IsSupported)
-        {
-            return new RgbVector256(precision);
-        }
-
-        if (JpegColorConverterVector128.IsSupported)
-        {
-            return new RgbVector128(precision);
-        }
-
-        return new RgbScalar(precision);
-    }
-
-    private static JpegColorConverterBase GetTiffCmykConverter(int precision)
-    {
-        if (JpegColorConverterVector512.IsSupported)
-        {
-            return new TiffCmykVector512(precision);
-        }
 
-        if (JpegColorConverterVector256.IsSupported)
+    /// <summary>
-        {
+    /// Returns the <see cref="JpegColorConverterBase"/> for non-inverted TIFF CMYK.
-            return new TiffCmykVector256(precision);
+    /// </summary>
-        }
+    /// <param name="precision">The precision in bits.</param>
-
+    private static JpegColorConverter<TiffCmykOperator> GetTiffCmykConverter(int precision)
-        if (JpegColorConverterVector128.IsSupported)
+        => new JpegColorConverter<TiffCmykOperator>(precision);
-        {
-            return new TiffCmykVector128(precision);
-        }
-
-        return new TiffCmykScalar(precision);
-    }
-
-    private static JpegColorConverterBase GetTiffYccKConverter(int precision)
-    {
-        if (JpegColorConverterVector512.IsSupported)
-        {
-            return new TiffYccKVector512(precision);
-        }
-
-        if (JpegColorConverterVector256.IsSupported)
-        {
-            return new TiffYccKVector256(precision);
-        }
-
-        if (JpegColorConverterVector128.IsSupported)
-        {
-            return new TiffYccKVector128(precision);
-        }
 
-        return new TiffYccKScalar(precision);
+    /// <summary>
-    }
+    /// Returns the <see cref="JpegColorConverterBase"/> for non-inverted TIFF YccK.
+    /// </summary>
+    /// <param name="precision">The precision in bits.</param>
+    private static JpegColorConverter<TiffYccKOperator> GetTiffYccKConverter(int precision)
+        => new JpegColorConverter<TiffYccKOperator>(precision);
 
     /// <summary>
     /// A stack-only struct to reference the input buffers using <see cref="ReadOnlySpan{T}"/>-s.
@@ -493,6 +252,14 @@ internal abstract partial class JpegColorConverterBase
             this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : [];
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ComponentValues"/> struct from explicitly supplied planar spans.
+        /// </summary>
+        /// <param name="componentCount">The number of populated component planes.</param>
+        /// <param name="c0">The first component plane.</param>
+        /// <param name="c1">The second component plane, if present.</param>
+        /// <param name="c2">The third component plane, if present.</param>
+        /// <param name="c3">The fourth component plane, if present.</param>
         internal ComponentValues(
             int componentCount,
             Span<float> c0,
@@ -507,6 +274,12 @@ internal abstract partial class JpegColorConverterBase
             this.Component3 = c3;
         }
 
+        /// <summary>
+        /// Creates a view over the same component planes for the requested sample range.
+        /// </summary>
+        /// <param name="start">The zero-based sample offset.</param>
+        /// <param name="length">The number of samples in each returned plane.</param>
+        /// <returns>The sliced component values.</returns>
         public ComponentValues Slice(int start, int length)
         {
             Span<float> c0 = this.Component0.Slice(start, length);

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

@@ -1,23 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on scalar instructions.
-    /// </summary>
-    internal abstract class JpegColorConverterScalar : JpegColorConverterBase
-    {
-        protected JpegColorConverterScalar(JpegColorSpace colorSpace, int precision)
-            : base(colorSpace, precision)
-        {
-        }
-
-        public sealed override bool IsAvailable => true;
-
-        public sealed override int ElementsPerBatch => 1;
-    }
-}

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

@@ -1,129 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Vector"/> API.
-    /// </summary>
-    /// <remarks>
-    /// Converters of this family can work with data of any size.
-    /// Even though real life data is guaranteed to be of size
-    /// divisible by 8 newer SIMD instructions like AVX512 won't work with
-    /// such data out of the box. These converters have fallback code
-    /// for 'remainder' data.
-    /// </remarks>
-    internal abstract class JpegColorConverterVector : JpegColorConverterBase
-    {
-        protected JpegColorConverterVector(JpegColorSpace colorSpace, int precision)
-            : base(colorSpace, precision)
-        {
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether this converter is supported on current hardware.
-        /// </summary>
-        public static bool IsSupported => Vector.IsHardwareAccelerated && Vector<float>.Count % 4 == 0;
-
-        /// <inheritdoc/>
-        public sealed override bool IsAvailable => IsSupported;
-
-        public override int ElementsPerBatch => Vector<float>.Count;
-
-        /// <inheritdoc/>
-        public sealed override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
-
-            int length = values.Component0.Length;
-            int remainder = (int)((uint)length % (uint)Vector<float>.Count);
-
-            int simdCount = length - remainder;
-            if (simdCount > 0)
-            {
-                this.ConvertToRgbInPlaceVectorized(values.Slice(0, simdCount));
-            }
-
-            // Jpeg images width is always divisible by 8 without a remainder
-            // so it's safe to say SSE/AVX1/AVX2 implementations would never have
-            // 'remainder' pixels
-            // But some exotic simd implementations e.g. AVX-512 can have
-            // remainder pixels
-            if (remainder > 0)
-            {
-                this.ConvertToRgbInPlaceScalarRemainder(values.Slice(simdCount, remainder));
-            }
-        }
-
-        /// <inheritdoc/>
-        public sealed override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
-
-            int length = values.Component0.Length;
-            int remainder = (int)((uint)length % (uint)Vector<float>.Count);
-
-            int simdCount = length - remainder;
-            if (simdCount > 0)
-            {
-                this.ConvertFromRgbVectorized(
-                    values.Slice(0, simdCount),
-                    rLane[..simdCount],
-                    gLane[..simdCount],
-                    bLane[..simdCount]);
-            }
-
-            // Jpeg images width is always divisible by 8 without a remainder
-            // so it's safe to say SSE/AVX1/AVX2 implementations would never have
-            // 'remainder' pixels
-            // But some exotic simd implementations e.g. AVX-512 can have
-            // remainder pixels
-            if (remainder > 0)
-            {
-                this.ConvertFromRgbScalarRemainder(
-                    values.Slice(simdCount, remainder),
-                    rLane.Slice(simdCount, remainder),
-                    gLane.Slice(simdCount, remainder),
-                    bLane.Slice(simdCount, remainder));
-            }
-        }
-
-        /// <summary>
-        /// Converts planar jpeg component values in <paramref name="values"/>
-        /// to RGB color space in place using <see cref="Vector"/> API.
-        /// </summary>
-        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInPlaceVectorized(in ComponentValues values);
-
-        /// <summary>
-        /// Converts remainder of the planar jpeg component values after
-        /// conversion in <see cref="ConvertToRgbInPlaceVectorized(in ComponentValues)"/>.
-        /// </summary>
-        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values);
-
-        /// <summary>
-        /// Converts RGB lanes to jpeg component values using <see cref="Vector"/> API.
-        /// </summary>
-        /// <param name="values">Jpeg component values.</param>
-        /// <param name="rLane">Red colors lane.</param>
-        /// <param name="gLane">Green colors lane.</param>
-        /// <param name="bLane">Blue colors lane.</param>
-        protected abstract void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
-
-        /// <summary>
-        /// Converts remainder of RGB lanes to jpeg component values after
-        ///  conversion in <see cref="ConvertFromRgbVectorized(in ComponentValues, Span{float}, Span{float}, Span{float})"/>.
-        /// </summary>
-        /// <param name="values">Jpeg component values.</param>
-        /// <param name="rLane">Red colors lane.</param>
-        /// <param name="gLane">Green colors lane.</param>
-        /// <param name="bLane">Blue colors lane.</param>
-        protected abstract void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
-    }
-}

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

@@ -1,34 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.Intrinsics;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Vector128{T}"/> instructions.
-    /// </summary>
-    /// <remarks>
-    /// Converters of this family would expect input buffers lengths to be
-    /// divisible by 8 without a remainder.
-    /// This is guaranteed by real-life data as jpeg stores pixels via 8x8 blocks.
-    /// DO NOT pass test data of invalid size to these converters as they
-    /// potentially won't do a bound check and return a false positive result.
-    /// </remarks>
-    internal abstract class JpegColorConverterVector128 : JpegColorConverterBase
-    {
-        protected JpegColorConverterVector128(JpegColorSpace colorSpace, int precision)
-            : base(colorSpace, precision)
-        {
-        }
-
-        public static bool IsSupported => Vector128.IsHardwareAccelerated;
-
-        public sealed override bool IsAvailable => IsSupported;
-
-        public sealed override int ElementsPerBatch => Vector128<float>.Count;
-    }
-}

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

@@ -1,34 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.Intrinsics;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Vector256{T}"/> instructions.
-    /// </summary>
-    /// <remarks>
-    /// Converters of this family would expect input buffers lengths to be
-    /// divisible by 8 without a remainder.
-    /// This is guaranteed by real-life data as jpeg stores pixels via 8x8 blocks.
-    /// DO NOT pass test data of invalid size to these converters as they
-    /// potentially won't do a bound check and return a false positive result.
-    /// </remarks>
-    internal abstract class JpegColorConverterVector256 : JpegColorConverterBase
-    {
-        protected JpegColorConverterVector256(JpegColorSpace colorSpace, int precision)
-            : base(colorSpace, precision)
-        {
-        }
-
-        public static bool IsSupported => Vector256.IsHardwareAccelerated;
-
-        public sealed override bool IsAvailable => IsSupported;
-
-        public sealed override int ElementsPerBatch => Vector256<float>.Count;
-    }
-}

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

@@ -1,111 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.Intrinsics;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Vector512{T}"/> instructions.
-    /// </summary>
-    internal abstract class JpegColorConverterVector512 : JpegColorConverterBase
-    {
-        protected JpegColorConverterVector512(JpegColorSpace colorSpace, int precision)
-            : base(colorSpace, precision)
-        {
-        }
-
-        public static bool IsSupported => Vector512.IsHardwareAccelerated;
-
-        /// <inheritdoc/>
-        public override bool IsAvailable => IsSupported;
-
-        /// <inheritdoc/>
-        public override int ElementsPerBatch => Vector512<float>.Count;
-
-        /// <inheritdoc/>
-        public sealed override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
-
-            int length = values.Component0.Length;
-            int remainder = (int)((uint)length % (uint)Vector512<float>.Count);
-
-            int simdCount = length - remainder;
-            if (simdCount > 0)
-            {
-                this.ConvertFromRgbVectorized(
-                    values.Slice(0, simdCount),
-                    rLane[..simdCount],
-                    gLane[..simdCount],
-                    bLane[..simdCount]);
-            }
-
-            if (remainder > 0)
-            {
-                this.ConvertFromRgbScalarRemainder(
-                    values.Slice(simdCount, remainder),
-                    rLane.Slice(simdCount, remainder),
-                    gLane.Slice(simdCount, remainder),
-                    bLane.Slice(simdCount, remainder));
-            }
-        }
-
-        /// <inheritdoc/>
-        public sealed override void ConvertToRgbInPlace(in ComponentValues values)
-        {
-            DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
-
-            int length = values.Component0.Length;
-            int remainder = (int)((uint)length % (uint)Vector512<float>.Count);
-
-            int simdCount = length - remainder;
-            if (simdCount > 0)
-            {
-                this.ConvertToRgbInPlaceVectorized(values.Slice(0, simdCount));
-            }
-
-            if (remainder > 0)
-            {
-                this.ConvertToRgbInPlaceScalarRemainder(values.Slice(simdCount, remainder));
-            }
-        }
-
-        /// <summary>
-        /// Converts planar jpeg component values in <paramref name="values"/>
-        /// to RGB color space in place using <see cref="Vector"/> API.
-        /// </summary>
-        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInPlaceVectorized(in ComponentValues values);
-
-        /// <summary>
-        /// Converts remainder of the planar jpeg component values after
-        /// conversion in <see cref="ConvertToRgbInPlaceVectorized(in ComponentValues)"/>.
-        /// </summary>
-        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values);
-
-        /// <summary>
-        /// Converts RGB lanes to jpeg component values using <see cref="Vector"/> API.
-        /// </summary>
-        /// <param name="values">Jpeg component values.</param>
-        /// <param name="rLane">Red colors lane.</param>
-        /// <param name="gLane">Green colors lane.</param>
-        /// <param name="bLane">Blue colors lane.</param>
-        protected abstract void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
-
-        /// <summary>
-        /// Converts remainder of RGB lanes to jpeg component values after
-        ///  conversion in <see cref="ConvertFromRgbVectorized(in ComponentValues, Span{float}, Span{float}, Span{float})"/>.
-        /// </summary>
-        /// <param name="values">Jpeg component values.</param>
-        /// <param name="rLane">Red colors lane.</param>
-        /// <param name="gLane">Green colors lane.</param>
-        /// <param name="bLane">Blue colors lane.</param>
-        protected abstract void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Encoder/ComponentProcessor.cs

@@ -5,8 +5,8 @@ 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;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder;
@@ -116,52 +116,9 @@ internal class ComponentProcessor : IDisposable
         }
 
         static void SumVertical(Span<float> target, Span<float> source)
-        {
-            if (Avx.IsSupported)
-            {
-                ref Vector256<float> targetVectorRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(target));
-                ref Vector256<float> sourceVectorRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-
-                // Spans are guaranteed to be multiple of 8 so no extra 'remainder' steps are needed
-                DebugGuard.IsTrue(source.Length % 8 == 0, "source must be multiple of 8");
-                nuint count = source.Vector256Count<float>();
-                for (nuint i = 0; i < count; i++)
-                {
-                    Unsafe.Add(ref targetVectorRef, i) = Avx.Add(Unsafe.Add(ref targetVectorRef, i), Unsafe.Add(ref sourceVectorRef, i));
-                }
-            }
-            else if (AdvSimd.IsSupported)
-            {
-                ref Vector128<float> targetVectorRef = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(target));
-                ref Vector128<float> sourceVectorRef = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(source));
 
-                // Spans are guaranteed to be multiple of 8 so no extra 'remainder' steps are needed
+            // Exact destination overlap is supported, so each accumulated row remains in target.
-                DebugGuard.IsTrue(source.Length % 8 == 0, "source must be multiple of 8");
+            => TensorPrimitives_.Add(target, source, target);
-                nuint count = source.Vector128Count<float>();
-                for (nuint i = 0; i < count; i++)
-                {
-                    Unsafe.Add(ref targetVectorRef, i) = AdvSimd.Add(Unsafe.Add(ref targetVectorRef, i), Unsafe.Add(ref sourceVectorRef, i));
-                }
-            }
-            else
-            {
-                ref Vector<float> targetVectorRef = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(target));
-                ref Vector<float> sourceVectorRef = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(source));
-
-                nuint count = source.VectorCount<float>();
-                for (nuint i = 0; i < count; i++)
-                {
-                    Unsafe.Add(ref targetVectorRef, i) += Unsafe.Add(ref sourceVectorRef, i);
-                }
-
-                ref float targetRef = ref MemoryMarshal.GetReference(target);
-                ref float sourceRef = ref MemoryMarshal.GetReference(source);
-                for (nuint i = count * (uint)Vector<float>.Count; i < (uint)source.Length; i++)
-                {
-                    Unsafe.Add(ref targetRef, i) += Unsafe.Add(ref sourceRef, i);
-                }
-            }
-        }
 
         static void SumHorizontal(Span<float> target, int factor)
         {
@@ -209,50 +166,8 @@ internal class ComponentProcessor : IDisposable
         }
 
         static void MultiplyToAverage(Span<float> target, float multiplier)
-        {
-            if (Avx.IsSupported)
-            {
-                ref Vector256<float> targetVectorRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(target));
-
-                // Spans are guaranteed to be multiple of 8 so no extra 'remainder' steps are needed
-                DebugGuard.IsTrue(target.Length % 8 == 0, "target must be multiple of 8");
-                nuint count = target.Vector256Count<float>();
-                Vector256<float> multiplierVector = Vector256.Create(multiplier);
-                for (nuint i = 0; i < count; i++)
-                {
-                    Unsafe.Add(ref targetVectorRef, i) = Avx.Multiply(Unsafe.Add(ref targetVectorRef, i), multiplierVector);
-                }
-            }
-            else if (AdvSimd.IsSupported)
-            {
-                ref Vector128<float> targetVectorRef = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(target));
 
-                // Spans are guaranteed to be multiple of 8 so no extra 'remainder' steps are needed
+            // Apply the subsampling reciprocal in place after all contributing rows have been summed.
-                DebugGuard.IsTrue(target.Length % 8 == 0, "target must be multiple of 8");
+            => TensorPrimitives_.Multiply(target, multiplier, target);
-                nuint count = target.Vector128Count<float>();
-                Vector128<float> multiplierVector = Vector128.Create(multiplier);
-                for (nuint i = 0; i < count; i++)
-                {
-                    Unsafe.Add(ref targetVectorRef, i) = AdvSimd.Multiply(Unsafe.Add(ref targetVectorRef, i), multiplierVector);
-                }
-            }
-            else
-            {
-                ref Vector<float> targetVectorRef = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(target));
-
-                nuint count = target.VectorCount<float>();
-                Vector<float> multiplierVector = new(multiplier);
-                for (nuint i = 0; i < count; i++)
-                {
-                    Unsafe.Add(ref targetVectorRef, i) *= multiplierVector;
-                }
-
-                ref float targetRef = ref MemoryMarshal.GetReference(target);
-                for (nuint i = count * (uint)Vector<float>.Count; i < (uint)target.Length; i++)
-                {
-                    Unsafe.Add(ref targetRef, i) *= multiplier;
-                }
-            }
-        }
     }
 }

src/ImageSharp/Formats/Png/Filters/AverageFilter.cs

@@ -140,98 +140,7 @@ internal static class AverageFilter
     /// <param name="sum">The sum of the total variance of the filtered row.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Encode(ReadOnlySpan<byte> scanline, ReadOnlySpan<byte> previousScanline, Span<byte> result, uint bytesPerPixel, out int sum)
-    {
+        => PngFilterEncoder.Encode<AverageFilterOperator>(scanline, previousScanline, result, bytesPerPixel, out sum);
-        DebugGuard.MustBeSameSized(scanline, previousScanline, nameof(scanline));
-        DebugGuard.MustBeSizedAtLeast(result, scanline, nameof(result));
-
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte prevBaseRef = ref MemoryMarshal.GetReference(previousScanline);
-        ref byte resultBaseRef = ref MemoryMarshal.GetReference(result);
-        sum = 0;
-
-        // Average(x) = Raw(x) - floor((Raw(x-bpp)+Prior(x))/2)
-        resultBaseRef = (byte)FilterType.Average;
-
-        nuint x = 0;
-        for (; x < bytesPerPixel; /* Note: ++x happens in the body to avoid one add operation */)
-        {
-            byte scan = Unsafe.Add(ref scanBaseRef, x);
-            byte above = Unsafe.Add(ref prevBaseRef, x);
-            ++x;
-            ref byte res = ref Unsafe.Add(ref resultBaseRef, x);
-            res = (byte)(scan - (above >> 1));
-            sum += Numerics.Abs(unchecked((sbyte)res));
-        }
-
-        if (Avx2.IsSupported)
-        {
-            Vector256<byte> zero = Vector256<byte>.Zero;
-            Vector256<int> sumAccumulator = Vector256<int>.Zero;
-            Vector256<byte> allBitsSet = Avx2.CompareEqual(sumAccumulator, sumAccumulator).AsByte();
-
-            for (nuint xLeft = x - bytesPerPixel; (int)x <= scanline.Length - Vector256<byte>.Count; xLeft += (uint)Vector256<byte>.Count)
-            {
-                Vector256<byte> scan = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector256<byte> left = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft));
-                Vector256<byte> above = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref prevBaseRef, x));
-
-                Vector256<byte> avg = Avx2.Xor(Avx2.Average(Avx2.Xor(left, allBitsSet), Avx2.Xor(above, allBitsSet)), allBitsSet);
-                Vector256<byte> res = Avx2.Subtract(scan, avg);
-
-                Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector256<byte>.Count;
-
-                sumAccumulator = Avx2.Add(sumAccumulator, Avx2.SumAbsoluteDifferences(Avx2.Abs(res.AsSByte()), zero).AsInt32());
-            }
-
-            sum += Numerics.EvenReduceSum(sumAccumulator);
-        }
-        else if (Sse2.IsSupported)
-        {
-            Vector128<byte> zero = Vector128<byte>.Zero;
-            Vector128<int> sumAccumulator = Vector128<int>.Zero;
-            Vector128<byte> allBitsSet = Sse2.CompareEqual(sumAccumulator, sumAccumulator).AsByte();
-
-            for (nuint xLeft = x - bytesPerPixel; (int)x <= scanline.Length - Vector128<byte>.Count; xLeft += (uint)Vector128<byte>.Count)
-            {
-                Vector128<byte> scan = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector128<byte> left = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft));
-                Vector128<byte> above = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref prevBaseRef, x));
-
-                Vector128<byte> avg = Sse2.Xor(Sse2.Average(Sse2.Xor(left, allBitsSet), Sse2.Xor(above, allBitsSet)), allBitsSet);
-                Vector128<byte> res = Sse2.Subtract(scan, avg);
-
-                Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector128<byte>.Count;
-
-                Vector128<byte> absRes;
-                if (Ssse3.IsSupported)
-                {
-                    absRes = Ssse3.Abs(res.AsSByte());
-                }
-                else
-                {
-                    Vector128<sbyte> mask = Sse2.CompareGreaterThan(zero.AsSByte(), res.AsSByte());
-                    absRes = Sse2.Xor(Sse2.Add(res.AsSByte(), mask), mask).AsByte();
-                }
-
-                sumAccumulator = Sse2.Add(sumAccumulator, Sse2.SumAbsoluteDifferences(absRes, zero).AsInt32());
-            }
-
-            sum += Numerics.EvenReduceSum(sumAccumulator);
-        }
-
-        for (nuint xLeft = x - bytesPerPixel; x < (uint)scanline.Length; ++xLeft /* Note: ++x happens in the body to avoid one add operation */)
-        {
-            byte scan = Unsafe.Add(ref scanBaseRef, x);
-            byte left = Unsafe.Add(ref scanBaseRef, xLeft);
-            byte above = Unsafe.Add(ref prevBaseRef, x);
-            ++x;
-            ref byte res = ref Unsafe.Add(ref resultBaseRef, x);
-            res = (byte)(scan - Average(left, above));
-            sum += Numerics.Abs(unchecked((sbyte)res));
-        }
-    }
 
     /// <summary>
     /// Calculates the average value of two bytes

src/ImageSharp/Formats/Png/Filters/IPngFilterOperator.cs

@@ -0,0 +1,424 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Png.Filters;
+
+/// <summary>
+/// Defines the scalar and SIMD mappings used by the shared PNG filter traversal.
+/// </summary>
+internal interface IPngFilterOperator
+{
+    /// <summary>
+    /// Gets the filter type written to the leading result byte.
+    /// </summary>
+    public static abstract FilterType Type { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the predictor reads the left component.
+    /// </summary>
+    public static abstract bool UsesLeft { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the predictor reads the above component.
+    /// </summary>
+    public static abstract bool UsesAbove { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the predictor reads the upper-left component.
+    /// </summary>
+    public static abstract bool UsesUpperLeft { get; }
+
+    /// <summary>
+    /// Filters one byte from its PNG neighborhood.
+    /// </summary>
+    /// <param name="scan">The component being filtered.</param>
+    /// <param name="left">The corresponding component in the preceding pixel.</param>
+    /// <param name="above">The corresponding component in the preceding scanline.</param>
+    /// <param name="upperLeft">The preceding component in the preceding scanline.</param>
+    /// <returns>The filtered residual.</returns>
+    public static abstract byte Invoke(byte scan, byte left, byte above, byte upperLeft);
+
+    /// <summary>
+    /// Filters sixteen byte lanes from their PNG neighborhoods.
+    /// </summary>
+    /// <param name="scan">The components being filtered.</param>
+    /// <param name="left">The corresponding components in the preceding pixels.</param>
+    /// <param name="above">The corresponding components in the preceding scanline.</param>
+    /// <param name="upperLeft">The preceding components in the preceding scanline.</param>
+    /// <returns>The filtered residuals.</returns>
+    public static abstract Vector128<byte> Invoke(Vector128<byte> scan, Vector128<byte> left, Vector128<byte> above, Vector128<byte> upperLeft);
+
+    /// <summary>
+    /// Filters thirty-two byte lanes from their PNG neighborhoods.
+    /// </summary>
+    /// <param name="scan">The components being filtered.</param>
+    /// <param name="left">The corresponding components in the preceding pixels.</param>
+    /// <param name="above">The corresponding components in the preceding scanline.</param>
+    /// <param name="upperLeft">The preceding components in the preceding scanline.</param>
+    /// <returns>The filtered residuals.</returns>
+    public static abstract Vector256<byte> Invoke(Vector256<byte> scan, Vector256<byte> left, Vector256<byte> above, Vector256<byte> upperLeft);
+
+    /// <summary>
+    /// Filters sixty-four byte lanes from their PNG neighborhoods.
+    /// </summary>
+    /// <param name="scan">The components being filtered.</param>
+    /// <param name="left">The corresponding components in the preceding pixels.</param>
+    /// <param name="above">The corresponding components in the preceding scanline.</param>
+    /// <param name="upperLeft">The preceding components in the preceding scanline.</param>
+    /// <returns>The filtered residuals.</returns>
+    public static abstract Vector512<byte> Invoke(Vector512<byte> scan, Vector512<byte> left, Vector512<byte> above, Vector512<byte> upperLeft);
+}
+
+/// <summary>
+/// Maps each component to its difference from the corresponding component in the preceding pixel.
+/// </summary>
+internal readonly struct SubFilterOperator : IPngFilterOperator
+{
+    /// <inheritdoc />
+    public static FilterType Type => FilterType.Sub;
+
+    /// <inheritdoc />
+    public static bool UsesLeft => true;
+
+    /// <inheritdoc />
+    public static bool UsesAbove => false;
+
+    /// <inheritdoc />
+    public static bool UsesUpperLeft => false;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static byte Invoke(byte scan, byte left, byte above, byte upperLeft) => (byte)(scan - left);
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector128<byte> Invoke(Vector128<byte> scan, Vector128<byte> left, Vector128<byte> above, Vector128<byte> upperLeft)
+        => scan - left;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector256<byte> Invoke(Vector256<byte> scan, Vector256<byte> left, Vector256<byte> above, Vector256<byte> upperLeft)
+        => scan - left;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector512<byte> Invoke(Vector512<byte> scan, Vector512<byte> left, Vector512<byte> above, Vector512<byte> upperLeft)
+        => scan - left;
+}
+
+/// <summary>
+/// Maps each component to its difference from the component directly above it.
+/// </summary>
+internal readonly struct UpFilterOperator : IPngFilterOperator
+{
+    /// <inheritdoc />
+    public static FilterType Type => FilterType.Up;
+
+    /// <inheritdoc />
+    public static bool UsesLeft => false;
+
+    /// <inheritdoc />
+    public static bool UsesAbove => true;
+
+    /// <inheritdoc />
+    public static bool UsesUpperLeft => false;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static byte Invoke(byte scan, byte left, byte above, byte upperLeft) => (byte)(scan - above);
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector128<byte> Invoke(Vector128<byte> scan, Vector128<byte> left, Vector128<byte> above, Vector128<byte> upperLeft)
+        => scan - above;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector256<byte> Invoke(Vector256<byte> scan, Vector256<byte> left, Vector256<byte> above, Vector256<byte> upperLeft)
+        => scan - above;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector512<byte> Invoke(Vector512<byte> scan, Vector512<byte> left, Vector512<byte> above, Vector512<byte> upperLeft)
+        => scan - above;
+}
+
+/// <summary>
+/// Maps each component to its difference from the truncated average of its left and above neighbors.
+/// </summary>
+internal readonly struct AverageFilterOperator : IPngFilterOperator
+{
+    /// <inheritdoc />
+    public static FilterType Type => FilterType.Average;
+
+    /// <inheritdoc />
+    public static bool UsesLeft => true;
+
+    /// <inheritdoc />
+    public static bool UsesAbove => true;
+
+    /// <inheritdoc />
+    public static bool UsesUpperLeft => false;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static byte Invoke(byte scan, byte left, byte above, byte upperLeft)
+        => (byte)(scan - ((left + above) >> 1));
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector128<byte> Invoke(Vector128<byte> scan, Vector128<byte> left, Vector128<byte> above, Vector128<byte> upperLeft)
+    {
+        Vector128<byte> average;
+
+        if (Sse2.IsSupported)
+        {
+            // PAVG rounds upward. Complementing both inputs and the result converts
+            // that rounding into the floor((left + above) / 2) required by PNG.
+            average = ~Sse2.Average(~left, ~above);
+        }
+        else if (AdvSimd.IsSupported)
+        {
+            // ARM's halving add truncates directly and therefore needs no correction.
+            average = AdvSimd.FusedAddHalving(left, above);
+        }
+        else
+        {
+            // Portable 128-bit backends use the carry-free average identity. Shared
+            // bits supply the integer part while differing bits supply half the remainder.
+            average = (left & above) + Vector128.ShiftRightLogical(left ^ above, 1);
+        }
+
+        return scan - average;
+    }
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector256<byte> Invoke(Vector256<byte> scan, Vector256<byte> left, Vector256<byte> above, Vector256<byte> upperLeft)
+
+        // VPAVGB rounds (left + above) / 2 upward. Complementing both inputs and
+        // the result changes that to the truncated average required by PNG.
+        => scan - ~Avx2.Average(~left, ~above);
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector512<byte> Invoke(Vector512<byte> scan, Vector512<byte> left, Vector512<byte> above, Vector512<byte> upperLeft)
+
+        // AVX-512BW retains VPAVGB's upward rounding, so use the same complement
+        // identity as AVX2 to obtain floor((left + above) / 2) in every byte lane.
+        => scan - ~Avx512BW.Average(~left, ~above);
+}
+
+/// <summary>
+/// Maps each component to its difference from the nearest Paeth neighbor.
+/// </summary>
+internal readonly struct PaethFilterOperator : IPngFilterOperator
+{
+    /// <inheritdoc />
+    public static FilterType Type => FilterType.Paeth;
+
+    /// <inheritdoc />
+    public static bool UsesLeft => true;
+
+    /// <inheritdoc />
+    public static bool UsesAbove => true;
+
+    /// <inheritdoc />
+    public static bool UsesUpperLeft => true;
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static byte Invoke(byte scan, byte left, byte above, byte upperLeft)
+    {
+        int p = left + above - upperLeft;
+        int distanceLeft = Numerics.Abs(p - left);
+        int distanceAbove = Numerics.Abs(p - above);
+        int distanceUpperLeft = Numerics.Abs(p - upperLeft);
+
+        // PNG resolves equal distances in left, above, upper-left order.
+        byte predictor = distanceLeft <= distanceAbove && distanceLeft <= distanceUpperLeft ? left : distanceAbove <= distanceUpperLeft ? above : upperLeft;
+
+        return (byte)(scan - predictor);
+    }
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector128<byte> Invoke(Vector128<byte> scan, Vector128<byte> left, Vector128<byte> above, Vector128<byte> upperLeft)
+    {
+        Vector128<byte> predictor = Predict(left, above, upperLeft);
+        return scan - predictor;
+    }
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector256<byte> Invoke(Vector256<byte> scan, Vector256<byte> left, Vector256<byte> above, Vector256<byte> upperLeft)
+    {
+        Vector256<byte> predictor = Predict(left, above, upperLeft);
+        return scan - predictor;
+    }
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static Vector512<byte> Invoke(Vector512<byte> scan, Vector512<byte> left, Vector512<byte> above, Vector512<byte> upperLeft)
+    {
+        Vector512<byte> predictor = Predict(left, above, upperLeft);
+        return scan - predictor;
+    }
+
+    /// <summary>
+    /// Selects the nearest Paeth neighbor for sixteen independent byte lanes.
+    /// </summary>
+    /// <param name="left">The reconstructed component immediately before each current component.</param>
+    /// <param name="above">The reconstructed component immediately above each current component.</param>
+    /// <param name="upperLeft">The reconstructed component diagonally above and before each current component.</param>
+    /// <returns>The selected Paeth predictor for each byte lane.</returns>
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static Vector128<byte> Predict(Vector128<byte> left, Vector128<byte> above, Vector128<byte> upperLeft)
+    {
+        // For p = left + above - upperLeft, the Paeth distances simplify to:
+        //   distanceLeft  = |above - upperLeft|
+        //   distanceAbove = |left - upperLeft|
+        // Computing both unsigned subtraction directions and OR-ing them obtains
+        // each absolute difference without widening the byte lanes.
+        Vector128<byte> aboveMinusUpper = Vector128_.SubtractSaturate(above, upperLeft);
+        Vector128<byte> leftMinusUpper = Vector128_.SubtractSaturate(left, upperLeft);
+        Vector128<byte> distanceLeft = Vector128_.SubtractSaturate(upperLeft, above) | aboveMinusUpper;
+        Vector128<byte> distanceAbove = Vector128_.SubtractSaturate(upperLeft, left) | leftMinusUpper;
+
+        return SelectPredictor(left, above, upperLeft, aboveMinusUpper, leftMinusUpper, distanceLeft, distanceAbove);
+    }
+
+    /// <summary>
+    /// Selects the nearest Paeth neighbor for thirty-two independent byte lanes.
+    /// </summary>
+    /// <param name="left">The reconstructed component immediately before each current component.</param>
+    /// <param name="above">The reconstructed component immediately above each current component.</param>
+    /// <param name="upperLeft">The reconstructed component diagonally above and before each current component.</param>
+    /// <returns>The selected Paeth predictor for each byte lane.</returns>
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static Vector256<byte> Predict(Vector256<byte> left, Vector256<byte> above, Vector256<byte> upperLeft)
+    {
+        // Apply the same Paeth identities as the 128-bit path to thirty-two lanes.
+        // Saturating subtraction in both directions forms the absolute differences
+        // without widening, preserving one predictor result per source byte.
+        Vector256<byte> aboveMinusUpper = Vector256_.SubtractSaturate(above, upperLeft);
+        Vector256<byte> leftMinusUpper = Vector256_.SubtractSaturate(left, upperLeft);
+        Vector256<byte> distanceLeft = Vector256_.SubtractSaturate(upperLeft, above) | aboveMinusUpper;
+        Vector256<byte> distanceAbove = Vector256_.SubtractSaturate(upperLeft, left) | leftMinusUpper;
+
+        return SelectPredictor(left, above, upperLeft, aboveMinusUpper, leftMinusUpper, distanceLeft, distanceAbove);
+    }
+
+    /// <summary>
+    /// Selects the nearest Paeth neighbor for sixty-four independent byte lanes.
+    /// </summary>
+    /// <param name="left">The reconstructed component immediately before each current component.</param>
+    /// <param name="above">The reconstructed component immediately above each current component.</param>
+    /// <param name="upperLeft">The reconstructed component diagonally above and before each current component.</param>
+    /// <returns>The selected Paeth predictor for each byte lane.</returns>
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static Vector512<byte> Predict(Vector512<byte> left, Vector512<byte> above, Vector512<byte> upperLeft)
+    {
+        // Apply the same byte-lane Paeth identities to sixty-four AVX-512BW lanes.
+        // No cross-lane operation is required because every component has its own
+        // left, above, and upper-left inputs at the matching vector index.
+        Vector512<byte> aboveMinusUpper = Vector512_.SubtractSaturate(above, upperLeft);
+        Vector512<byte> leftMinusUpper = Vector512_.SubtractSaturate(left, upperLeft);
+        Vector512<byte> distanceLeft = Vector512_.SubtractSaturate(upperLeft, above) | aboveMinusUpper;
+        Vector512<byte> distanceAbove = Vector512_.SubtractSaturate(upperLeft, left) | leftMinusUpper;
+
+        return SelectPredictor(left, above, upperLeft, aboveMinusUpper, leftMinusUpper, distanceLeft, distanceAbove);
+    }
+
+    /// <summary>
+    /// Applies Paeth distance and tie-breaking rules to sixteen lanes.
+    /// </summary>
+    /// <param name="left">The left-neighbor candidates.</param>
+    /// <param name="above">The above-neighbor candidates.</param>
+    /// <param name="upperLeft">The upper-left-neighbor candidates.</param>
+    /// <param name="aboveMinusUpper">The saturated differences from above to upper-left.</param>
+    /// <param name="leftMinusUpper">The saturated differences from left to upper-left.</param>
+    /// <param name="distanceLeft">The Paeth distances for the left candidates.</param>
+    /// <param name="distanceAbove">The Paeth distances for the above candidates.</param>
+    /// <returns>The selected Paeth predictor for each byte lane.</returns>
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static Vector128<byte> SelectPredictor(Vector128<byte> left, Vector128<byte> above, Vector128<byte> upperLeft, Vector128<byte> aboveMinusUpper, Vector128<byte> leftMinusUpper, Vector128<byte> distanceLeft, Vector128<byte> distanceAbove)
+    {
+        Vector128<byte> sameDirection = Vector128.Equals(Vector128.Equals(aboveMinusUpper, Vector128<byte>.Zero), Vector128.Equals(leftMinusUpper, Vector128<byte>.Zero));
+
+        // If left and above lie on the same side of upper-left, distanceUpper is
+        // their summed distance and cannot beat either neighbor; the all-bits mask
+        // excludes upper-left. On opposite sides, that distance is the absolute
+        // difference between distanceLeft and distanceAbove.
+        Vector128<byte> distanceUpper = sameDirection | Vector128_.SubtractSaturate(distanceAbove, distanceLeft) | Vector128_.SubtractSaturate(distanceLeft, distanceAbove);
+
+        // Equality selects above before upper-left, implementing PNG's second tie rule.
+        Vector128<byte> minimumAboveUpper = Vector128.Min(distanceUpper, distanceAbove);
+        Vector128<byte> aboveOrUpper = Vector128.ConditionalSelect(Vector128.Equals(minimumAboveUpper, distanceAbove), above, upperLeft);
+
+        // Applying the left comparison last preserves PNG's left-first tie rule.
+        return Vector128.ConditionalSelect(Vector128.Equals(Vector128.Min(minimumAboveUpper, distanceLeft), distanceLeft), left, aboveOrUpper);
+    }
+
+    /// <summary>
+    /// Applies Paeth distance and tie-breaking rules to thirty-two lanes.
+    /// </summary>
+    /// <param name="left">The left-neighbor candidates.</param>
+    /// <param name="above">The above-neighbor candidates.</param>
+    /// <param name="upperLeft">The upper-left-neighbor candidates.</param>
+    /// <param name="aboveMinusUpper">The saturated differences from above to upper-left.</param>
+    /// <param name="leftMinusUpper">The saturated differences from left to upper-left.</param>
+    /// <param name="distanceLeft">The Paeth distances for the left candidates.</param>
+    /// <param name="distanceAbove">The Paeth distances for the above candidates.</param>
+    /// <returns>The selected Paeth predictor for each byte lane.</returns>
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static Vector256<byte> SelectPredictor(Vector256<byte> left, Vector256<byte> above, Vector256<byte> upperLeft, Vector256<byte> aboveMinusUpper, Vector256<byte> leftMinusUpper, Vector256<byte> distanceLeft, Vector256<byte> distanceAbove)
+    {
+        Vector256<byte> sameDirection = Vector256.Equals(Vector256.Equals(aboveMinusUpper, Vector256<byte>.Zero), Vector256.Equals(leftMinusUpper, Vector256<byte>.Zero));
+
+        // Exclude upper-left when its distance is the non-minimal sum; otherwise
+        // compute its distance as the absolute difference of the two known distances.
+        Vector256<byte> distanceUpper = sameDirection | Vector256_.SubtractSaturate(distanceAbove, distanceLeft) | Vector256_.SubtractSaturate(distanceLeft, distanceAbove);
+
+        // Select above on equality, then select left on equality to preserve PNG's
+        // required left, above, upper-left tie order in every byte lane.
+        Vector256<byte> minimumAboveUpper = Vector256.Min(distanceUpper, distanceAbove);
+        Vector256<byte> aboveOrUpper = Vector256.ConditionalSelect(Vector256.Equals(minimumAboveUpper, distanceAbove), above, upperLeft);
+
+        return Vector256.ConditionalSelect(Vector256.Equals(Vector256.Min(minimumAboveUpper, distanceLeft), distanceLeft), left, aboveOrUpper);
+    }
+
+    /// <summary>
+    /// Applies Paeth distance and tie-breaking rules to sixty-four lanes.
+    /// </summary>
+    /// <param name="left">The left-neighbor candidates.</param>
+    /// <param name="above">The above-neighbor candidates.</param>
+    /// <param name="upperLeft">The upper-left-neighbor candidates.</param>
+    /// <param name="aboveMinusUpper">The saturated differences from above to upper-left.</param>
+    /// <param name="leftMinusUpper">The saturated differences from left to upper-left.</param>
+    /// <param name="distanceLeft">The Paeth distances for the left candidates.</param>
+    /// <param name="distanceAbove">The Paeth distances for the above candidates.</param>
+    /// <returns>The selected Paeth predictor for each byte lane.</returns>
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static Vector512<byte> SelectPredictor(Vector512<byte> left, Vector512<byte> above, Vector512<byte> upperLeft, Vector512<byte> aboveMinusUpper, Vector512<byte> leftMinusUpper, Vector512<byte> distanceLeft, Vector512<byte> distanceAbove)
+    {
+        Vector512<byte> sameDirection = Vector512.Equals(Vector512.Equals(aboveMinusUpper, Vector512<byte>.Zero), Vector512.Equals(leftMinusUpper, Vector512<byte>.Zero));
+
+        // Exclude upper-left when its distance is the non-minimal sum; otherwise
+        // compute its distance as the absolute difference of the two known distances.
+        Vector512<byte> distanceUpper = sameDirection | Vector512_.SubtractSaturate(distanceAbove, distanceLeft) | Vector512_.SubtractSaturate(distanceLeft, distanceAbove);
+
+        // Select above on equality, then select left on equality to preserve PNG's
+        // required left, above, upper-left tie order in every byte lane.
+        Vector512<byte> minimumAboveUpper = Vector512.Min(distanceUpper, distanceAbove);
+        Vector512<byte> aboveOrUpper = Vector512.ConditionalSelect(Vector512.Equals(minimumAboveUpper, distanceAbove), above, upperLeft);
+
+        return Vector512.ConditionalSelect(Vector512.Equals(Vector512.Min(minimumAboveUpper, distanceLeft), distanceLeft), left, aboveOrUpper);
+    }
+}

src/ImageSharp/Formats/Png/Filters/PaethFilter.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -193,86 +192,7 @@ internal static class PaethFilter
     /// <param name="sum">The sum of the total variance of the filtered row.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Encode(ReadOnlySpan<byte> scanline, ReadOnlySpan<byte> previousScanline, Span<byte> result, int bytesPerPixel, out int sum)
-    {
+        => PngFilterEncoder.Encode<PaethFilterOperator>(scanline, previousScanline, result, (uint)bytesPerPixel, out sum);
-        DebugGuard.MustBeSameSized(scanline, previousScanline, nameof(scanline));
-        DebugGuard.MustBeSizedAtLeast(result, scanline, nameof(result));
-
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte prevBaseRef = ref MemoryMarshal.GetReference(previousScanline);
-        ref byte resultBaseRef = ref MemoryMarshal.GetReference(result);
-        sum = 0;
-
-        // Paeth(x) = Raw(x) - PaethPredictor(Raw(x-bpp), Prior(x), Prior(x - bpp))
-        resultBaseRef = (byte)FilterType.Paeth;
-
-        nuint x = 0;
-        for (; x < (uint)bytesPerPixel; /* Note: ++x happens in the body to avoid one add operation */)
-        {
-            byte scan = Unsafe.Add(ref scanBaseRef, x);
-            byte above = Unsafe.Add(ref prevBaseRef, x);
-            ++x;
-            ref byte res = ref Unsafe.Add(ref resultBaseRef, x);
-            res = (byte)(scan - PaethPredictor(0, above, 0));
-            sum += Numerics.Abs(unchecked((sbyte)res));
-        }
-
-        if (Avx2.IsSupported)
-        {
-            Vector256<byte> zero = Vector256<byte>.Zero;
-            Vector256<int> sumAccumulator = Vector256<int>.Zero;
-
-            for (nuint xLeft = x - (uint)bytesPerPixel; (int)x <= scanline.Length - Vector256<byte>.Count; xLeft += (uint)Vector256<byte>.Count)
-            {
-                Vector256<byte> scan = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector256<byte> left = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft));
-                Vector256<byte> above = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref prevBaseRef, x));
-                Vector256<byte> upperLeft = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref prevBaseRef, xLeft));
-
-                Vector256<byte> res = Avx2.Subtract(scan, PaethPredictor(left, above, upperLeft));
-                Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector256<byte>.Count;
-
-                sumAccumulator = Avx2.Add(sumAccumulator, Avx2.SumAbsoluteDifferences(Avx2.Abs(res.AsSByte()), zero).AsInt32());
-            }
-
-            sum += Numerics.EvenReduceSum(sumAccumulator);
-        }
-        else if (Vector.IsHardwareAccelerated)
-        {
-            Vector<uint> sumAccumulator = Vector<uint>.Zero;
-
-            for (nuint xLeft = x - (uint)bytesPerPixel; (int)x <= scanline.Length - Vector<byte>.Count; xLeft += (uint)Vector<byte>.Count)
-            {
-                Vector<byte> scan = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector<byte> left = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft));
-                Vector<byte> above = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref prevBaseRef, x));
-                Vector<byte> upperLeft = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref prevBaseRef, xLeft));
-
-                Vector<byte> res = scan - PaethPredictor(left, above, upperLeft);
-                Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector<byte>.Count;
-
-                Numerics.Accumulate(ref sumAccumulator, Vector.AsVectorByte(Vector.Abs(Vector.AsVectorSByte(res))));
-            }
-
-            for (int i = 0; i < Vector<uint>.Count; i++)
-            {
-                sum += (int)sumAccumulator[i];
-            }
-        }
-
-        for (nuint xLeft = x - (uint)bytesPerPixel; (int)x < scanline.Length; ++xLeft /* Note: ++x happens in the body to avoid one add operation */)
-        {
-            byte scan = Unsafe.Add(ref scanBaseRef, x);
-            byte left = Unsafe.Add(ref scanBaseRef, xLeft);
-            byte above = Unsafe.Add(ref prevBaseRef, x);
-            byte upperLeft = Unsafe.Add(ref prevBaseRef, xLeft);
-            ++x;
-            ref byte res = ref Unsafe.Add(ref resultBaseRef, x);
-            res = (byte)(scan - PaethPredictor(left, above, upperLeft));
-            sum += Numerics.Abs(unchecked((sbyte)res));
-        }
-    }
 
     /// <summary>
     /// Computes a simple linear function of the three neighboring pixels (left, above, upper left), then chooses
@@ -304,70 +224,4 @@ internal static class PaethFilter
 
         return upperLeft;
     }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static Vector256<byte> PaethPredictor(Vector256<byte> left, Vector256<byte> above, Vector256<byte> upleft)
-    {
-        Vector256<byte> zero = Vector256<byte>.Zero;
-
-        // Here, we refactor pa = abs(p - left) = abs(left + above - upleft - left)
-        // to pa = abs(above - upleft).  Same deal for pb.
-        // Using saturated subtraction, if the result is negative, the output is zero.
-        // If we subtract in both directions and `or` the results, only one can be
-        // non-zero, so we end up with the absolute value.
-        Vector256<byte> sac = Avx2.SubtractSaturate(above, upleft);
-        Vector256<byte> sbc = Avx2.SubtractSaturate(left, upleft);
-        Vector256<byte> pa = Avx2.Or(Avx2.SubtractSaturate(upleft, above), sac);
-        Vector256<byte> pb = Avx2.Or(Avx2.SubtractSaturate(upleft, left), sbc);
-
-        // pc = abs(left + above - upleft - upleft), or abs(left - upleft + above - upleft).
-        // We've already calculated left - upleft and above - upleft in `sac` and `sbc`.
-        // If they are both negative or both positive, the absolute value of their
-        // sum can't possibly be less than `pa` or `pb`, so we'll never use the value.
-        // We make a mask that sets the value to 255 if they either both got
-        // saturated to zero or both didn't.  Then we calculate the absolute value
-        // of their difference using saturated subtract and `or`, same as before,
-        // keeping the value only where the mask isn't set.
-        Vector256<byte> pm = Avx2.CompareEqual(Avx2.CompareEqual(sac, zero), Avx2.CompareEqual(sbc, zero));
-        Vector256<byte> pc = Avx2.Or(pm, Avx2.Or(Avx2.SubtractSaturate(pb, pa), Avx2.SubtractSaturate(pa, pb)));
-
-        // Finally, blend the values together.  We start with `upleft` and overwrite on
-        // tied values so that the `left`, `above`, `upleft` precedence is preserved.
-        Vector256<byte> minbc = Avx2.Min(pc, pb);
-        Vector256<byte> resbc = Avx2.BlendVariable(upleft, above, Avx2.CompareEqual(minbc, pb));
-        return Avx2.BlendVariable(resbc, left, Avx2.CompareEqual(Avx2.Min(minbc, pa), pa));
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static Vector<byte> PaethPredictor(Vector<byte> left, Vector<byte> above, Vector<byte> upperLeft)
-    {
-        Vector.Widen(left, out Vector<ushort> a1, out Vector<ushort> a2);
-        Vector.Widen(above, out Vector<ushort> b1, out Vector<ushort> b2);
-        Vector.Widen(upperLeft, out Vector<ushort> c1, out Vector<ushort> c2);
-
-        Vector<short> p1 = PaethPredictor(Vector.AsVectorInt16(a1), Vector.AsVectorInt16(b1), Vector.AsVectorInt16(c1));
-        Vector<short> p2 = PaethPredictor(Vector.AsVectorInt16(a2), Vector.AsVectorInt16(b2), Vector.AsVectorInt16(c2));
-        return Vector.AsVectorByte(Vector.Narrow(p1, p2));
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static Vector<short> PaethPredictor(Vector<short> left, Vector<short> above, Vector<short> upperLeft)
-    {
-        Vector<short> p = left + above - upperLeft;
-        Vector<short> pa = Vector.Abs(p - left);
-        Vector<short> pb = Vector.Abs(p - above);
-        Vector<short> pc = Vector.Abs(p - upperLeft);
-
-        Vector<short> pa_pb = Vector.LessThanOrEqual(pa, pb);
-        Vector<short> pa_pc = Vector.LessThanOrEqual(pa, pc);
-        Vector<short> pb_pc = Vector.LessThanOrEqual(pb, pc);
-
-        return Vector.ConditionalSelect(
-            condition: Vector.BitwiseAnd(pa_pb, pa_pc),
-            left: left,
-            right: Vector.ConditionalSelect(
-                condition: pb_pc,
-                left: above,
-                right: upperLeft));
-    }
 }

src/ImageSharp/Formats/Png/Filters/PngFilterEncoder.cs

@@ -0,0 +1,187 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Formats.Png.Filters;
+
+/// <summary>
+/// Applies PNG filter operators while accumulating the absolute signed residuals used for filter selection.
+/// </summary>
+internal static class PngFilterEncoder
+{
+    /// <summary>
+    /// Maps a scanline through a filter operator, writes the residuals, and reduces their total variance.
+    /// </summary>
+    /// <typeparam name="TOperator">The PNG predictor selected for this closed traversal.</typeparam>
+    /// <param name="scanline">The scanline to encode.</param>
+    /// <param name="previousScanline">The preceding scanline.</param>
+    /// <param name="result">The destination including its leading filter byte.</param>
+    /// <param name="bytesPerPixel">The distance to the corresponding component in the preceding pixel.</param>
+    /// <param name="sum">The sum of the absolute signed residuals.</param>
+    // Inlining closes every static interface call over TOperator. The JIT can then remove
+    // source loads ignored by simpler predictors and specialize the active register widths.
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    public static void Encode<TOperator>(ReadOnlySpan<byte> scanline, ReadOnlySpan<byte> previousScanline, Span<byte> result, uint bytesPerPixel, out int sum)
+        where TOperator : struct, IPngFilterOperator
+    {
+        DebugGuard.MustBeSameSized(scanline, previousScanline, nameof(scanline));
+        DebugGuard.MustBeSizedAtLeast(result, scanline, nameof(result));
+
+        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
+        ref byte previousBaseRef = ref MemoryMarshal.GetReference(previousScanline);
+        ref byte resultBaseRef = ref MemoryMarshal.GetReference(result);
+
+        resultBaseRef = (byte)TOperator.Type;
+        sum = 0;
+
+        nuint x = 0;
+
+        // Components in the first pixel have no left or upper-left neighbor. Supplying
+        // zeroes expresses the PNG boundary rule directly through the same predictor.
+        for (; x < bytesPerPixel; x++)
+        {
+            byte above = TOperator.UsesAbove ? Unsafe.Add(ref previousBaseRef, x) : (byte)0;
+
+            byte filtered = TOperator.Invoke(Unsafe.Add(ref scanBaseRef, x), 0, above, 0);
+
+            Unsafe.Add(ref resultBaseRef, x + 1) = filtered;
+            sum += Numerics.Abs(unchecked((sbyte)filtered));
+        }
+
+        Vector128<uint> sum128 = Vector128<uint>.Zero;
+
+        // A single 512-bit register does not amortize folding its SAD accumulator.
+        // Leave short rows to the narrower paths, which have lower fixed reduction cost.
+        if (Avx512BW.IsSupported && scanline.Length - (int)x >= Vector512<byte>.Count * 2)
+        {
+            Vector512<uint> sum512 = Vector512<uint>.Zero;
+            int oneRegisterFromEnd = scanline.Length - Vector512<byte>.Count;
+
+            for (nuint xLeft = x - bytesPerPixel; (int)x <= oneRegisterFromEnd; xLeft += (uint)Vector512<byte>.Count)
+            {
+                // Each byte lane represents one independently filtered component. The
+                // four input vectors retain the scan/left/above/upper-left PNG layout.
+                // Operator usage flags are constants after generic specialization, so
+                // unused predictors do not retain even fault-preserving probe loads.
+                Vector512<byte> left = TOperator.UsesLeft ? Unsafe.As<byte, Vector512<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft)) : default;
+                Vector512<byte> above = TOperator.UsesAbove ? Unsafe.As<byte, Vector512<byte>>(ref Unsafe.Add(ref previousBaseRef, x)) : default;
+                Vector512<byte> upperLeft = TOperator.UsesUpperLeft ? Unsafe.As<byte, Vector512<byte>>(ref Unsafe.Add(ref previousBaseRef, xLeft)) : default;
+
+                Vector512<byte> filtered = TOperator.Invoke(Unsafe.As<byte, Vector512<byte>>(ref Unsafe.Add(ref scanBaseRef, x)), left, above, upperLeft);
+
+                Unsafe.As<byte, Vector512<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = filtered;
+                x += (uint)Vector512<byte>.Count;
+
+                // Vector512.Abs lowers to VPABSB under the surrounding AVX-512BW guard.
+                // Reinterpreting the signed result preserves -128's 0x80 bit pattern as
+                // the unsigned magnitude 128 consumed by VPSADBW.
+                Vector512<byte> absolute = Vector512.Abs(filtered.AsSByte()).AsByte();
+                sum512 += Avx512BW.SumAbsoluteDifferences(absolute, Vector512<byte>.Zero).AsUInt32();
+            }
+
+            // Fold only widths that processed data. Short rows therefore avoid both
+            // wide accumulator initialization and an otherwise empty reduction.
+            Vector256<uint> folded512 = sum512.GetLower() + sum512.GetUpper();
+            sum128 += folded512.GetLower() + folded512.GetUpper();
+        }
+
+        if (Avx2.IsSupported)
+        {
+            Vector256<uint> sum256 = Vector256<uint>.Zero;
+            int oneRegisterFromEnd = scanline.Length - Vector256<byte>.Count;
+
+            for (nuint xLeft = x - bytesPerPixel; (int)x <= oneRegisterFromEnd; xLeft += (uint)Vector256<byte>.Count)
+            {
+                // Thirty-two byte lanes preserve the same scan/left/above/upper-left
+                // correspondence as the 512-bit path. Closed operator flags remove
+                // unused loads when the predictor does not consume that neighbor.
+                Vector256<byte> left = TOperator.UsesLeft ? Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft)) : default;
+                Vector256<byte> above = TOperator.UsesAbove ? Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref previousBaseRef, x)) : default;
+                Vector256<byte> upperLeft = TOperator.UsesUpperLeft ? Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref previousBaseRef, xLeft)) : default;
+
+                Vector256<byte> filtered = TOperator.Invoke(Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, x)), left, above, upperLeft);
+
+                Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = filtered;
+                x += (uint)Vector256<byte>.Count;
+
+                // Vector256.Abs lowers to VPABSB under the surrounding AVX2 guard.
+                // Reinterpreting the signed result preserves -128's 0x80 bit pattern as
+                // the unsigned magnitude 128 consumed by VPSADBW.
+                Vector256<byte> absolute = Vector256.Abs(filtered.AsSByte()).AsByte();
+                sum256 += Avx2.SumAbsoluteDifferences(absolute, Vector256<byte>.Zero).AsUInt32();
+            }
+
+            // Fold both 128-bit halves into the shared four-lane accumulator.
+            sum128 += sum256.GetLower() + sum256.GetUpper();
+        }
+
+        if (Vector128.IsHardwareAccelerated)
+        {
+            int oneRegisterFromEnd = scanline.Length - Vector128<byte>.Count;
+
+            for (nuint xLeft = x - bytesPerPixel; (int)x <= oneRegisterFromEnd; xLeft += (uint)Vector128<byte>.Count)
+            {
+                // The final vector width handles sixteen more components with the
+                // same lane-wise neighborhood layout before the scalar remainder.
+                Vector128<byte> left = TOperator.UsesLeft ? Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft)) : default;
+                Vector128<byte> above = TOperator.UsesAbove ? Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref previousBaseRef, x)) : default;
+                Vector128<byte> upperLeft = TOperator.UsesUpperLeft ? Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref previousBaseRef, xLeft)) : default;
+
+                Vector128<byte> filtered = TOperator.Invoke(Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref scanBaseRef, x)), left, above, upperLeft);
+
+                Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = filtered;
+                x += (uint)Vector128<byte>.Count;
+
+                // AccumulateAbsolute selects the available x86 or portable widening
+                // reduction while preserving the same unsigned 32-bit partial sums.
+                sum128 = AccumulateAbsolute(sum128, filtered);
+            }
+        }
+
+        // Reduce the four partial lanes before adding individually scored tail bytes.
+        sum += unchecked((int)Vector128.Sum(sum128));
+
+        for (nuint xLeft = x - bytesPerPixel; x < (uint)scanline.Length; xLeft++, x++)
+        {
+            byte left = TOperator.UsesLeft ? Unsafe.Add(ref scanBaseRef, xLeft) : (byte)0;
+            byte above = TOperator.UsesAbove ? Unsafe.Add(ref previousBaseRef, x) : (byte)0;
+            byte upperLeft = TOperator.UsesUpperLeft ? Unsafe.Add(ref previousBaseRef, xLeft) : (byte)0;
+
+            byte filtered = TOperator.Invoke(Unsafe.Add(ref scanBaseRef, x), left, above, upperLeft);
+
+            Unsafe.Add(ref resultBaseRef, x + 1) = filtered;
+            sum += Numerics.Abs(unchecked((sbyte)filtered));
+        }
+    }
+
+    /// <summary>
+    /// Accumulates the absolute signed values in a 128-bit residual vector.
+    /// </summary>
+    /// <param name="accumulator">The four-lane unsigned accumulator.</param>
+    /// <param name="residuals">The sixteen filtered byte residuals.</param>
+    /// <returns>The updated accumulator.</returns>
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static Vector128<uint> AccumulateAbsolute(Vector128<uint> accumulator, Vector128<byte> residuals)
+    {
+        // The generic absolute-value intrinsic selects PABSB where available and
+        // preserves -128's 0x80 bit pattern as the unsigned magnitude 128.
+        Vector128<byte> absolute = Vector128.Abs(residuals.AsSByte()).AsByte();
+
+        if (Sse2.IsSupported)
+        {
+            return accumulator + Sse2.SumAbsoluteDifferences(absolute, Vector128<byte>.Zero).AsUInt32();
+        }
+
+        (Vector128<ushort> lower16, Vector128<ushort> upper16) = Vector128.Widen(absolute);
+        (Vector128<uint> lower0, Vector128<uint> lower1) = Vector128.Widen(lower16);
+        (Vector128<uint> upper0, Vector128<uint> upper1) = Vector128.Widen(upper16);
+
+        // Four widening additions keep every byte contribution in a 32-bit lane,
+        // matching the x86 accumulator's overflow behavior without scalar reduction.
+        return accumulator + lower0 + lower1 + upper0 + upper1;
+    }
+}

src/ImageSharp/Formats/Png/Filters/SubFilter.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -103,84 +102,16 @@ internal static class SubFilter
     }
 
     /// <summary>
-    /// Encodes a scanline with the sup filter applied.
+    /// Encodes a scanline with the sub filter applied.
     /// </summary>
     /// <param name="scanline">The scanline to encode.</param>
     /// <param name="result">The filtered scanline result.</param>
     /// <param name="bytesPerPixel">The bytes per pixel.</param>
     /// <param name="sum">The sum of the total variance of the filtered row.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static void Encode(ReadOnlySpan<byte> scanline, ReadOnlySpan<byte> result, int bytesPerPixel, out int sum)
+    public static void Encode(ReadOnlySpan<byte> scanline, Span<byte> result, int bytesPerPixel, out int sum)
-    {
-        DebugGuard.MustBeSizedAtLeast(result, scanline, nameof(result));
-
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte resultBaseRef = ref MemoryMarshal.GetReference(result);
-        sum = 0;
-
-        // Sub(x) = Raw(x) - Raw(x-bpp)
-        resultBaseRef = (byte)FilterType.Sub;
-
-        nuint x = 0;
-        for (; x < (uint)bytesPerPixel; /* Note: ++x happens in the body to avoid one add operation */)
-        {
-            byte scan = Unsafe.Add(ref scanBaseRef, x);
-            ++x;
-            ref byte res = ref Unsafe.Add(ref resultBaseRef, x);
-            res = scan;
-            sum += Numerics.Abs(unchecked((sbyte)res));
-        }
-
-        if (Avx2.IsSupported)
-        {
-            Vector256<byte> zero = Vector256<byte>.Zero;
-            Vector256<int> sumAccumulator = Vector256<int>.Zero;
-
-            for (nuint xLeft = x - (uint)bytesPerPixel; (int)x <= (scanline.Length - Vector256<byte>.Count); xLeft += (uint)Vector256<byte>.Count)
-            {
-                Vector256<byte> scan = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector256<byte> prev = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft));
-
-                Vector256<byte> res = Avx2.Subtract(scan, prev);
-                Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector256<byte>.Count;
-
-                sumAccumulator = Avx2.Add(sumAccumulator, Avx2.SumAbsoluteDifferences(Avx2.Abs(res.AsSByte()), zero).AsInt32());
-            }
 
-            sum += Numerics.EvenReduceSum(sumAccumulator);
+        // Sub does not consume an above neighbor, so the shared traversal may alias
-        }
+        // the unused previous-row argument to the current row without an extra buffer.
-        else
+        => PngFilterEncoder.Encode<SubFilterOperator>(scanline, scanline, result, (uint)bytesPerPixel, out sum);
-        if (Vector.IsHardwareAccelerated)
-        {
-            Vector<uint> sumAccumulator = Vector<uint>.Zero;
-
-            for (nuint xLeft = x - (uint)bytesPerPixel; (int)x <= (scanline.Length - Vector<byte>.Count); xLeft += (uint)Vector<byte>.Count)
-            {
-                Vector<byte> scan = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector<byte> prev = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref scanBaseRef, xLeft));
-
-                Vector<byte> res = scan - prev;
-                Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector<byte>.Count;
-
-                Numerics.Accumulate(ref sumAccumulator, Vector.AsVectorByte(Vector.Abs(Vector.AsVectorSByte(res))));
-            }
-
-            for (int i = 0; i < Vector<uint>.Count; i++)
-            {
-                sum += (int)sumAccumulator[i];
-            }
-        }
-
-        for (nuint xLeft = x - (uint)bytesPerPixel; x < (uint)scanline.Length; ++xLeft /* Note: ++x happens in the body to avoid one add operation */)
-        {
-            byte scan = Unsafe.Add(ref scanBaseRef, x);
-            byte prev = Unsafe.Add(ref scanBaseRef, xLeft);
-            ++x;
-            ref byte res = ref Unsafe.Add(ref resultBaseRef, x);
-            res = (byte)(scan - prev);
-            sum += Numerics.Abs(unchecked((sbyte)res));
-        }
-    }
 }

src/ImageSharp/Formats/Png/Filters/UpFilter.cs

@@ -1,12 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Common.Helpers;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Formats.Png.Filters;
 
@@ -27,128 +23,8 @@ internal static class UpFilter
     {
         DebugGuard.MustBeSameSized<byte>(scanline, previousScanline, nameof(scanline));
 
-        if (Avx2.IsSupported)
+        // The leading filter byte is metadata; every remaining byte is the modulo-256 sum of Raw(x) and Prior(x).
-        {
+        TensorPrimitives_.Add(scanline[1..], previousScanline[1..], scanline[1..]);
-            DecodeAvx2(scanline, previousScanline);
-        }
-        else if (Sse2.IsSupported)
-        {
-            DecodeSse2(scanline, previousScanline);
-        }
-        else if (AdvSimd.IsSupported)
-        {
-            DecodeArm(scanline, previousScanline);
-        }
-        else
-        {
-            DecodeScalar(scanline, previousScanline);
-        }
-    }
-
-    private static void DecodeAvx2(Span<byte> scanline, Span<byte> previousScanline)
-    {
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte prevBaseRef = ref MemoryMarshal.GetReference(previousScanline);
-
-        // Up(x) + Prior(x)
-        int rb = scanline.Length;
-        nuint offset = 1;
-        while (rb >= Vector256<byte>.Count)
-        {
-            ref byte scanRef = ref Unsafe.Add(ref scanBaseRef, offset);
-            Vector256<byte> prior = Unsafe.As<byte, Vector256<byte>>(ref scanRef);
-            Vector256<byte> up = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref prevBaseRef, offset));
-
-            Unsafe.As<byte, Vector256<byte>>(ref scanRef) = Avx2.Add(up, prior);
-
-            offset += (uint)Vector256<byte>.Count;
-            rb -= Vector256<byte>.Count;
-        }
-
-        // Handle left over.
-        for (nuint i = offset; i < (uint)scanline.Length; i++)
-        {
-            ref byte scan = ref Unsafe.Add(ref scanBaseRef, offset);
-            byte above = Unsafe.Add(ref prevBaseRef, offset);
-            scan = (byte)(scan + above);
-            offset++;
-        }
-    }
-
-    private static void DecodeSse2(Span<byte> scanline, Span<byte> previousScanline)
-    {
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte prevBaseRef = ref MemoryMarshal.GetReference(previousScanline);
-
-        // Up(x) + Prior(x)
-        int rb = scanline.Length;
-        nuint offset = 1;
-        while (rb >= Vector128<byte>.Count)
-        {
-            ref byte scanRef = ref Unsafe.Add(ref scanBaseRef, offset);
-            Vector128<byte> prior = Unsafe.As<byte, Vector128<byte>>(ref scanRef);
-            Vector128<byte> up = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref prevBaseRef, offset));
-
-            Unsafe.As<byte, Vector128<byte>>(ref scanRef) = Sse2.Add(up, prior);
-
-            offset += (uint)Vector128<byte>.Count;
-            rb -= Vector128<byte>.Count;
-        }
-
-        // Handle left over.
-        for (nuint i = offset; i < (uint)scanline.Length; i++)
-        {
-            ref byte scan = ref Unsafe.Add(ref scanBaseRef, offset);
-            byte above = Unsafe.Add(ref prevBaseRef, offset);
-            scan = (byte)(scan + above);
-            offset++;
-        }
-    }
-
-    private static void DecodeArm(Span<byte> scanline, Span<byte> previousScanline)
-    {
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte prevBaseRef = ref MemoryMarshal.GetReference(previousScanline);
-
-        // Up(x) + Prior(x)
-        int rb = scanline.Length;
-        nuint offset = 1;
-        const int bytesPerBatch = 16;
-        while (rb >= bytesPerBatch)
-        {
-            ref byte scanRef = ref Unsafe.Add(ref scanBaseRef, offset);
-            Vector128<byte> prior = Unsafe.As<byte, Vector128<byte>>(ref scanRef);
-            Vector128<byte> up = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref prevBaseRef, offset));
-
-            Unsafe.As<byte, Vector128<byte>>(ref scanRef) = AdvSimd.Add(prior, up);
-
-            offset += bytesPerBatch;
-            rb -= bytesPerBatch;
-        }
-
-        // Handle left over.
-        for (nuint i = offset; i < (uint)scanline.Length; i++)
-        {
-            ref byte scan = ref Unsafe.Add(ref scanBaseRef, offset);
-            byte above = Unsafe.Add(ref prevBaseRef, offset);
-            scan = (byte)(scan + above);
-            offset++;
-        }
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void DecodeScalar(Span<byte> scanline, Span<byte> previousScanline)
-    {
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte prevBaseRef = ref MemoryMarshal.GetReference(previousScanline);
-
-        // Up(x) + Prior(x)
-        for (nuint x = 1; x < (uint)scanline.Length; x++)
-        {
-            ref byte scan = ref Unsafe.Add(ref scanBaseRef, x);
-            byte above = Unsafe.Add(ref prevBaseRef, x);
-            scan = (byte)(scan + above);
-        }
     }
 
     /// <summary>
@@ -160,69 +36,8 @@ internal static class UpFilter
     /// <param name="sum">The sum of the total variance of the filtered row.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void Encode(ReadOnlySpan<byte> scanline, ReadOnlySpan<byte> previousScanline, Span<byte> result, out int sum)
-    {
-        DebugGuard.MustBeSameSized(scanline, previousScanline, nameof(scanline));
-        DebugGuard.MustBeSizedAtLeast(result, scanline, nameof(result));
-
-        ref byte scanBaseRef = ref MemoryMarshal.GetReference(scanline);
-        ref byte prevBaseRef = ref MemoryMarshal.GetReference(previousScanline);
-        ref byte resultBaseRef = ref MemoryMarshal.GetReference(result);
-        sum = 0;
-
-        // Up(x) = Raw(x) - Prior(x)
-        resultBaseRef = (byte)FilterType.Up;
-
-        nuint x = 0;
 
-        if (Avx2.IsSupported)
+        // Up never reads a left neighbor, so bytesPerPixel is deliberately zero in
-        {
+        // the shared traversal and no unsigned left offset is evaluated.
-            Vector256<byte> zero = Vector256<byte>.Zero;
+        => PngFilterEncoder.Encode<UpFilterOperator>(scanline, previousScanline, result, 0, out sum);
-            Vector256<int> sumAccumulator = Vector256<int>.Zero;
-
-            for (; (int)x <= scanline.Length - Vector256<byte>.Count;)
-            {
-                Vector256<byte> scan = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector256<byte> above = Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref prevBaseRef, x));
-
-                Vector256<byte> res = Avx2.Subtract(scan, above);
-                Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector256<byte>.Count;
-
-                sumAccumulator = Avx2.Add(sumAccumulator, Avx2.SumAbsoluteDifferences(Avx2.Abs(res.AsSByte()), zero).AsInt32());
-            }
-
-            sum += Numerics.EvenReduceSum(sumAccumulator);
-        }
-        else if (Vector.IsHardwareAccelerated)
-        {
-            Vector<uint> sumAccumulator = Vector<uint>.Zero;
-
-            for (; (int)x <= scanline.Length - Vector<byte>.Count;)
-            {
-                Vector<byte> scan = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref scanBaseRef, x));
-                Vector<byte> above = Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref prevBaseRef, x));
-
-                Vector<byte> res = scan - above;
-                Unsafe.As<byte, Vector<byte>>(ref Unsafe.Add(ref resultBaseRef, x + 1)) = res; // +1 to skip filter type
-                x += (uint)Vector<byte>.Count;
-
-                Numerics.Accumulate(ref sumAccumulator, Vector.AsVectorByte(Vector.Abs(Vector.AsVectorSByte(res))));
-            }
-
-            for (int i = 0; i < Vector<uint>.Count; i++)
-            {
-                sum += (int)sumAccumulator[i];
-            }
-        }
-
-        for (; x < (uint)scanline.Length; /* Note: ++x happens in the body to avoid one add operation */)
-        {
-            byte scan = Unsafe.Add(ref scanBaseRef, x);
-            byte above = Unsafe.Add(ref prevBaseRef, x);
-            ++x;
-            ref byte res = ref Unsafe.Add(ref resultBaseRef, x);
-            res = (byte)(scan - above);
-            sum += Numerics.Abs(unchecked((sbyte)res));
-        }
-    }
 }

src/ImageSharp/Formats/Webp/AlphaDecoder.cs

@@ -361,34 +361,10 @@ internal class AlphaDecoder : IDisposable
         {
             HorizontalUnfilter(null, input, dst, width);
         }
-        else if (Vector256.IsHardwareAccelerated)
-        {
-            ref byte inputRef = ref MemoryMarshal.GetReference(input);
-            ref byte prevRef = ref MemoryMarshal.GetReference(prev);
-            ref byte dstRef = ref MemoryMarshal.GetReference(dst);
-
-            nuint i;
-            int maxPos = width & ~31;
-            for (i = 0; i < (uint)maxPos; i += 32)
-            {
-                Vector256<int> a0 = Unsafe.As<byte, Vector256<int>>(ref Unsafe.Add(ref inputRef, i));
-                Vector256<int> b0 = Unsafe.As<byte, Vector256<int>>(ref Unsafe.Add(ref prevRef, i));
-                Vector256<byte> c0 = a0.AsByte() + b0.AsByte();
-                ref byte outputRef = ref Unsafe.Add(ref dstRef, i);
-                Unsafe.As<byte, Vector256<byte>>(ref outputRef) = c0;
-            }
-
-            for (; i < (uint)width; i++)
-            {
-                Unsafe.Add(ref dstRef, i) = (byte)(Unsafe.Add(ref prevRef, i) + Unsafe.Add(ref inputRef, i));
-            }
-        }
         else
         {
-            for (int i = 0; i < width; i++)
+            // Byte addition intentionally wraps modulo 256, matching the WebP alpha predictor.
-            {
+            TensorPrimitives_.Add(input[..width], prev[..width], dst[..width]);
-                dst[i] = (byte)(prev[i] + input[i]);
-            }
         }
     }
 

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

@@ -3,9 +3,7 @@
 
 using System.Buffers;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Common.Helpers;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Formats.Webp.Lossless;
@@ -333,7 +331,7 @@ internal abstract unsafe class Vp8LHistogram
         {
             if (b.IsUsed(0))
             {
-                AddVector(this.Literal, b.Literal, output.Literal, literalSize);
+                TensorPrimitives_.Add(this.Literal[..literalSize], b.Literal[..literalSize], output.Literal[..literalSize]);
             }
             else
             {
@@ -356,7 +354,7 @@ internal abstract unsafe class Vp8LHistogram
         {
             if (b.IsUsed(1))
             {
-                AddVector(this.Red, b.Red, output.Red, size);
+                TensorPrimitives_.Add(this.Red[..size], b.Red[..size], output.Red[..size]);
             }
             else
             {
@@ -379,7 +377,7 @@ internal abstract unsafe class Vp8LHistogram
         {
             if (b.IsUsed(2))
             {
-                AddVector(this.Blue, b.Blue, output.Blue, size);
+                TensorPrimitives_.Add(this.Blue[..size], b.Blue[..size], output.Blue[..size]);
             }
             else
             {
@@ -402,7 +400,7 @@ internal abstract unsafe class Vp8LHistogram
         {
             if (b.IsUsed(3))
             {
-                AddVector(this.Alpha, b.Alpha, output.Alpha, size);
+                TensorPrimitives_.Add(this.Alpha[..size], b.Alpha[..size], output.Alpha[..size]);
             }
             else
             {
@@ -425,7 +423,7 @@ internal abstract unsafe class Vp8LHistogram
         {
             if (b.IsUsed(4))
             {
-                AddVector(this.Distance, b.Distance, output.Distance, size);
+                TensorPrimitives_.Add(this.Distance[..size], b.Distance[..size], output.Distance[..size]);
             }
             else
             {
@@ -535,56 +533,6 @@ internal abstract unsafe class Vp8LHistogram
 
         return cost;
     }
-
-    private static void AddVector(Span<uint> a, Span<uint> b, Span<uint> output, int count)
-    {
-        DebugGuard.MustBeGreaterThanOrEqualTo(a.Length, count, nameof(a.Length));
-        DebugGuard.MustBeGreaterThanOrEqualTo(b.Length, count, nameof(b.Length));
-        DebugGuard.MustBeGreaterThanOrEqualTo(output.Length, count, nameof(output.Length));
-
-        if (Avx2.IsSupported && count >= 32)
-        {
-            ref uint aRef = ref MemoryMarshal.GetReference(a);
-            ref uint bRef = ref MemoryMarshal.GetReference(b);
-            ref uint outputRef = ref MemoryMarshal.GetReference(output);
-
-            nuint idx = 0;
-            do
-            {
-                // Load values.
-                Vector256<uint> a0 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref aRef, idx + 0));
-                Vector256<uint> a1 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref aRef, idx + 8));
-                Vector256<uint> a2 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref aRef, idx + 16));
-                Vector256<uint> a3 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref aRef, idx + 24));
-                Vector256<uint> b0 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref bRef, idx + 0));
-                Vector256<uint> b1 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref bRef, idx + 8));
-                Vector256<uint> b2 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref bRef, idx + 16));
-                Vector256<uint> b3 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref bRef, idx + 24));
-
-                // Note we are adding uint32_t's as *signed* int32's (using _mm_add_epi32). But
-                // that's ok since the histogram values are less than 1<<28 (max picture count).
-                Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref outputRef, idx + 0)) = Avx2.Add(a0, b0);
-                Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref outputRef, idx + 8)) = Avx2.Add(a1, b1);
-                Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref outputRef, idx + 16)) = Avx2.Add(a2, b2);
-                Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref outputRef, idx + 24)) = Avx2.Add(a3, b3);
-                idx += 32;
-            }
-            while (idx <= (uint)count - 32);
-
-            int i = (int)idx;
-            for (; i < count; i++)
-            {
-                output[i] = a[i] + b[i];
-            }
-        }
-        else
-        {
-            for (int i = 0; i < count; i++)
-            {
-                output[i] = a[i] + b[i];
-            }
-        }
-    }
 }
 
 internal sealed unsafe class OwnedVp8LHistogram : Vp8LHistogram, IDisposable

src/ImageSharp/Metadata/Profiles/ICC/Various/IccLut.cs

@@ -23,13 +23,8 @@ internal readonly struct IccLut : IEquatable<IccLut>
     {
         Guard.NotNull(values, nameof(values));
 
-        const float max = ushort.MaxValue;
-
         this.Values = new float[values.Length];
-        for (int i = 0; i < values.Length; i++)
+        IccLutNormalizer.Normalize(values, this.Values);
-        {
-            this.Values[i] = values[i] / max;
-        }
     }
 
     /// <summary>
@@ -40,13 +35,8 @@ internal readonly struct IccLut : IEquatable<IccLut>
     {
         Guard.NotNull(values, nameof(values));
 
-        const float max = byte.MaxValue;
-
         this.Values = new float[values.Length];
-        for (int i = 0; i < values.Length; i++)
+        IccLutNormalizer.Normalize(values, this.Values);
-        {
-            this.Values[i] = values[i] / max;
-        }
     }
 
     /// <summary>

src/ImageSharp/Metadata/Profiles/ICC/Various/IccLutNormalizer.cs

@@ -0,0 +1,253 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+/// <summary>
+/// Converts integer ICC lookup-table entries to their normalized single-precision representation.
+/// </summary>
+internal static class IccLutNormalizer
+{
+    /// <summary>
+    /// Defines the scalar and SIMD conversion for an integer lookup-table element type.
+    /// </summary>
+    /// <typeparam name="T">The integer element type.</typeparam>
+    private interface INormalizeOperator<T>
+        where T : unmanaged
+    {
+        /// <summary>
+        /// Gets the divisor that maps the integer range to <c>[0, 1]</c>.
+        /// </summary>
+        public static abstract float Divisor { get; }
+
+        /// <summary>
+        /// Converts one scalar value.
+        /// </summary>
+        /// <param name="source">The integer value.</param>
+        /// <returns>The normalized value.</returns>
+        public static abstract float Invoke(T source);
+
+        /// <summary>
+        /// Converts one 128-bit input vector and stores the expanded single-precision results.
+        /// </summary>
+        /// <param name="source">The packed integer values.</param>
+        /// <param name="divisor">The normalization divisor.</param>
+        /// <param name="destination">The first destination element.</param>
+        public static abstract void Invoke(Vector128<T> source, Vector128<float> divisor, ref float destination);
+
+        /// <summary>
+        /// Converts one 256-bit input vector and stores the expanded single-precision results.
+        /// </summary>
+        /// <param name="source">The packed integer values.</param>
+        /// <param name="divisor">The normalization divisor.</param>
+        /// <param name="destination">The first destination element.</param>
+        public static abstract void Invoke(Vector256<T> source, Vector256<float> divisor, ref float destination);
+
+        /// <summary>
+        /// Converts one 512-bit input vector and stores the expanded single-precision results.
+        /// </summary>
+        /// <param name="source">The packed integer values.</param>
+        /// <param name="divisor">The normalization divisor.</param>
+        /// <param name="destination">The first destination element.</param>
+        public static abstract void Invoke(Vector512<T> source, Vector512<float> divisor, ref float destination);
+    }
+
+    /// <summary>
+    /// Converts byte lookup-table entries to normalized single-precision values.
+    /// </summary>
+    /// <param name="source">The integer lookup-table entries.</param>
+    /// <param name="destination">The normalized destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Normalize(ReadOnlySpan<byte> source, Span<float> destination)
+        => Normalize<byte, ByteNormalizeOperator>(source, destination);
+
+    /// <summary>
+    /// Converts unsigned-short lookup-table entries to normalized single-precision values.
+    /// </summary>
+    /// <param name="source">The integer lookup-table entries.</param>
+    /// <param name="destination">The normalized destination values.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Normalize(ReadOnlySpan<ushort> source, Span<float> destination)
+        => Normalize<ushort, UInt16NormalizeOperator>(source, destination);
+
+    /// <summary>
+    /// Converts an integer lookup table using the widest available portable SIMD width, followed by narrower
+    /// widths and a scalar remainder.
+    /// </summary>
+    /// <typeparam name="T">The integer element type.</typeparam>
+    /// <typeparam name="TOperator">The conversion implementation.</typeparam>
+    /// <param name="source">The integer lookup-table entries.</param>
+    /// <param name="destination">The normalized destination values.</param>
+    private static void Normalize<T, TOperator>(ReadOnlySpan<T> source, Span<float> destination)
+        where T : unmanaged
+        where TOperator : struct, INormalizeOperator<T>
+    {
+        ref T sourceRef = ref MemoryMarshal.GetReference(source);
+        ref float destinationRef = ref MemoryMarshal.GetReference(destination);
+        nuint length = (uint)source.Length;
+        nuint index = 0;
+
+        if (Vector512.IsHardwareAccelerated)
+        {
+            Vector512<float> divisor = Vector512.Create(TOperator.Divisor);
+            nuint count = (uint)Vector512<T>.Count;
+
+            while (length - index >= count)
+            {
+                ref float destinationStart = ref Unsafe.Add(ref destinationRef, index);
+                TOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, index), divisor, ref destinationStart);
+                index += count;
+            }
+        }
+
+        if (Vector256.IsHardwareAccelerated)
+        {
+            Vector256<float> divisor = Vector256.Create(TOperator.Divisor);
+            nuint count = (uint)Vector256<T>.Count;
+
+            while (length - index >= count)
+            {
+                ref float destinationStart = ref Unsafe.Add(ref destinationRef, index);
+                TOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, index), divisor, ref destinationStart);
+                index += count;
+            }
+        }
+
+        if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<float> divisor = Vector128.Create(TOperator.Divisor);
+            nuint count = (uint)Vector128<T>.Count;
+
+            while (length - index >= count)
+            {
+                ref float destinationStart = ref Unsafe.Add(ref destinationRef, index);
+                TOperator.Invoke(Vector128.LoadUnsafe(ref sourceRef, index), divisor, ref destinationStart);
+                index += count;
+            }
+        }
+
+        // Preserve the scalar division expression for the final partial vector. Multiplication by a reciprocal
+        // is not bit-equivalent for every input and would change the values stored in the ICC profile model.
+        while (index < length)
+        {
+            Unsafe.Add(ref destinationRef, index) = TOperator.Invoke(Unsafe.Add(ref sourceRef, index));
+            index++;
+        }
+    }
+
+    /// <summary>
+    /// Converts packed byte entries to normalized single-precision values.
+    /// </summary>
+    private readonly struct ByteNormalizeOperator : INormalizeOperator<byte>
+    {
+        /// <inheritdoc/>
+        public static float Divisor => byte.MaxValue;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Invoke(byte source)
+            => source / (float)byte.MaxValue;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke(Vector128<byte> source, Vector128<float> divisor, ref float destination)
+        {
+            // [b0..b15] becomes four ordered groups of four UInt32 values. Every widened value is at most
+            // 255, so reinterpreting UInt32 as Int32 before conversion preserves its numeric value.
+            (Vector128<ushort> lower16, Vector128<ushort> upper16) = Vector128.Widen(source);
+            (Vector128<uint> values0, Vector128<uint> values1) = Vector128.Widen(lower16);
+            (Vector128<uint> values2, Vector128<uint> values3) = Vector128.Widen(upper16);
+
+            (Vector128.ConvertToSingle(values0.AsInt32()) / divisor).StoreUnsafe(ref destination);
+            (Vector128.ConvertToSingle(values1.AsInt32()) / divisor).StoreUnsafe(ref destination, 4);
+            (Vector128.ConvertToSingle(values2.AsInt32()) / divisor).StoreUnsafe(ref destination, 8);
+            (Vector128.ConvertToSingle(values3.AsInt32()) / divisor).StoreUnsafe(ref destination, 12);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke(Vector256<byte> source, Vector256<float> divisor, ref float destination)
+        {
+            // [b0..b31] becomes four ordered groups of eight UInt32 values, matching four contiguous
+            // Vector256<float> stores without shuffling the converted results.
+            (Vector256<ushort> lower16, Vector256<ushort> upper16) = Vector256.Widen(source);
+            (Vector256<uint> values0, Vector256<uint> values1) = Vector256.Widen(lower16);
+            (Vector256<uint> values2, Vector256<uint> values3) = Vector256.Widen(upper16);
+
+            (Vector256.ConvertToSingle(values0.AsInt32()) / divisor).StoreUnsafe(ref destination);
+            (Vector256.ConvertToSingle(values1.AsInt32()) / divisor).StoreUnsafe(ref destination, 8);
+            (Vector256.ConvertToSingle(values2.AsInt32()) / divisor).StoreUnsafe(ref destination, 16);
+            (Vector256.ConvertToSingle(values3.AsInt32()) / divisor).StoreUnsafe(ref destination, 24);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke(Vector512<byte> source, Vector512<float> divisor, ref float destination)
+        {
+            // [b0..b63] becomes four ordered groups of sixteen UInt32 values, matching four contiguous
+            // Vector512<float> stores. The portable widening APIs map to zero-extension instructions.
+            (Vector512<ushort> lower16, Vector512<ushort> upper16) = Vector512.Widen(source);
+            (Vector512<uint> values0, Vector512<uint> values1) = Vector512.Widen(lower16);
+            (Vector512<uint> values2, Vector512<uint> values3) = Vector512.Widen(upper16);
+
+            (Vector512.ConvertToSingle(values0.AsInt32()) / divisor).StoreUnsafe(ref destination);
+            (Vector512.ConvertToSingle(values1.AsInt32()) / divisor).StoreUnsafe(ref destination, 16);
+            (Vector512.ConvertToSingle(values2.AsInt32()) / divisor).StoreUnsafe(ref destination, 32);
+            (Vector512.ConvertToSingle(values3.AsInt32()) / divisor).StoreUnsafe(ref destination, 48);
+        }
+    }
+
+    /// <summary>
+    /// Converts packed unsigned-short entries to normalized single-precision values.
+    /// </summary>
+    private readonly struct UInt16NormalizeOperator : INormalizeOperator<ushort>
+    {
+        /// <inheritdoc/>
+        public static float Divisor => ushort.MaxValue;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Invoke(ushort source)
+            => source / (float)ushort.MaxValue;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke(Vector128<ushort> source, Vector128<float> divisor, ref float destination)
+        {
+            // [u0..u7] becomes two ordered groups of four UInt32 values. Every value is at most 65535,
+            // so signed conversion after reinterpretation is numerically identical to unsigned conversion.
+            (Vector128<uint> lower, Vector128<uint> upper) = Vector128.Widen(source);
+
+            (Vector128.ConvertToSingle(lower.AsInt32()) / divisor).StoreUnsafe(ref destination);
+            (Vector128.ConvertToSingle(upper.AsInt32()) / divisor).StoreUnsafe(ref destination, 4);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke(Vector256<ushort> source, Vector256<float> divisor, ref float destination)
+        {
+            // [u0..u15] becomes two ordered groups of eight UInt32 values, matching two contiguous
+            // Vector256<float> stores without a result shuffle.
+            (Vector256<uint> lower, Vector256<uint> upper) = Vector256.Widen(source);
+
+            (Vector256.ConvertToSingle(lower.AsInt32()) / divisor).StoreUnsafe(ref destination);
+            (Vector256.ConvertToSingle(upper.AsInt32()) / divisor).StoreUnsafe(ref destination, 8);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke(Vector512<ushort> source, Vector512<float> divisor, ref float destination)
+        {
+            // [u0..u31] becomes two ordered groups of sixteen UInt32 values, matching two contiguous
+            // Vector512<float> stores. The portable widening APIs map to zero-extension instructions.
+            (Vector512<uint> lower, Vector512<uint> upper) = Vector512.Widen(source);
+
+            (Vector512.ConvertToSingle(lower.AsInt32()) / divisor).StoreUnsafe(ref destination);
+            (Vector512.ConvertToSingle(upper.AsInt32()) / divisor).StoreUnsafe(ref destination, 16);
+        }
+    }
+}

src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt

@@ -4,31 +4,19 @@
 #>
 <#@ template debug="false" hostspecific="false" language="C#" #>
 <#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
 <#@ output extension=".cs" #>
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // <auto-generated />
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
-/// <summary>
-/// Provides generated Porter-Duff blenders for associated-alpha pixel formats.
-/// </summary>
-internal static partial class AssociatedAlphaPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
-{
-
 <#
-var composers = new []{
+var composers = new []
+{
     "Src",
     "SrcAtop",
     "SrcOver",
@@ -43,7 +31,8 @@ var composers = new []{
     "Xor",
 };
 
-var blenders = new []{
+var blenders = new []
+{
     "Normal",
     "Multiply",
     "Add",
@@ -52,796 +41,69 @@ var blenders = new []{
     "Darken",
     "Lighten",
     "Overlay",
-    "HardLight"
+    "HardLight",
 };
-
+#>
-    foreach(var composer in composers) {
+/// <summary>
-    foreach(var blender in blenders) {
+/// Provides the associated-alpha equations consumed by the shared pixel-blending traversal.
-
+/// </summary>
-        var blender_composer= $"{blender}{composer}";
+internal static class AssociatedAlphaPixelBlenderOperators
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
 #>
     /// <summary>
-    /// A pixel blender that implements the "<#= blender_composer#>" composition equation.
+    /// Applies the "<#= blenderComposer #>" associated-alpha composition equation.
     /// </summary>
-    public sealed class <#= blender_composer#> : AssociatedAlphaPixelBlender<TPixel>
+    public readonly struct <#= blenderComposer #> : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static <#=blender_composer#> Instance { get; } = new <#=blender_composer#>();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-        }
-
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        public static bool IsAssociatedAlpha => true;
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-        {
+            => AssociatedAlphaPorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-        {
+            => AssociatedAlphaPorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-        {
+            => AssociatedAlphaPorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
     }
 
 <#
     }
 }
+#>
+}
+
+/// <summary>
+/// Provides associated-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The associated-alpha destination pixel format.</typeparam>
+internal static partial class AssociatedAlphaPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
+#>
+    /// <summary>
+    /// Gets the shared blender for the "<#= blenderComposer #>" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> <#= blenderComposer #> => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.<#= blenderComposer #>>.Instance;
 
+<#
+    }
+}
 #>
 }

src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.cs

@@ -21,147 +21,147 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
         {
             PixelAlphaCompositionMode.Src => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplySrc.Instance,
+                PixelColorBlendingMode.Multiply => MultiplySrc,
-                PixelColorBlendingMode.Add => AddSrc.Instance,
+                PixelColorBlendingMode.Add => AddSrc,
-                PixelColorBlendingMode.Subtract => SubtractSrc.Instance,
+                PixelColorBlendingMode.Subtract => SubtractSrc,
-                PixelColorBlendingMode.Screen => ScreenSrc.Instance,
+                PixelColorBlendingMode.Screen => ScreenSrc,
-                PixelColorBlendingMode.Darken => DarkenSrc.Instance,
+                PixelColorBlendingMode.Darken => DarkenSrc,
-                PixelColorBlendingMode.Lighten => LightenSrc.Instance,
+                PixelColorBlendingMode.Lighten => LightenSrc,
-                PixelColorBlendingMode.Overlay => OverlaySrc.Instance,
+                PixelColorBlendingMode.Overlay => OverlaySrc,
-                PixelColorBlendingMode.HardLight => HardLightSrc.Instance,
+                PixelColorBlendingMode.HardLight => HardLightSrc,
-                _ => NormalSrc.Instance,
+                _ => NormalSrc,
             },
             PixelAlphaCompositionMode.SrcAtop => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplySrcAtop.Instance,
+                PixelColorBlendingMode.Multiply => MultiplySrcAtop,
-                PixelColorBlendingMode.Add => AddSrcAtop.Instance,
+                PixelColorBlendingMode.Add => AddSrcAtop,
-                PixelColorBlendingMode.Subtract => SubtractSrcAtop.Instance,
+                PixelColorBlendingMode.Subtract => SubtractSrcAtop,
-                PixelColorBlendingMode.Screen => ScreenSrcAtop.Instance,
+                PixelColorBlendingMode.Screen => ScreenSrcAtop,
-                PixelColorBlendingMode.Darken => DarkenSrcAtop.Instance,
+                PixelColorBlendingMode.Darken => DarkenSrcAtop,
-                PixelColorBlendingMode.Lighten => LightenSrcAtop.Instance,
+                PixelColorBlendingMode.Lighten => LightenSrcAtop,
-                PixelColorBlendingMode.Overlay => OverlaySrcAtop.Instance,
+                PixelColorBlendingMode.Overlay => OverlaySrcAtop,
-                PixelColorBlendingMode.HardLight => HardLightSrcAtop.Instance,
+                PixelColorBlendingMode.HardLight => HardLightSrcAtop,
-                _ => NormalSrcAtop.Instance,
+                _ => NormalSrcAtop,
             },
             PixelAlphaCompositionMode.SrcIn => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplySrcIn.Instance,
+                PixelColorBlendingMode.Multiply => MultiplySrcIn,
-                PixelColorBlendingMode.Add => AddSrcIn.Instance,
+                PixelColorBlendingMode.Add => AddSrcIn,
-                PixelColorBlendingMode.Subtract => SubtractSrcIn.Instance,
+                PixelColorBlendingMode.Subtract => SubtractSrcIn,
-                PixelColorBlendingMode.Screen => ScreenSrcIn.Instance,
+                PixelColorBlendingMode.Screen => ScreenSrcIn,
-                PixelColorBlendingMode.Darken => DarkenSrcIn.Instance,
+                PixelColorBlendingMode.Darken => DarkenSrcIn,
-                PixelColorBlendingMode.Lighten => LightenSrcIn.Instance,
+                PixelColorBlendingMode.Lighten => LightenSrcIn,
-                PixelColorBlendingMode.Overlay => OverlaySrcIn.Instance,
+                PixelColorBlendingMode.Overlay => OverlaySrcIn,
-                PixelColorBlendingMode.HardLight => HardLightSrcIn.Instance,
+                PixelColorBlendingMode.HardLight => HardLightSrcIn,
-                _ => NormalSrcIn.Instance,
+                _ => NormalSrcIn,
             },
             PixelAlphaCompositionMode.SrcOut => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplySrcOut.Instance,
+                PixelColorBlendingMode.Multiply => MultiplySrcOut,
-                PixelColorBlendingMode.Add => AddSrcOut.Instance,
+                PixelColorBlendingMode.Add => AddSrcOut,
-                PixelColorBlendingMode.Subtract => SubtractSrcOut.Instance,
+                PixelColorBlendingMode.Subtract => SubtractSrcOut,
-                PixelColorBlendingMode.Screen => ScreenSrcOut.Instance,
+                PixelColorBlendingMode.Screen => ScreenSrcOut,
-                PixelColorBlendingMode.Darken => DarkenSrcOut.Instance,
+                PixelColorBlendingMode.Darken => DarkenSrcOut,
-                PixelColorBlendingMode.Lighten => LightenSrcOut.Instance,
+                PixelColorBlendingMode.Lighten => LightenSrcOut,
-                PixelColorBlendingMode.Overlay => OverlaySrcOut.Instance,
+                PixelColorBlendingMode.Overlay => OverlaySrcOut,
-                PixelColorBlendingMode.HardLight => HardLightSrcOut.Instance,
+                PixelColorBlendingMode.HardLight => HardLightSrcOut,
-                _ => NormalSrcOut.Instance,
+                _ => NormalSrcOut,
             },
             PixelAlphaCompositionMode.Dest => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplyDest.Instance,
+                PixelColorBlendingMode.Multiply => MultiplyDest,
-                PixelColorBlendingMode.Add => AddDest.Instance,
+                PixelColorBlendingMode.Add => AddDest,
-                PixelColorBlendingMode.Subtract => SubtractDest.Instance,
+                PixelColorBlendingMode.Subtract => SubtractDest,
-                PixelColorBlendingMode.Screen => ScreenDest.Instance,
+                PixelColorBlendingMode.Screen => ScreenDest,
-                PixelColorBlendingMode.Darken => DarkenDest.Instance,
+                PixelColorBlendingMode.Darken => DarkenDest,
-                PixelColorBlendingMode.Lighten => LightenDest.Instance,
+                PixelColorBlendingMode.Lighten => LightenDest,
-                PixelColorBlendingMode.Overlay => OverlayDest.Instance,
+                PixelColorBlendingMode.Overlay => OverlayDest,
-                PixelColorBlendingMode.HardLight => HardLightDest.Instance,
+                PixelColorBlendingMode.HardLight => HardLightDest,
-                _ => NormalDest.Instance,
+                _ => NormalDest,
             },
             PixelAlphaCompositionMode.DestAtop => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplyDestAtop.Instance,
+                PixelColorBlendingMode.Multiply => MultiplyDestAtop,
-                PixelColorBlendingMode.Add => AddDestAtop.Instance,
+                PixelColorBlendingMode.Add => AddDestAtop,
-                PixelColorBlendingMode.Subtract => SubtractDestAtop.Instance,
+                PixelColorBlendingMode.Subtract => SubtractDestAtop,
-                PixelColorBlendingMode.Screen => ScreenDestAtop.Instance,
+                PixelColorBlendingMode.Screen => ScreenDestAtop,
-                PixelColorBlendingMode.Darken => DarkenDestAtop.Instance,
+                PixelColorBlendingMode.Darken => DarkenDestAtop,
-                PixelColorBlendingMode.Lighten => LightenDestAtop.Instance,
+                PixelColorBlendingMode.Lighten => LightenDestAtop,
-                PixelColorBlendingMode.Overlay => OverlayDestAtop.Instance,
+                PixelColorBlendingMode.Overlay => OverlayDestAtop,
-                PixelColorBlendingMode.HardLight => HardLightDestAtop.Instance,
+                PixelColorBlendingMode.HardLight => HardLightDestAtop,
-                _ => NormalDestAtop.Instance,
+                _ => NormalDestAtop,
             },
             PixelAlphaCompositionMode.DestOver => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplyDestOver.Instance,
+                PixelColorBlendingMode.Multiply => MultiplyDestOver,
-                PixelColorBlendingMode.Add => AddDestOver.Instance,
+                PixelColorBlendingMode.Add => AddDestOver,
-                PixelColorBlendingMode.Subtract => SubtractDestOver.Instance,
+                PixelColorBlendingMode.Subtract => SubtractDestOver,
-                PixelColorBlendingMode.Screen => ScreenDestOver.Instance,
+                PixelColorBlendingMode.Screen => ScreenDestOver,
-                PixelColorBlendingMode.Darken => DarkenDestOver.Instance,
+                PixelColorBlendingMode.Darken => DarkenDestOver,
-                PixelColorBlendingMode.Lighten => LightenDestOver.Instance,
+                PixelColorBlendingMode.Lighten => LightenDestOver,
-                PixelColorBlendingMode.Overlay => OverlayDestOver.Instance,
+                PixelColorBlendingMode.Overlay => OverlayDestOver,
-                PixelColorBlendingMode.HardLight => HardLightDestOver.Instance,
+                PixelColorBlendingMode.HardLight => HardLightDestOver,
-                _ => NormalDestOver.Instance,
+                _ => NormalDestOver,
             },
             PixelAlphaCompositionMode.DestIn => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplyDestIn.Instance,
+                PixelColorBlendingMode.Multiply => MultiplyDestIn,
-                PixelColorBlendingMode.Add => AddDestIn.Instance,
+                PixelColorBlendingMode.Add => AddDestIn,
-                PixelColorBlendingMode.Subtract => SubtractDestIn.Instance,
+                PixelColorBlendingMode.Subtract => SubtractDestIn,
-                PixelColorBlendingMode.Screen => ScreenDestIn.Instance,
+                PixelColorBlendingMode.Screen => ScreenDestIn,
-                PixelColorBlendingMode.Darken => DarkenDestIn.Instance,
+                PixelColorBlendingMode.Darken => DarkenDestIn,
-                PixelColorBlendingMode.Lighten => LightenDestIn.Instance,
+                PixelColorBlendingMode.Lighten => LightenDestIn,
-                PixelColorBlendingMode.Overlay => OverlayDestIn.Instance,
+                PixelColorBlendingMode.Overlay => OverlayDestIn,
-                PixelColorBlendingMode.HardLight => HardLightDestIn.Instance,
+                PixelColorBlendingMode.HardLight => HardLightDestIn,
-                _ => NormalDestIn.Instance,
+                _ => NormalDestIn,
             },
             PixelAlphaCompositionMode.DestOut => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplyDestOut.Instance,
+                PixelColorBlendingMode.Multiply => MultiplyDestOut,
-                PixelColorBlendingMode.Add => AddDestOut.Instance,
+                PixelColorBlendingMode.Add => AddDestOut,
-                PixelColorBlendingMode.Subtract => SubtractDestOut.Instance,
+                PixelColorBlendingMode.Subtract => SubtractDestOut,
-                PixelColorBlendingMode.Screen => ScreenDestOut.Instance,
+                PixelColorBlendingMode.Screen => ScreenDestOut,
-                PixelColorBlendingMode.Darken => DarkenDestOut.Instance,
+                PixelColorBlendingMode.Darken => DarkenDestOut,
-                PixelColorBlendingMode.Lighten => LightenDestOut.Instance,
+                PixelColorBlendingMode.Lighten => LightenDestOut,
-                PixelColorBlendingMode.Overlay => OverlayDestOut.Instance,
+                PixelColorBlendingMode.Overlay => OverlayDestOut,
-                PixelColorBlendingMode.HardLight => HardLightDestOut.Instance,
+                PixelColorBlendingMode.HardLight => HardLightDestOut,
-                _ => NormalDestOut.Instance,
+                _ => NormalDestOut,
             },
             PixelAlphaCompositionMode.Clear => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplyClear.Instance,
+                PixelColorBlendingMode.Multiply => MultiplyClear,
-                PixelColorBlendingMode.Add => AddClear.Instance,
+                PixelColorBlendingMode.Add => AddClear,
-                PixelColorBlendingMode.Subtract => SubtractClear.Instance,
+                PixelColorBlendingMode.Subtract => SubtractClear,
-                PixelColorBlendingMode.Screen => ScreenClear.Instance,
+                PixelColorBlendingMode.Screen => ScreenClear,
-                PixelColorBlendingMode.Darken => DarkenClear.Instance,
+                PixelColorBlendingMode.Darken => DarkenClear,
-                PixelColorBlendingMode.Lighten => LightenClear.Instance,
+                PixelColorBlendingMode.Lighten => LightenClear,
-                PixelColorBlendingMode.Overlay => OverlayClear.Instance,
+                PixelColorBlendingMode.Overlay => OverlayClear,
-                PixelColorBlendingMode.HardLight => HardLightClear.Instance,
+                PixelColorBlendingMode.HardLight => HardLightClear,
-                _ => NormalClear.Instance,
+                _ => NormalClear,
             },
             PixelAlphaCompositionMode.Xor => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplyXor.Instance,
+                PixelColorBlendingMode.Multiply => MultiplyXor,
-                PixelColorBlendingMode.Add => AddXor.Instance,
+                PixelColorBlendingMode.Add => AddXor,
-                PixelColorBlendingMode.Subtract => SubtractXor.Instance,
+                PixelColorBlendingMode.Subtract => SubtractXor,
-                PixelColorBlendingMode.Screen => ScreenXor.Instance,
+                PixelColorBlendingMode.Screen => ScreenXor,
-                PixelColorBlendingMode.Darken => DarkenXor.Instance,
+                PixelColorBlendingMode.Darken => DarkenXor,
-                PixelColorBlendingMode.Lighten => LightenXor.Instance,
+                PixelColorBlendingMode.Lighten => LightenXor,
-                PixelColorBlendingMode.Overlay => OverlayXor.Instance,
+                PixelColorBlendingMode.Overlay => OverlayXor,
-                PixelColorBlendingMode.HardLight => HardLightXor.Instance,
+                PixelColorBlendingMode.HardLight => HardLightXor,
-                _ => NormalXor.Instance,
+                _ => NormalXor,
             },
             _ => colorMode switch
             {
-                PixelColorBlendingMode.Multiply => MultiplySrcOver.Instance,
+                PixelColorBlendingMode.Multiply => MultiplySrcOver,
-                PixelColorBlendingMode.Add => AddSrcOver.Instance,
+                PixelColorBlendingMode.Add => AddSrcOver,
-                PixelColorBlendingMode.Subtract => SubtractSrcOver.Instance,
+                PixelColorBlendingMode.Subtract => SubtractSrcOver,
-                PixelColorBlendingMode.Screen => ScreenSrcOver.Instance,
+                PixelColorBlendingMode.Screen => ScreenSrcOver,
-                PixelColorBlendingMode.Darken => DarkenSrcOver.Instance,
+                PixelColorBlendingMode.Darken => DarkenSrcOver,
-                PixelColorBlendingMode.Lighten => LightenSrcOver.Instance,
+                PixelColorBlendingMode.Lighten => LightenSrcOver,
-                PixelColorBlendingMode.Overlay => OverlaySrcOver.Instance,
+                PixelColorBlendingMode.Overlay => OverlaySrcOver,
-                PixelColorBlendingMode.HardLight => HardLightSrcOver.Instance,
+                PixelColorBlendingMode.HardLight => HardLightSrcOver,
-                _ => NormalSrcOver.Instance,
+                _ => NormalSrcOver,
             },
         };
     }

src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlender{TPixel}.cs

@@ -1,38 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-
-namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
-
-/// <summary>
-/// Provides the vector representation used to blend pixels that store associated alpha.
-/// </summary>
-/// <typeparam name="TPixel">The associated-alpha pixel format.</typeparam>
-internal abstract class AssociatedAlphaPixelBlender<TPixel> : PixelBlender<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
-{
-    private static readonly PixelOperations<TPixel> Operations = PixelOperations<TPixel>.Instance;
-
-    /// <inheritdoc />
-    protected override void ToBlendVector4<TPixelSource>(
-        Configuration configuration,
-        ReadOnlySpan<TPixelSource> source,
-        Span<Vector4> destination)
-    {
-        // Selecting the source representation once per row avoids a format check for every blended pixel.
-        PixelOperations<TPixelSource>.Instance.ToVector4(configuration, source, destination, PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply);
-    }
-
-    /// <inheritdoc />
-    protected override Vector4 ToBlendVector4(TPixel source) => source.ToAssociatedScaledVector4();
-
-    /// <inheritdoc />
-    protected override void FromBlendVector4(
-        Configuration configuration,
-        Span<Vector4> source,
-        Span<TPixel> destination)
-    {
-        Operations.FromVector4Destructive(configuration, source, destination, PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply);
-    }
-}

src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt

@@ -4,39 +4,19 @@
 #>
 <#@ template debug="false" hostspecific="false" language="C#" #>
 <#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
 <#@ output extension=".cs" #>
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // <auto-generated />
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
-/// <summary>
-/// Collection of Porter Duff alpha blending functions applying different composition models.
-/// </summary>
-/// <remarks>
-/// These functions are designed to be a general solution for all color cases,
-/// that is, they take in account the alpha value of both the backdrop
-/// and source, and there's no need to alpha-premultiply neither the backdrop
-/// nor the source.
-/// Note there are faster functions for when the backdrop color is known
-/// to be opaque
-/// </remarks>
-internal static class DefaultPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
-{
-
 <#
-var composers = new []{
+var composers = new []
+{
     "Src",
     "SrcAtop",
     "SrcOver",
@@ -51,7 +31,8 @@ var composers = new []{
     "Xor",
 };
 
-var blenders = new []{
+var blenders = new []
+{
     "Normal",
     "Multiply",
     "Add",
@@ -60,796 +41,69 @@ var blenders = new []{
     "Darken",
     "Lighten",
     "Overlay",
-    "HardLight"
+    "HardLight",
 };
-
+#>
-    foreach(var composer in composers) {
+/// <summary>
-    foreach(var blender in blenders) {
+/// Provides the straight-alpha equations consumed by the shared pixel-blending traversal.
-
+/// </summary>
-        var blender_composer= $"{blender}{composer}";
+internal static class DefaultPixelBlenderOperators
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
 #>
     /// <summary>
-    /// A pixel blender that implements the "<#= blender_composer#>" composition equation.
+    /// Applies the "<#= blenderComposer #>" straight-alpha composition equation.
     /// </summary>
-    public class <#= blender_composer#> : PixelBlender<TPixel>
+    public readonly struct <#= blenderComposer #> : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static <#=blender_composer#> Instance { get; } = new <#=blender_composer#>();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.<#=blender_composer#>(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-        }
-
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        public static bool IsAssociatedAlpha => false;
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-        {
+            => PorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-        {
+            => PorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-        {
+            => PorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
     }
 
 <#
     }
 }
+#>
+}
+
+/// <summary>
+/// Provides straight-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The destination pixel format.</typeparam>
+internal static class DefaultPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
+#>
+    /// <summary>
+    /// Gets the shared blender for the "<#= blenderComposer #>" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> <#= blenderComposer #> => PixelBlender<TPixel, DefaultPixelBlenderOperators.<#= blenderComposer #>>.Instance;
 
+<#
+    }
+}
 #>
 }

src/ImageSharp/PixelFormats/PixelBlenders/IPixelBlenderOperator.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
+
+/// <summary>
+/// Defines a Porter-Duff equation that can be applied by the shared pixel-blending traversal.
+/// </summary>
+internal interface IPixelBlenderOperator
+{
+    /// <summary>
+    /// Gets a value indicating whether pixel conversion uses associated-alpha vectors.
+    /// </summary>
+    public static abstract bool IsAssociatedAlpha { get; }
+
+    /// <summary>
+    /// Blends one pixel represented by four RGBA lanes.
+    /// </summary>
+    /// <param name="background">The background RGBA lanes.</param>
+    /// <param name="source">The source RGBA lanes.</param>
+    /// <param name="amount">The source opacity in the range 0 through 1.</param>
+    /// <returns>The blended RGBA lanes.</returns>
+    public static abstract Vector4 Invoke(Vector4 background, Vector4 source, float amount);
+
+    /// <summary>
+    /// Blends two pixels represented by two consecutive groups of four RGBA lanes.
+    /// </summary>
+    /// <param name="background">The background RGBA lanes.</param>
+    /// <param name="source">The source RGBA lanes.</param>
+    /// <param name="amount">The source opacity repeated across each pixel's four lanes.</param>
+    /// <returns>The blended RGBA lanes.</returns>
+    public static abstract Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount);
+
+    /// <summary>
+    /// Blends four pixels represented by four consecutive groups of four RGBA lanes.
+    /// </summary>
+    /// <param name="background">The background RGBA lanes.</param>
+    /// <param name="source">The source RGBA lanes.</param>
+    /// <param name="amount">The source opacity repeated across each pixel's four lanes.</param>
+    /// <returns>The blended RGBA lanes.</returns>
+    public static abstract Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount);
+}

src/ImageSharp/PixelFormats/PixelBlenders/PixelBlender{TPixel,TOperator}.cs

@@ -0,0 +1,586 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
+
+/// <summary>
+/// Applies a statically selected Porter-Duff equation across pixel-vector rows.
+/// </summary>
+/// <typeparam name="TPixel">The destination pixel format.</typeparam>
+/// <typeparam name="TOperator">The Porter-Duff equation.</typeparam>
+internal sealed class PixelBlender<TPixel, TOperator> : PixelBlender<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+    where TOperator : struct, IPixelBlenderOperator
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PixelBlender{TPixel, TOperator}"/> class.
+    /// </summary>
+    private PixelBlender()
+    {
+    }
+
+    /// <summary>
+    /// Gets the shared blender instance for this exact pixel and equation combination.
+    /// </summary>
+    // Keeping the singleton on the already-required closed blender type preserves per-mode lazy initialization
+    // without introducing another NativeAOT holder type or eagerly allocating every blender for a pixel format.
+    public static PixelBlender<TPixel> Instance { get; } = new PixelBlender<TPixel, TOperator>();
+
+    /// <inheritdoc />
+    public override TPixel Blend(TPixel background, TPixel source, float amount)
+    {
+        // The operator type uniquely determines the alpha representation. NativeAOT therefore needs only the
+        // pixel/operator closure, while the JIT can remove this static choice from the generated hot path.
+        Vector4 backgroundVector = TOperator.IsAssociatedAlpha
+            ? background.ToAssociatedScaledVector4()
+            : background.ToUnassociatedScaledVector4();
+        Vector4 sourceVector = TOperator.IsAssociatedAlpha
+            ? source.ToAssociatedScaledVector4()
+            : source.ToUnassociatedScaledVector4();
+
+        Vector4 result = TOperator.Invoke(backgroundVector, sourceVector, Numerics.Clamp(amount, 0, 1F));
+
+        return TOperator.IsAssociatedAlpha
+            ? TPixel.FromAssociatedScaledVector4(result)
+            : TPixel.FromUnassociatedScaledVector4(result);
+    }
+
+    /// <inheritdoc />
+    protected sealed override void ToBlendVector4<TPixelSource>(
+        Configuration configuration,
+        ReadOnlySpan<TPixelSource> source,
+        Span<Vector4> destination)
+    {
+        PixelConversionModifiers modifiers = TOperator.IsAssociatedAlpha
+            ? PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply
+            : PixelConversionModifiers.Scale | PixelConversionModifiers.UnPremultiply;
+
+        PixelOperations<TPixelSource>.Instance.ToVector4(configuration, source, destination, modifiers);
+    }
+
+    /// <inheritdoc />
+    protected sealed override Vector4 ToBlendVector4(TPixel source)
+        => TOperator.IsAssociatedAlpha
+            ? source.ToAssociatedScaledVector4()
+            : source.ToUnassociatedScaledVector4();
+
+    /// <inheritdoc />
+    protected sealed override void FromBlendVector4(
+        Configuration configuration,
+        Span<Vector4> source,
+        Span<TPixel> destination)
+    {
+        PixelConversionModifiers modifiers = TOperator.IsAssociatedAlpha
+            ? PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply
+            : PixelConversionModifiers.Scale | PixelConversionModifiers.UnPremultiply;
+
+        PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, source, destination, modifiers);
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+    {
+        // Public entry points validate the row lengths, so all three references can advance in lockstep.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            // A 512-bit register holds four complete RGBA pixels in [R,G,B,A] groups.
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), Unsafe.Add(ref sourceBase, i), amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            // A 256-bit register holds two complete RGBA pixels in [R,G,B,A] groups.
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), Unsafe.Add(ref sourceBase, i), amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        // Vector4 is both the scalar pixel representation and the portable SIMD fallback.
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(Unsafe.Add(ref backgroundRef, (uint)i), Unsafe.Add(ref sourceRef, (uint)i), amount);
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+    {
+        // Public entry points validate the row lengths, so the destination and background advance together.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            // Repeat one [R,G,B,A] source group four times to match the four background pixels.
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), sourceVector, amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            // Repeat one [R,G,B,A] source group twice to match the two background pixels.
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), sourceVector, amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        // The remaining pixel count is at most three after AVX-512 or one after AVX2.
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(Unsafe.Add(ref backgroundRef, (uint)i), source, amount);
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+    {
+        // Each amount belongs to one pixel and must be repeated across that pixel's four RGBA lanes.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                // Four scalar amounts become four contiguous [a,a,a,a] groups before clamping.
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), Unsafe.Add(ref sourceBase, i), amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                // Two scalar amounts become two contiguous [a,a,a,a] groups before clamping.
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), Unsafe.Add(ref sourceBase, i), amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(Unsafe.Add(ref backgroundRef, (uint)i), Unsafe.Add(ref sourceRef, (uint)i), Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+    {
+        // The source is invariant, while each background pixel has its own independently clamped amount.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), sourceVector, amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(Unsafe.Add(ref backgroundBase, i), sourceVector, amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(Unsafe.Add(ref backgroundRef, (uint)i), source, Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
+    {
+        // Coverage mixes the composed result back toward the original background, so it is fused into this pass.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(backgroundVector, Unsafe.Add(ref sourceBase, i), amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(backgroundVector, Unsafe.Add(ref sourceBase, i), amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(backgroundPixel, Unsafe.Add(ref sourceRef, (uint)i), amount);
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(backgroundPixel, blended, Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
+    {
+        // The constant source is expanded once per selected width and reused for the complete row.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(backgroundPixel, source, amount);
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(backgroundPixel, blended, Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
+    {
+        // Amount controls composition while coverage controls the final mix with the untouched background.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(backgroundVector, Unsafe.Add(ref sourceBase, i), amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(backgroundVector, Unsafe.Add(ref sourceBase, i), amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(backgroundPixel, Unsafe.Add(ref sourceRef, (uint)i), Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(backgroundPixel, blended, Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
+    {
+        // The invariant source is expanded once; only amount and coverage are gathered for each vector batch.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Vector512.IsHardwareAccelerated && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Vector256.IsHardwareAccelerated && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(backgroundVector, blended, coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(backgroundPixel, source, Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(backgroundPixel, blended, Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <summary>
+    /// Repeats one RGBA pixel twice to fill a 256-bit register.
+    /// </summary>
+    /// <param name="pixel">The pixel represented by ordered RGBA lanes.</param>
+    /// <returns>Two consecutive copies of the pixel.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> CreateVector256(Vector4 pixel)
+        => Vector256.Create(pixel.X, pixel.Y, pixel.Z, pixel.W, pixel.X, pixel.Y, pixel.Z, pixel.W);
+
+    /// <summary>
+    /// Repeats one RGBA pixel four times to fill a 512-bit register.
+    /// </summary>
+    /// <param name="pixel">The pixel represented by ordered RGBA lanes.</param>
+    /// <returns>Four consecutive copies of the pixel.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> CreateVector512(Vector4 pixel)
+        => Vector512.Create(pixel.X, pixel.Y, pixel.Z, pixel.W, pixel.X, pixel.Y, pixel.Z, pixel.W, pixel.X, pixel.Y, pixel.Z, pixel.W, pixel.X, pixel.Y, pixel.Z, pixel.W);
+
+    /// <summary>
+    /// Expands and clamps two per-pixel scalar values for two packed RGBA pixels.
+    /// </summary>
+    /// <param name="values">The first of two contiguous scalar values.</param>
+    /// <returns>Two consecutive groups containing one clamped value in each group's four lanes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> CreateClampedVector256(ref float values)
+    {
+        Vector256<float> result = Vector256.Create(Vector128.Create(values), Vector128.Create(Unsafe.Add(ref values, 1)));
+
+        // Amount and coverage share the same public 0..1 contract and therefore the same packed clamp.
+        return Vector256.Min(Vector256.Max(Vector256<float>.Zero, result), Vector256.Create(1F));
+    }
+
+    /// <summary>
+    /// Expands and clamps four per-pixel scalar values for four packed RGBA pixels.
+    /// </summary>
+    /// <param name="values">The first of four contiguous scalar values.</param>
+    /// <returns>Four consecutive groups containing one clamped value in each group's four lanes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> CreateClampedVector512(ref float values)
+    {
+        Vector512<float> result = Vector512.Create(values, values, values, values, Unsafe.Add(ref values, 1), Unsafe.Add(ref values, 1), Unsafe.Add(ref values, 1), Unsafe.Add(ref values, 1), Unsafe.Add(ref values, 2), Unsafe.Add(ref values, 2), Unsafe.Add(ref values, 2), Unsafe.Add(ref values, 2), Unsafe.Add(ref values, 3), Unsafe.Add(ref values, 3), Unsafe.Add(ref values, 3), Unsafe.Add(ref values, 3));
+
+        // Amount and coverage share the same public 0..1 contract and therefore the same packed clamp.
+        return Vector512.Min(Vector512.Max(Vector512<float>.Zero, result), Vector512.Create(1F));
+    }
+}

src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs

@@ -34,182 +34,182 @@ public partial class PixelOperations<TPixel>
             case PixelAlphaCompositionMode.Clear:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyClear.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyClear;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddClear.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddClear;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractClear.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractClear;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenClear.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenClear;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenClear.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenClear;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenClear.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenClear;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayClear.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayClear;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightClear.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightClear;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalClear.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalClear;
                 }
 
             case PixelAlphaCompositionMode.Xor:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyXor.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyXor;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddXor.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddXor;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractXor.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractXor;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenXor.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenXor;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenXor.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenXor;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenXor.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenXor;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayXor.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayXor;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightXor.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightXor;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalXor.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalXor;
                 }
 
             case PixelAlphaCompositionMode.Src:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrc.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrc;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrc.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrc;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrc.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrc;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrc.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrc;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrc.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrc;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrc.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrc;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrc.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrc;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrc.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrc;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalSrc.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalSrc;
                 }
 
             case PixelAlphaCompositionMode.SrcAtop:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcAtop.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcAtop;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcAtop.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcAtop;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcAtop.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcAtop;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcAtop.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcAtop;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcAtop.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcAtop;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcAtop.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcAtop;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcAtop.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcAtop;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcAtop.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcAtop;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalSrcAtop.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalSrcAtop;
                 }
 
             case PixelAlphaCompositionMode.SrcIn:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcIn.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcIn;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcIn.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcIn;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcIn.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcIn;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcIn.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcIn;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcIn.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcIn;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcIn.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcIn;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcIn.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcIn;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcIn.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcIn;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalSrcIn.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalSrcIn;
                 }
 
             case PixelAlphaCompositionMode.SrcOut:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcOut.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcOut;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcOut.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcOut;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcOut.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcOut;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcOut.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcOut;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcOut.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcOut;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcOut.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcOut;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcOut.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcOut;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcOut.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcOut;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalSrcOut.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalSrcOut;
                 }
 
             case PixelAlphaCompositionMode.Dest:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDest.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDest;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDest.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDest;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDest.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDest;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDest.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDest;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDest.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDest;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDest.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDest;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDest.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDest;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDest.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDest;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalDest.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalDest;
                 }
 
             case PixelAlphaCompositionMode.DestAtop:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestAtop.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestAtop;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestAtop.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestAtop;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestAtop.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestAtop;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestAtop.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestAtop;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestAtop.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestAtop;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestAtop.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestAtop;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestAtop.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestAtop;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestAtop.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestAtop;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalDestAtop.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalDestAtop;
                 }
 
             case PixelAlphaCompositionMode.DestIn:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestIn.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestIn;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestIn.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestIn;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestIn.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestIn;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestIn.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestIn;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestIn.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestIn;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestIn.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestIn;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestIn.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestIn;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestIn.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestIn;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalDestIn.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalDestIn;
                 }
 
             case PixelAlphaCompositionMode.DestOut:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestOut.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestOut;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestOut.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestOut;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestOut.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestOut;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestOut.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestOut;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestOut.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestOut;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestOut.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestOut;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestOut.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestOut;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestOut.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestOut;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalDestOut.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalDestOut;
                 }
 
             case PixelAlphaCompositionMode.DestOver:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestOver.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyDestOver;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestOver.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddDestOver;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestOver.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractDestOver;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestOver.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenDestOver;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestOver.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenDestOver;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestOver.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestOver;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestOver.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestOver;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestOver.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestOver;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalDestOver.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalDestOver;
                 }
 
             case PixelAlphaCompositionMode.SrcOver:
             default:
                 switch (colorMode)
                 {
-                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcOver.Instance;
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcOver;
-                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcOver.Instance;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcOver;
-                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcOver.Instance;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcOver;
-                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcOver.Instance;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcOver;
-                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcOver.Instance;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcOver;
-                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcOver.Instance;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcOver;
-                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcOver.Instance;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcOver;
-                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcOver.Instance;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcOver;
                     case PixelColorBlendingMode.Normal:
-                    default: return DefaultPixelBlenders<TPixel>.NormalSrcOver.Instance;
+                    default: return DefaultPixelBlenders<TPixel>.NormalSrcOver;
                 }
         }
     }

src/ImageSharp/PixelFormats/Utils/PixelConverter.cs

@@ -33,7 +33,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToArgb32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<WXYZShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<WXYZShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -44,7 +44,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgra32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<ZYXWShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<ZYXWShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -55,7 +55,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToAbgr32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -66,7 +66,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgb24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3<XYZWShuffle4Slice3>(source, dest, default);
+            => SimdUtils.Shuffle4Slice3<XYZWShuffle4Slice3>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -77,7 +77,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgr24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3(source, dest, new DefaultShuffle4Slice3(SimdUtils.Shuffle.MMShuffle3012));
+            => SimdUtils.Shuffle4Slice3<ZYXWShuffle4Slice3>(source, dest);
     }
 
     /// <summary>
@@ -96,7 +96,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgba32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<YZWXShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<YZWXShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -107,7 +107,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgra32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -118,7 +118,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToAbgr32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<XWZYShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<XWZYShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -129,7 +129,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgb24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3(source, dest, new DefaultShuffle4Slice3(SimdUtils.Shuffle.MMShuffle0321));
+            => SimdUtils.Shuffle4Slice3<YZWXShuffle4Slice3>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -140,7 +140,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgr24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3(source, dest, new DefaultShuffle4Slice3(SimdUtils.Shuffle.MMShuffle0123));
+            => SimdUtils.Shuffle4Slice3<WZYXShuffle4Slice3>(source, dest);
     }
 
     /// <summary>
@@ -159,7 +159,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToArgb32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -170,7 +170,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgba32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<ZYXWShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<ZYXWShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -181,7 +181,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToAbgr32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<WXYZShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<WXYZShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -192,7 +192,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgb24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3(source, dest, new DefaultShuffle4Slice3(SimdUtils.Shuffle.MMShuffle3012));
+            => SimdUtils.Shuffle4Slice3<ZYXWShuffle4Slice3>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -203,7 +203,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgr24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3<XYZWShuffle4Slice3>(source, dest, default);
+            => SimdUtils.Shuffle4Slice3<XYZWShuffle4Slice3>(source, dest);
     }
 
     /// <summary>
@@ -222,7 +222,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToArgb32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<XWZYShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<XWZYShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -233,7 +233,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgba32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<WZYXShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -244,7 +244,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgra32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4<YZWXShuffle4>(source, dest, default);
+            => SimdUtils.Shuffle4<YZWXShuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -255,7 +255,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgb24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3(source, dest, new DefaultShuffle4Slice3(SimdUtils.Shuffle.MMShuffle0123));
+            => SimdUtils.Shuffle4Slice3<WZYXShuffle4Slice3>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -266,7 +266,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgr24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle4Slice3(source, dest, new DefaultShuffle4Slice3(SimdUtils.Shuffle.MMShuffle0321));
+            => SimdUtils.Shuffle4Slice3<YZWXShuffle4Slice3>(source, dest);
     }
 
     /// <summary>
@@ -285,7 +285,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgba32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4<XYZWPad3Shuffle4>(source, dest, default);
+            => SimdUtils.Pad3Shuffle4<XYZWPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -296,7 +296,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToArgb32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4(source, dest, new DefaultPad3Shuffle4(SimdUtils.Shuffle.MMShuffle2103));
+            => SimdUtils.Pad3Shuffle4<WXYZPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -307,7 +307,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgra32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4(source, dest, new DefaultPad3Shuffle4(SimdUtils.Shuffle.MMShuffle3012));
+            => SimdUtils.Pad3Shuffle4<ZYXWPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -318,7 +318,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToAbgr32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4(source, dest, new DefaultPad3Shuffle4(SimdUtils.Shuffle.MMShuffle0123));
+            => SimdUtils.Pad3Shuffle4<WZYXPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -329,7 +329,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgr24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle3(source, dest, new DefaultShuffle3(SimdUtils.Shuffle.MMShuffle3012));
+            => SimdUtils.Shuffle3<ZYXShuffle3>(source, dest);
     }
 
     /// <summary>
@@ -348,7 +348,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToArgb32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4(source, dest, new DefaultPad3Shuffle4(SimdUtils.Shuffle.MMShuffle0123));
+            => SimdUtils.Pad3Shuffle4<WZYXPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -359,7 +359,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgba32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4(source, dest, new DefaultPad3Shuffle4(SimdUtils.Shuffle.MMShuffle3012));
+            => SimdUtils.Pad3Shuffle4<ZYXWPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -370,7 +370,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToBgra32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4<XYZWPad3Shuffle4>(source, dest, default);
+            => SimdUtils.Pad3Shuffle4<XYZWPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -381,7 +381,7 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToAbgr32(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Pad3Shuffle4(source, dest, new DefaultPad3Shuffle4(SimdUtils.Shuffle.MMShuffle2103));
+            => SimdUtils.Pad3Shuffle4<WXYZPad3Shuffle4>(source, dest);
 
         /// <summary>
         /// Converts a <see cref="ReadOnlySpan{Byte}"/> representing a collection of
@@ -392,6 +392,6 @@ internal static class PixelConverter
         /// <param name="dest">The destination span of bytes.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToRgb24(ReadOnlySpan<byte> source, Span<byte> dest)
-            => SimdUtils.Shuffle3(source, dest, new DefaultShuffle3(SimdUtils.Shuffle.MMShuffle3012));
+            => SimdUtils.Shuffle3<ZYXShuffle3>(source, dest);
     }
 }

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

@@ -16,60 +16,8 @@ internal static partial class Vector4Converters
     /// <param name="vectors">The vectors to transform in place.</param>
     /// <param name="multiplier">The component-wise multiplier.</param>
     /// <param name="offset">The component-wise offset applied after multiplication.</param>
-    internal static void MultiplyThenAdd(Span<Vector4> vectors, Vector4 multiplier, Vector4 offset)
+    public static void MultiplyThenAdd(Span<Vector4> vectors, Vector4 multiplier, Vector4 offset)
-    {
+        => Apply(vectors, new MultiplyThenAddOperator(multiplier, offset));
-        ref Vector4 vectorBase = ref MemoryMarshal.GetReference(vectors);
-        int index = 0;
-
-        if (Vector512.IsHardwareAccelerated)
-        {
-            int vectorsPerVector = Vector512<float>.Count / Vector128<float>.Count;
-            Vector256<float> multiplier256 = Vector256.Create(multiplier.AsVector128(), multiplier.AsVector128());
-            Vector256<float> offset256 = Vector256.Create(offset.AsVector128(), offset.AsVector128());
-            Vector512<float> multiplier512 = Vector512.Create(multiplier256, multiplier256);
-            Vector512<float> offset512 = Vector512.Create(offset256, offset256);
-
-            for (; index <= vectors.Length - vectorsPerVector; index += vectorsPerVector)
-            {
-                ref Vector512<float> vector = ref Unsafe.As<Vector4, Vector512<float>>(ref Unsafe.Add(ref vectorBase, (uint)index));
-                vector = (vector * multiplier512) + offset512;
-            }
-        }
-
-        if (Vector256.IsHardwareAccelerated)
-        {
-            int vectorsPerVector = Vector256<float>.Count / Vector128<float>.Count;
-            Vector256<float> multiplier256 = Vector256.Create(multiplier.AsVector128(), multiplier.AsVector128());
-            Vector256<float> offset256 = Vector256.Create(offset.AsVector128(), offset.AsVector128());
-
-            for (; index <= vectors.Length - vectorsPerVector; index += vectorsPerVector)
-            {
-                ref Vector256<float> vector = ref Unsafe.As<Vector4, Vector256<float>>(ref Unsafe.Add(ref vectorBase, (uint)index));
-                vector = (vector * multiplier256) + offset256;
-            }
-        }
-
-        if (Vector128.IsHardwareAccelerated)
-        {
-            Vector128<float> multiplier128 = multiplier.AsVector128();
-            Vector128<float> offset128 = offset.AsVector128();
-
-            for (; index < vectors.Length; index++)
-            {
-                ref Vector128<float> vector = ref Unsafe.As<Vector4, Vector128<float>>(ref Unsafe.Add(ref vectorBase, (uint)index));
-                vector = (vector * multiplier128) + offset128;
-            }
-
-            return;
-        }
-
-        // The scalar fallback retains the same multiply-then-add order as the SIMD paths and the per-pixel contracts.
-        for (; index < vectors.Length; index++)
-        {
-            ref Vector4 vector = ref Unsafe.Add(ref vectorBase, (uint)index);
-            vector = (vector * multiplier) + offset;
-        }
-    }
 
     /// <summary>
     /// Adds the corresponding offset component and then divides each vector component by its divisor.
@@ -77,58 +25,72 @@ internal static partial class Vector4Converters
     /// <param name="vectors">The vectors to transform in place.</param>
     /// <param name="offset">The component-wise offset applied before division.</param>
     /// <param name="divisor">The component-wise divisor.</param>
-    internal static void AddThenDivide(Span<Vector4> vectors, Vector4 offset, Vector4 divisor)
+    public static void AddThenDivide(Span<Vector4> vectors, Vector4 offset, Vector4 divisor)
+        => Apply(vectors, new AddThenDivideOperator(offset, divisor));
+
+    /// <summary>
+    /// Applies a stateful component transform to a vector buffer in place.
+    /// </summary>
+    /// <typeparam name="TOperator">The transform selected for this closed traversal.</typeparam>
+    /// <param name="vectors">The vectors to transform.</param>
+    /// <param name="transform">The transform and its component-wise state.</param>
+    // Closing and inlining the traversal lets the JIT devirtualize every Invoke call,
+    // specialize the active hardware-width branches, and discard unused operator state.
+    [MethodImpl(InliningOptions.AlwaysInline)]
+    private static void Apply<TOperator>(Span<Vector4> vectors, TOperator transform)
+        where TOperator : struct, IStatefulVector4Operator
     {
         ref Vector4 vectorBase = ref MemoryMarshal.GetReference(vectors);
         int index = 0;
 
+        // A Vector4 is one complete pixel. Descending register widths therefore consume groups
+        // of four, two, and one pixels without splitting a pixel across traversal boundaries.
         if (Vector512.IsHardwareAccelerated)
         {
-            int vectorsPerVector = Vector512<float>.Count / Vector128<float>.Count;
+            int vectorsPerRegister = Vector512<float>.Count / Vector128<float>.Count;
-            Vector256<float> offset256 = Vector256.Create(offset.AsVector128(), offset.AsVector128());
+            int oneRegisterFromEnd = vectors.Length - vectorsPerRegister;
-            Vector256<float> divisor256 = Vector256.Create(divisor.AsVector128(), divisor.AsVector128());
-            Vector512<float> offset512 = Vector512.Create(offset256, offset256);
-            Vector512<float> divisor512 = Vector512.Create(divisor256, divisor256);
 
-            for (; index <= vectors.Length - vectorsPerVector; index += vectorsPerVector)
+            for (; index <= oneRegisterFromEnd; index += vectorsPerRegister)
             {
                 ref Vector512<float> vector = ref Unsafe.As<Vector4, Vector512<float>>(ref Unsafe.Add(ref vectorBase, (uint)index));
-                vector = (vector + offset512) / divisor512;
+
+                vector = transform.Invoke(vector);
             }
         }
 
         if (Vector256.IsHardwareAccelerated)
         {
-            int vectorsPerVector = Vector256<float>.Count / Vector128<float>.Count;
+            int vectorsPerRegister = Vector256<float>.Count / Vector128<float>.Count;
-            Vector256<float> offset256 = Vector256.Create(offset.AsVector128(), offset.AsVector128());
+            int oneRegisterFromEnd = vectors.Length - vectorsPerRegister;
-            Vector256<float> divisor256 = Vector256.Create(divisor.AsVector128(), divisor.AsVector128());
 
-            for (; index <= vectors.Length - vectorsPerVector; index += vectorsPerVector)
+            for (; index <= oneRegisterFromEnd; index += vectorsPerRegister)
             {
                 ref Vector256<float> vector = ref Unsafe.As<Vector4, Vector256<float>>(ref Unsafe.Add(ref vectorBase, (uint)index));
-                vector = (vector + offset256) / divisor256;
+
+                vector = transform.Invoke(vector);
             }
         }
 
         if (Vector128.IsHardwareAccelerated)
         {
-            Vector128<float> offset128 = offset.AsVector128();
+            // Vector128<float> and Vector4 have the same four-lane layout, so this stage
-            Vector128<float> divisor128 = divisor.AsVector128();
+            // consumes every remaining complete pixel and leaves no scalar remainder.
-
             for (; index < vectors.Length; index++)
             {
                 ref Vector128<float> vector = ref Unsafe.As<Vector4, Vector128<float>>(ref Unsafe.Add(ref vectorBase, (uint)index));
-                vector = (vector + offset128) / divisor128;
+
+                vector = transform.Invoke(vector);
             }
 
             return;
         }
 
-        // Native-to-scaled conversion deliberately adds before dividing to match each format's scalar conversion order.
+        // Vector4 retains the same component order and expression ordering when hardware
+        // intrinsics are unavailable, preserving the format-specific conversion contract.
         for (; index < vectors.Length; index++)
         {
             ref Vector4 vector = ref Unsafe.Add(ref vectorBase, (uint)index);
-            vector = (vector + offset) / divisor;
+            vector = transform.Invoke(vector);
         }
     }
 }

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

@@ -0,0 +1,147 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.PixelFormats.Utils;
+
+internal static partial class Vector4Converters
+{
+    /// <summary>
+    /// Defines a stateful component transform for each register width used by the shared traversal.
+    /// </summary>
+    private interface IStatefulVector4Operator
+    {
+        /// <summary>
+        /// Transforms one pixel represented by four components.
+        /// </summary>
+        /// <param name="source">The source components.</param>
+        /// <returns>The transformed components.</returns>
+        public Vector4 Invoke(Vector4 source);
+
+        /// <summary>
+        /// Transforms one pixel represented by the four single-precision lanes in a 128-bit register.
+        /// </summary>
+        /// <param name="source">The source components.</param>
+        /// <returns>The transformed components.</returns>
+        public Vector128<float> Invoke(Vector128<float> source);
+
+        /// <summary>
+        /// Transforms two pixels represented by the eight single-precision lanes in a 256-bit register.
+        /// </summary>
+        /// <param name="source">The source components.</param>
+        /// <returns>The transformed components.</returns>
+        public Vector256<float> Invoke(Vector256<float> source);
+
+        /// <summary>
+        /// Transforms four pixels represented by the sixteen single-precision lanes in a 512-bit register.
+        /// </summary>
+        /// <param name="source">The source components.</param>
+        /// <returns>The transformed components.</returns>
+        public Vector512<float> Invoke(Vector512<float> source);
+    }
+
+    /// <summary>
+    /// Carries the component state for a multiply-then-add transform.
+    /// </summary>
+    private readonly struct MultiplyThenAddOperator : IStatefulVector4Operator
+    {
+        private readonly Vector512<float> multiplier;
+        private readonly Vector512<float> offset;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MultiplyThenAddOperator"/> struct.
+        /// </summary>
+        /// <param name="multiplier">The component-wise multiplier.</param>
+        /// <param name="offset">The component-wise offset applied after multiplication.</param>
+        public MultiplyThenAddOperator(Vector4 multiplier, Vector4 offset)
+        {
+            Vector128<float> multiplier128 = multiplier.AsVector128();
+            Vector128<float> offset128 = offset.AsVector128();
+            Vector256<float> multiplier256 = Vector256.Create(multiplier128, multiplier128);
+            Vector256<float> offset256 = Vector256.Create(offset128, offset128);
+
+            // Expanding the invariant state once prevents the width-specific Invoke methods
+            // from rebuilding identical lane groups for every vector processed by the loop.
+            this.multiplier = Vector512.Create(multiplier256, multiplier256);
+            this.offset = Vector512.Create(offset256, offset256);
+        }
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector4 Invoke(Vector4 source)
+        {
+            Vector128<float> result = (source.AsVector128() * this.multiplier.GetLower().GetLower()) + this.offset.GetLower().GetLower();
+
+            return result.AsVector4();
+        }
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector128<float> Invoke(Vector128<float> source)
+            => (source * this.multiplier.GetLower().GetLower()) + this.offset.GetLower().GetLower();
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector256<float> Invoke(Vector256<float> source)
+            => (source * this.multiplier.GetLower()) + this.offset.GetLower();
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector512<float> Invoke(Vector512<float> source)
+            => (source * this.multiplier) + this.offset;
+    }
+
+    /// <summary>
+    /// Carries the component state for an add-then-divide transform.
+    /// </summary>
+    private readonly struct AddThenDivideOperator : IStatefulVector4Operator
+    {
+        private readonly Vector512<float> offset;
+        private readonly Vector512<float> divisor;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AddThenDivideOperator"/> struct.
+        /// </summary>
+        /// <param name="offset">The component-wise offset applied before division.</param>
+        /// <param name="divisor">The component-wise divisor.</param>
+        public AddThenDivideOperator(Vector4 offset, Vector4 divisor)
+        {
+            Vector128<float> offset128 = offset.AsVector128();
+            Vector128<float> divisor128 = divisor.AsVector128();
+            Vector256<float> offset256 = Vector256.Create(offset128, offset128);
+            Vector256<float> divisor256 = Vector256.Create(divisor128, divisor128);
+
+            // All register widths consume prefixes of this repeated four-pixel state,
+            // so one construction serves the wide loop and every narrower remainder.
+            this.offset = Vector512.Create(offset256, offset256);
+            this.divisor = Vector512.Create(divisor256, divisor256);
+        }
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector4 Invoke(Vector4 source)
+        {
+            Vector128<float> result = (source.AsVector128() + this.offset.GetLower().GetLower()) / this.divisor.GetLower().GetLower();
+
+            return result.AsVector4();
+        }
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector128<float> Invoke(Vector128<float> source)
+            => (source + this.offset.GetLower().GetLower()) / this.divisor.GetLower().GetLower();
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector256<float> Invoke(Vector256<float> source)
+            => (source + this.offset.GetLower()) / this.divisor.GetLower();
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector512<float> Invoke(Vector512<float> source)
+            => (source + this.offset) / this.divisor;
+    }
+}

src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessorHelpers.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Diagnostics.CodeAnalysis;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Convolution;
 
@@ -36,11 +37,8 @@ internal static class ConvolutionProcessorHelpers
             kernel[i] = gx;
         }
 
-        // Normalize kernel so that the sum of all weights equals 1
+        // Divide every weight by the accumulated Gaussian sum so the kernel has unit response.
-        for (int i = 0; i < size; i++)
+        TensorPrimitives_.Divide<float>(kernel, sum, kernel);
-        {
-            kernel[i] /= sum;
-        }
 
         return kernel;
     }
@@ -68,25 +66,15 @@ internal static class ConvolutionProcessorHelpers
 
         // Invert the kernel for sharpening.
         int midpointRounded = (int)midpoint;
-        for (int i = 0; i < size; i++)
+        float midpointValue = kernel[midpointRounded];
-        {
+        TensorPrimitives_.Negate<float>(kernel, kernel);
-            if (i == midpointRounded)
-            {
-                // Calculate central value
-                kernel[i] = (2F * sum) - kernel[i];
-            }
-            else
-            {
-                // invert value
-                kernel[i] = -kernel[i];
-            }
-        }
 
-        // Normalize kernel so that the sum of all weights equals 1
+        // The sharpening kernel negates every Gaussian weight except its center. Restore that original
-        for (int i = 0; i < size; i++)
+        // center while adding twice the Gaussian sum so the complete kernel retains unit response.
-        {
+        kernel[midpointRounded] = (2F * sum) - midpointValue;
-            kernel[i] /= sum;
+
-        }
+        // Sharpening changes signs but preserves the Gaussian sum, so the same divisor produces unit response.
+        TensorPrimitives_.Divide<float>(kernel, sum, kernel);
 
         return kernel;
     }

src/ImageSharp/Processing/Processors/Convolution/Parameters/BokehBlurKernelDataProvider.cs

@@ -5,6 +5,7 @@ using System.Collections.Concurrent;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Convolution.Parameters;
 
@@ -209,13 +210,11 @@ internal static class BokehBlurKernelDataProvider
         for (int i = 0; i < kernelsSpan.Length; i++)
         {
             ref Complex64[] kernelsRef = ref Unsafe.Add(ref baseKernelsRef, (uint)i);
-            int length = kernelsRef.Length;
-            ref Complex64 valueRef = ref MemoryMarshal.GetArrayDataReference(kernelsRef);
 
-            for (int j = 0; j < length; j++)
+            // Complex64 stores each value as adjacent real and imaginary floats. Multiplying that flattened
-            {
+            // float span scales both parts independently, which is exactly complex multiplication by a real scalar.
-                Unsafe.Add(ref valueRef, (uint)j) *= scalar;
+            Span<float> values = MemoryMarshal.Cast<Complex64, float>(kernelsRef.AsSpan());
-            }
+            TensorPrimitives_.Multiply(values, scalar, values);
         }
     }
 }

src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor{TPixel}.cs

@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Normalization;
@@ -115,10 +116,7 @@ internal abstract class HistogramEqualizationProcessor<TPixel> : ImageProcessor<
         int addToEachBin = sumOverClip > 0 ? (int)MathF.Floor(sumOverClip / this.luminanceLevelsFloat) : 0;
         if (addToEachBin > 0)
         {
-            for (nuint i = 0; i < (uint)histogram.Length; i++)
+            TensorPrimitives_.Add(histogram, addToEachBin, histogram);
-            {
-                Unsafe.Add(ref histogramBase, i) += addToEachBin;
-            }
         }
 
         int residual = sumOverClip - (addToEachBin * this.LuminanceLevels);

tests/ImageSharp.Benchmarks/Bulk/Pad3Shuffle4Channel.cs

@@ -8,7 +8,6 @@ namespace SixLabors.ImageSharp.Benchmarks.Bulk;
 [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
 public class Pad3Shuffle4Channel
 {
-    private static readonly DefaultPad3Shuffle4 Control = new(SimdUtils.Shuffle.MMShuffle1032);
     private byte[] source;
     private byte[] destination;
 
@@ -25,11 +24,11 @@ public class Pad3Shuffle4Channel
 
     [Benchmark]
     public void Pad3Shuffle4()
-        => SimdUtils.Pad3Shuffle4(this.source, this.destination, Control);
+        => SimdUtils.Pad3Shuffle4<WZYXPad3Shuffle4>(this.source, this.destination);
 
     [Benchmark]
     public void Pad3Shuffle4FastFallback()
-        => SimdUtils.Pad3Shuffle4(this.source, this.destination, default(XYZWPad3Shuffle4));
+        => SimdUtils.Pad3Shuffle4<XYZWPad3Shuffle4>(this.source, this.destination);
 }
 
 // 2020-10-30

tests/ImageSharp.Benchmarks/Bulk/Shuffle3Channel.cs

@@ -8,7 +8,6 @@ namespace SixLabors.ImageSharp.Benchmarks.Bulk;
 [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
 public class Shuffle3Channel
 {
-    private static readonly DefaultShuffle3 Control = new(SimdUtils.Shuffle.MMShuffle3102);
     private byte[] source;
     private byte[] destination;
 
@@ -25,7 +24,7 @@ public class Shuffle3Channel
 
     [Benchmark]
     public void Shuffle3()
-        => SimdUtils.Shuffle3(this.source, this.destination, Control);
+        => SimdUtils.Shuffle3<ZYXShuffle3>(this.source, this.destination);
 }
 
 // 2020-11-02

tests/ImageSharp.Benchmarks/Bulk/Shuffle4Slice3Channel.cs

@@ -8,7 +8,6 @@ namespace SixLabors.ImageSharp.Benchmarks.Bulk;
 [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
 public class Shuffle4Slice3Channel
 {
-    private static readonly DefaultShuffle4Slice3 Control = new(SimdUtils.Shuffle.MMShuffle1032);
     private byte[] source;
     private byte[] destination;
 
@@ -25,11 +24,11 @@ public class Shuffle4Slice3Channel
 
     [Benchmark]
     public void Shuffle4Slice3()
-        => SimdUtils.Shuffle4Slice3(this.source, this.destination, Control);
+        => SimdUtils.Shuffle4Slice3<WZYXShuffle4Slice3>(this.source, this.destination);
 
     [Benchmark]
     public void Shuffle4Slice3FastFallback()
-        => SimdUtils.Shuffle4Slice3(this.source, this.destination, default(XYZWShuffle4Slice3));
+        => SimdUtils.Shuffle4Slice3<XYZWShuffle4Slice3>(this.source, this.destination);
 }
 
 // 2020-10-29

tests/ImageSharp.Benchmarks/Bulk/ShuffleByte4Channel.cs

@@ -24,7 +24,7 @@ public class ShuffleByte4Channel
 
     [Benchmark]
     public void Shuffle4Channel()
-        => SimdUtils.Shuffle4<WXYZShuffle4>(this.source, this.destination, default);
+        => SimdUtils.Shuffle4<WXYZShuffle4>(this.source, this.destination);
 }
 
 // 2020-10-29

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/CmykColorConversion.cs

@@ -9,40 +9,24 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
 [Config(typeof(Config.Short))]
 public class CmykColorConversion : ColorConversionBenchmark
 {
+    private readonly JpegColorConverterBase converter = JpegColorConverterBase.GetConverter(JpegColorSpace.Cmyk, 8);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CmykColorConversion"/> class.
+    /// </summary>
     public CmykColorConversion()
         : base(4)
     {
     }
 
-    [Benchmark(Baseline = true)]
+    /// <summary>
-    public void Scalar()
+    /// Converts one CMYK component row through the adaptive operator traversal.
-    {
+    /// </summary>
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.CmykScalar(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector128()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.CmykVector128(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector256()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.CmykVector256(8).ConvertToRgbInPlace(values);
-    }
-
     [Benchmark]
-    public void SimdVector512()
+    public void ConvertToRgb()
     {
         JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.CmykVector512(8).ConvertToRgbInPlace(values);
+        this.converter.ConvertToRgbInPlace(values);
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/ColorConversionBenchmark.cs

@@ -51,6 +51,7 @@ public abstract class ColorConversionBenchmark
 
             // no need to dispose when buffer is not array owner
             buffers[i] = Configuration.Default.MemoryAllocator.Allocate2D<float>(values.Length, 1);
+            values.CopyTo(buffers[i].DangerousGetRowSpan(0));
         }
 
         return buffers;

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/GrayscaleColorConversion.cs

@@ -9,40 +9,24 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
 [Config(typeof(Config.Short))]
 public class GrayScaleColorConversion : ColorConversionBenchmark
 {
+    private readonly JpegColorConverterBase converter = JpegColorConverterBase.GetConverter(JpegColorSpace.Grayscale, 8);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GrayScaleColorConversion"/> class.
+    /// </summary>
     public GrayScaleColorConversion()
         : base(1)
     {
     }
 
-    [Benchmark(Baseline = true)]
+    /// <summary>
-    public void Scalar()
+    /// Converts one grayscale component row through the adaptive operator traversal.
-    {
+    /// </summary>
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.GrayScaleScalar(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector128()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.GrayScaleVector128(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector256()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.GrayScaleVector256(8).ConvertToRgbInPlace(values);
-    }
-
     [Benchmark]
-    public void SimdVector512()
+    public void ConvertToRgb()
     {
         JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.GrayScaleVector512(8).ConvertToRgbInPlace(values);
+        this.converter.ConvertToRgbInPlace(values);
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/JpegColorPacking.cs

@@ -0,0 +1,178 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+/// <summary>
+/// Compares the previous scalar JPEG packing loops with the SIMD register-transpose implementation.
+/// </summary>
+[Config(typeof(Config.Short))]
+[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+[CategoriesColumn]
+public class JpegColorPacking
+{
+    private const float MaximumValue = 255F;
+    private const float Scale = 1F / MaximumValue;
+
+    private float[] x = null!;
+    private float[] y = null!;
+    private float[] z = null!;
+    private float[] w = null!;
+    private Vector3[] packed3 = null!;
+    private float[] destination3 = null!;
+    private float[] destination4 = null!;
+
+    /// <summary>
+    /// Gets or sets the number of pixels transformed by each benchmark invocation.
+    /// </summary>
+    [Params(128, 1024, 4096)]
+    public int Length { get; set; }
+
+    /// <summary>
+    /// Creates deterministic source and destination buffers outside the measured operations.
+    /// </summary>
+    [GlobalSetup]
+    public void Setup()
+    {
+        this.x = CreateSamples(this.Length, 1);
+        this.y = CreateSamples(this.Length, 2);
+        this.z = CreateSamples(this.Length, 3);
+        this.w = CreateSamples(this.Length, 4);
+        this.packed3 = new Vector3[this.Length];
+        this.destination3 = new float[this.Length * 3];
+        this.destination4 = new float[this.Length * 4];
+
+        for (int i = 0; i < this.packed3.Length; i++)
+        {
+            this.packed3[i] = new Vector3(this.x[i], this.y[i], this.z[i]);
+        }
+    }
+
+    /// <summary>
+    /// Measures the previous scalar three-plane normalization and interleave loop.
+    /// </summary>
+    /// <returns>The last destination value, keeping the writes observable.</returns>
+    [Benchmark(Baseline = true)]
+    [BenchmarkCategory("Pack3")]
+    public float PackedNormalizeInterleave3Scalar()
+    {
+        JpegColorPackingScalar.PackedNormalizeInterleave3(this.x, this.y, this.z, this.destination3, Scale);
+
+        return this.destination3[^1];
+    }
+
+    /// <summary>
+    /// Measures the SIMD three-plane normalization and interleave implementation.
+    /// </summary>
+    /// <returns>The last destination value, keeping the writes observable.</returns>
+    [Benchmark]
+    [BenchmarkCategory("Pack3")]
+    public float PackedNormalizeInterleave3Simd()
+    {
+        JpegColorConverterBase.PackedNormalizeInterleave3(this.x, this.y, this.z, this.destination3, Scale);
+
+        return this.destination3[^1];
+    }
+
+    /// <summary>
+    /// Measures the previous scalar packed-three-channel deinterleave loop.
+    /// </summary>
+    /// <returns>A checksum containing the last value written to every destination plane.</returns>
+    [Benchmark(Baseline = true)]
+    [BenchmarkCategory("Unpack3")]
+    public float UnpackDeinterleave3Scalar()
+    {
+        JpegColorPackingScalar.UnpackDeinterleave3(this.packed3, this.x, this.y, this.z);
+
+        return this.x[^1] + this.y[^1] + this.z[^1];
+    }
+
+    /// <summary>
+    /// Measures the SIMD packed-three-channel deinterleave implementation.
+    /// </summary>
+    /// <returns>A checksum containing the last value written to every destination plane.</returns>
+    [Benchmark]
+    [BenchmarkCategory("Unpack3")]
+    public float UnpackDeinterleave3Simd()
+    {
+        JpegColorConverterBase.UnpackDeinterleave3(this.packed3, this.x, this.y, this.z);
+
+        return this.x[^1] + this.y[^1] + this.z[^1];
+    }
+
+    /// <summary>
+    /// Measures the previous scalar four-plane normalization and interleave loop.
+    /// </summary>
+    /// <returns>The last destination value, keeping the writes observable.</returns>
+    [Benchmark(Baseline = true)]
+    [BenchmarkCategory("Pack4")]
+    public float PackedNormalizeInterleave4Scalar()
+    {
+        JpegColorPackingScalar.PackedNormalizeInterleave4(this.x, this.y, this.z, this.w, this.destination4, MaximumValue);
+
+        return this.destination4[^1];
+    }
+
+    /// <summary>
+    /// Measures the SIMD four-plane normalization and interleave implementation.
+    /// </summary>
+    /// <returns>The last destination value, keeping the writes observable.</returns>
+    [Benchmark]
+    [BenchmarkCategory("Pack4")]
+    public float PackedNormalizeInterleave4Simd()
+    {
+        JpegColorConverterBase.PackedNormalizeInterleave4(this.x, this.y, this.z, this.w, this.destination4, MaximumValue);
+
+        return this.destination4[^1];
+    }
+
+    /// <summary>
+    /// Measures the previous scalar inverted four-plane normalization and interleave loop.
+    /// </summary>
+    /// <returns>The last destination value, keeping the writes observable.</returns>
+    [Benchmark(Baseline = true)]
+    [BenchmarkCategory("InvertPack4")]
+    public float PackedInvertNormalizeInterleave4Scalar()
+    {
+        JpegColorPackingScalar.PackedInvertNormalizeInterleave4(this.x, this.y, this.z, this.w, this.destination4, MaximumValue);
+
+        return this.destination4[^1];
+    }
+
+    /// <summary>
+    /// Measures the SIMD inverted four-plane normalization and interleave implementation.
+    /// </summary>
+    /// <returns>The last destination value, keeping the writes observable.</returns>
+    [Benchmark]
+    [BenchmarkCategory("InvertPack4")]
+    public float PackedInvertNormalizeInterleave4Simd()
+    {
+        JpegColorConverterBase.PackedInvertNormalizeInterleave4(this.x, this.y, this.z, this.w, this.destination4, MaximumValue);
+
+        return this.destination4[^1];
+    }
+
+    /// <summary>
+    /// Creates deterministic, non-integral samples for one component plane.
+    /// </summary>
+    /// <param name="length">The number of samples to create.</param>
+    /// <param name="component">The one-based component number used to distinguish the plane.</param>
+    /// <returns>The generated samples.</returns>
+    private static float[] CreateSamples(int length, int component)
+    {
+        float[] samples = new float[length];
+
+        for (int i = 0; i < samples.Length; i++)
+        {
+            samples[i] = (((i * 37) + (component * 53)) % 251) + (component * 0.125F);
+        }
+
+        return samples;
+    }
+}

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/JpegColorPackingScalar.cs

@@ -0,0 +1,117 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+/// <summary>
+/// Preserves the scalar JPEG packing loops that preceded the SIMD investigation.
+/// </summary>
+internal static class JpegColorPackingScalar
+{
+    /// <summary>
+    /// Normalizes and interleaves three planar component lanes using the previous scalar implementation.
+    /// </summary>
+    /// <param name="xLane">The planar X components.</param>
+    /// <param name="yLane">The planar Y components.</param>
+    /// <param name="zLane">The planar Z components.</param>
+    /// <param name="packed">The destination ordered as consecutive XYZ triples.</param>
+    /// <param name="scale">The normalization factor applied to every component.</param>
+    public static void PackedNormalizeInterleave3(ReadOnlySpan<float> xLane, ReadOnlySpan<float> yLane, ReadOnlySpan<float> zLane, Span<float> packed, float scale)
+    {
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+
+        for (nuint i = 0; i < (nuint)xLane.Length; i++)
+        {
+            nuint packedOffset = i * 3;
+            Unsafe.Add(ref packedRef, packedOffset) = Unsafe.Add(ref xLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 1) = Unsafe.Add(ref yLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 2) = Unsafe.Add(ref zLaneRef, i) * scale;
+        }
+    }
+
+    /// <summary>
+    /// Deinterleaves packed XYZ values using the previous scalar implementation.
+    /// </summary>
+    /// <param name="packed">The source ordered as consecutive XYZ triples.</param>
+    /// <param name="xLane">The destination X components.</param>
+    /// <param name="yLane">The destination Y components.</param>
+    /// <param name="zLane">The destination Z components.</param>
+    public static void UnpackDeinterleave3(ReadOnlySpan<Vector3> packed, Span<float> xLane, Span<float> yLane, Span<float> zLane)
+    {
+        ref float packedRef = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<Vector3, float>(packed));
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+
+        for (nuint i = 0; i < (nuint)packed.Length; i++)
+        {
+            nuint packedOffset = i * 3;
+            Unsafe.Add(ref xLaneRef, i) = Unsafe.Add(ref packedRef, packedOffset);
+            Unsafe.Add(ref yLaneRef, i) = Unsafe.Add(ref packedRef, packedOffset + 1);
+            Unsafe.Add(ref zLaneRef, i) = Unsafe.Add(ref packedRef, packedOffset + 2);
+        }
+    }
+
+    /// <summary>
+    /// Normalizes and interleaves four planar component lanes using the previous scalar implementation.
+    /// </summary>
+    /// <param name="xLane">The planar X components.</param>
+    /// <param name="yLane">The planar Y components.</param>
+    /// <param name="zLane">The planar Z components.</param>
+    /// <param name="wLane">The planar W components.</param>
+    /// <param name="packed">The destination ordered as consecutive XYZW groups.</param>
+    /// <param name="maximumValue">The maximum component value used to normalize each component.</param>
+    public static void PackedNormalizeInterleave4(ReadOnlySpan<float> xLane, ReadOnlySpan<float> yLane, ReadOnlySpan<float> zLane, ReadOnlySpan<float> wLane, Span<float> packed, float maximumValue)
+    {
+        float scale = 1F / maximumValue;
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+
+        for (nuint i = 0; i < (nuint)xLane.Length; i++)
+        {
+            nuint packedOffset = i * 4;
+            Unsafe.Add(ref packedRef, packedOffset) = Unsafe.Add(ref xLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 1) = Unsafe.Add(ref yLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 2) = Unsafe.Add(ref zLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 3) = Unsafe.Add(ref wLaneRef, i) * scale;
+        }
+    }
+
+    /// <summary>
+    /// Inverts, normalizes, and interleaves four planar lanes using the previous scalar implementation.
+    /// </summary>
+    /// <param name="xLane">The inverted planar X components.</param>
+    /// <param name="yLane">The inverted planar Y components.</param>
+    /// <param name="zLane">The inverted planar Z components.</param>
+    /// <param name="wLane">The inverted planar W components.</param>
+    /// <param name="packed">The destination ordered as consecutive conventional XYZW groups.</param>
+    /// <param name="maximumValue">The maximum component value used for inversion and normalization.</param>
+    public static void PackedInvertNormalizeInterleave4(ReadOnlySpan<float> xLane, ReadOnlySpan<float> yLane, ReadOnlySpan<float> zLane, ReadOnlySpan<float> wLane, Span<float> packed, float maximumValue)
+    {
+        float scale = 1F / maximumValue;
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+
+        for (nuint i = 0; i < (nuint)xLane.Length; i++)
+        {
+            nuint packedOffset = i * 4;
+            Unsafe.Add(ref packedRef, packedOffset) = (maximumValue - Unsafe.Add(ref xLaneRef, i)) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 1) = (maximumValue - Unsafe.Add(ref yLaneRef, i)) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 2) = (maximumValue - Unsafe.Add(ref zLaneRef, i)) * scale;
+            Unsafe.Add(ref packedRef, packedOffset + 3) = (maximumValue - Unsafe.Add(ref wLaneRef, i)) * scale;
+        }
+    }
+}

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/RgbColorConversion.cs

@@ -9,40 +9,24 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
 [Config(typeof(Config.Short))]
 public class RgbColorConversion : ColorConversionBenchmark
 {
+    private readonly JpegColorConverterBase converter = JpegColorConverterBase.GetConverter(JpegColorSpace.RGB, 8);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RgbColorConversion"/> class.
+    /// </summary>
     public RgbColorConversion()
         : base(3)
     {
     }
 
-    [Benchmark(Baseline = true)]
+    /// <summary>
-    public void Scalar()
+    /// Converts one RGB component row through the adaptive operator traversal.
-    {
+    /// </summary>
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.RgbScalar(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector128()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.RgbVector128(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector256()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.RgbVector256(8).ConvertToRgbInPlace(values);
-    }
-
     [Benchmark]
-    public void SimdVector512()
+    public void ConvertToRgb()
     {
         JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.RgbVector512(8).ConvertToRgbInPlace(values);
+        this.converter.ConvertToRgbInPlace(values);
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YCbCrColorConversion.cs

@@ -9,40 +9,24 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
 [Config(typeof(Config.Short))]
 public class YCbCrColorConversion : ColorConversionBenchmark
 {
+    private readonly JpegColorConverterBase converter = JpegColorConverterBase.GetConverter(JpegColorSpace.YCbCr, 8);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YCbCrColorConversion"/> class.
+    /// </summary>
     public YCbCrColorConversion()
         : base(3)
     {
     }
 
+    /// <summary>
+    /// Converts one YCbCr component row through the adaptive operator traversal.
+    /// </summary>
     [Benchmark]
-    public void Scalar()
+    public void ConvertToRgb()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.YCbCrScalar(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector128()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.YCbCrVector128(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector256()
-    {
-        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
-
-        new JpegColorConverterBase.YCbCrVector256(8).ConvertToRgbInPlace(values);
-    }
-
-    [Benchmark]
-    public void SimdVector512()
     {
         JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YCbCrVector512(8).ConvertToRgbInPlace(values);
+        this.converter.ConvertToRgbInPlace(values);
     }
 }