Complete implementation and add tests/benchmark

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -643,6 +643,20 @@ internal static class Numerics
         return Avx.Blend(result, alpha, BlendAlphaControl);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> UnPremultiply(Vector512<float> source, Vector512<float> alpha)
+    {
+        // Check if alpha is zero to avoid division by zero
+        Vector512<float> zeroMask = Vector512.Equals(alpha, Vector512<float>.Zero);
+
+        // Divide source by alpha if alpha is nonzero, otherwise set all components to match the source value
+        Vector512<float> result = Vector512.ConditionalSelect(zeroMask, source, source / alpha);
+
+        // Blend the result with the alpha vector to ensure that the alpha component is unchanged
+        Vector512<float> alphaMask = Vector512.Create(0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1).AsSingle();
+        return Vector512.ConditionalSelect(alphaMask, alpha, result);
+    }
+
     /// <summary>
     /// Permutes the given vector return a new instance with all the values set to <see cref="Vector4.W"/>.
     /// </summary>

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

@@ -601,28 +601,6 @@ internal static partial class SimdUtils
             }
         }
 
-        /// <summary>
-        /// Performs a multiplication and a negated addition of the <see cref="Vector256{Single}"/>.
-        /// </summary>
-        /// <remarks>ret = va - (vm0 * vm1)</remarks>
-        /// <param name="va">The vector to add to the negated intermediate result.</param>
-        /// <param name="vm0">The first vector to multiply.</param>
-        /// <param name="vm1">The second vector to multiply.</param>
-        /// <returns>The <see cref="Vector256{T}"/>.</returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static Vector256<float> MultiplyAddNegated(
-            Vector256<float> va,
-            Vector256<float> vm0,
-            Vector256<float> vm1)
-        {
-            if (Fma.IsSupported)
-            {
-                return Fma.MultiplyAddNegated(vm0, vm1, va);
-            }
-
-            return Avx.Subtract(va, Avx.Multiply(vm0, vm1));
-        }
-
         /// <summary>
         /// Blend packed 8-bit integers from <paramref name="left"/> and <paramref name="right"/> using <paramref name="mask"/>.
         /// The high bit of each corresponding <paramref name="mask"/> byte determines the selection.

src/ImageSharp/Common/Helpers/Vector512Utilities.cs

@@ -87,6 +87,21 @@ internal static class Vector512_
         Vector512<float> vm1)
         => Avx512F.FusedMultiplyAdd(vm0, vm1, va);
 
+    /// <summary>
+    /// Performs a multiplication and a negated addition of the <see cref="Vector512{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = va - (vm0 * vm1)</remarks>
+    /// <param name="va">The vector to add to the negated intermediate result.</param>
+    /// <param name="vm0">The first vector to multiply.</param>
+    /// <param name="vm1">The second vector to multiply.</param>
+    /// <returns>The <see cref="Vector512{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyAddNegated(
+        Vector512<float> va,
+        Vector512<float> vm0,
+        Vector512<float> vm1)
+        => Avx512F.FusedMultiplyAddNegated(vm0, vm1, va);
+
     /// <summary>
     /// Restricts a vector between a minimum and a maximum value.
     /// </summary>

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

@@ -89,7 +89,34 @@ var blenders = new []{
         {
             amount = Numerics.Clamp(amount, 0, 1);
 
-            if (Avx2.IsSupported && destination.Length >= 2)
+            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));
@@ -128,7 +155,37 @@ var blenders = new []{
         {
             amount = Numerics.Clamp(amount, 0, 1);
 
-            if (Avx2.IsSupported && destination.Length >= 2)
+            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));
@@ -164,7 +221,51 @@ var blenders = new []{
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            if (Avx2.IsSupported && destination.Length >= 2)
+            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));
@@ -211,7 +312,54 @@ var blenders = new []{
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
-            if (Avx2.IsSupported && destination.Length >= 2)
+            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));

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

@@ -49,6 +49,17 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> <#=blender#>Src(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
         => Avx.Blend(source, source * opacity, BlendAlphaControl);
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>Src compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>Src(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
     /// <summary>
     /// Returns the result of the "<#=blender#>SrcAtop" compositing equation.
     /// </summary>
@@ -79,6 +90,21 @@ internal static partial class PorterDuffFunctions
         return Atop(backdrop, source, <#=blender#>(backdrop, source));
     }
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>SrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>SrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, <#=blender#>(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "<#=blender#>SrcOver" compositing equation.
     /// </summary>
@@ -109,6 +135,21 @@ internal static partial class PorterDuffFunctions
         return Over(backdrop, source, <#=blender#>(backdrop, source));
     }
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>SrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>SrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, <#=blender#>(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "<#=blender#>SrcIn" compositing equation.
     /// </summary>
@@ -135,6 +176,17 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> <#=blender#>SrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
         => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>SrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>SrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
     /// <summary>
     /// Returns the result of the "<#=blender#>SrcOut" compositing equation.
     /// </summary>
@@ -161,6 +213,17 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> <#=blender#>SrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
         => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>SrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>SrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
     /// <summary>
     /// Returns the result of the "<#=blender#>Dest" compositing equation.
     /// </summary>
@@ -187,6 +250,19 @@ internal static partial class PorterDuffFunctions
         return backdrop;
     }
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>Dest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>Dest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
     /// <summary>
     /// Returns the result of the "<#=blender#>DestAtop" compositing equation.
     /// </summary>
@@ -217,6 +293,21 @@ internal static partial class PorterDuffFunctions
         return Atop(source, backdrop, <#=blender#>(source, backdrop));
     }
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>DestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>DestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, <#=blender#>(source, backdrop));
+    }
+
     /// <summary>
     /// Returns the result of the "<#=blender#>DestOver" compositing equation.
     /// </summary>
@@ -247,6 +338,21 @@ internal static partial class PorterDuffFunctions
         return Over(source, backdrop, <#=blender#>(source, backdrop));
     }
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>DestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>DestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, <#=blender#>(source, backdrop));
+    }
+
     /// <summary>
     /// Returns the result of the "<#=blender#>DestIn" compositing equation.
     /// </summary>
@@ -273,6 +379,17 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> <#=blender#>DestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
         => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>DestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>DestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
     /// <summary>
     /// Returns the result of the "<#=blender#>DestOut" compositing equation.
     /// </summary>
@@ -299,6 +416,17 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> <#=blender#>DestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
         => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>DestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>DestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
     /// <summary>
     /// Returns the result of the "<#=blender#>Xor" compositing equation.
     /// </summary>
@@ -325,6 +453,17 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> <#=blender#>Xor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
         => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>Xor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>Xor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
     /// <summary>
     /// Returns the result of the "<#=blender#>Clear" compositing equation.
     /// </summary>
@@ -351,6 +490,17 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> <#=blender#>Clear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
         => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>Clear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>Clear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
 <#} #>
 
 <# void GenerateGenericPixelBlender(string blender, string composer) { #>

src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs

@@ -45,6 +45,16 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> Normal(Vector256<float> backdrop, Vector256<float> source)
         => source;
 
+    /// <summary>
+    /// Returns the result of the "Normal" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Normal(Vector512<float> backdrop, Vector512<float> source)
+        => source;
+
     /// <summary>
     /// Returns the result of the "Multiply" compositing equation.
     /// </summary>
@@ -65,6 +75,16 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> Multiply(Vector256<float> backdrop, Vector256<float> source)
         => backdrop * source;
 
+    /// <summary>
+    /// Returns the result of the "Multiply" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Multiply(Vector512<float> backdrop, Vector512<float> source)
+        => backdrop * source;
+
     /// <summary>
     /// Returns the result of the "Add" compositing equation.
     /// </summary>
@@ -85,6 +105,16 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> Add(Vector256<float> backdrop, Vector256<float> source)
         => Vector256.Min(Vector256.Create(1F), backdrop + source);
 
+    /// <summary>
+    /// Returns the result of the "Add" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Add(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Min(Vector512.Create(1F), backdrop + source);
+
     /// <summary>
     /// Returns the result of the "Subtract" compositing equation.
     /// </summary>
@@ -105,6 +135,16 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> Subtract(Vector256<float> backdrop, Vector256<float> source)
         => Vector256.Max(Vector256<float>.Zero, backdrop - source);
 
+    /// <summary>
+    /// Returns the result of the "Subtract" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Subtract(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Max(Vector512<float>.Zero, backdrop - source);
+
     /// <summary>
     /// Returns the result of the "Screen" compositing equation.
     /// </summary>
@@ -128,6 +168,19 @@ internal static partial class PorterDuffFunctions
         return Vector256_.MultiplyAddNegated(vOne, vOne - backdrop, vOne - source);
     }
 
+    /// <summary>
+    /// Returns the result of the "Screen" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Screen(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> vOne = Vector512.Create(1F);
+        return Vector512_.MultiplyAddNegated(vOne, vOne - backdrop, vOne - source);
+    }
+
     /// <summary>
     /// Returns the result of the "Darken" compositing equation.
     /// </summary>
@@ -148,6 +201,16 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> Darken(Vector256<float> backdrop, Vector256<float> source)
         => Vector256.Min(backdrop, source);
 
+    /// <summary>
+    /// Returns the result of the "Darken" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Darken(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Min(backdrop, source);
+
     /// <summary>
     /// Returns the result of the "Lighten" compositing equation.
     /// </summary>
@@ -167,6 +230,16 @@ internal static partial class PorterDuffFunctions
     public static Vector256<float> Lighten(Vector256<float> backdrop, Vector256<float> source)
         => Vector256.Max(backdrop, source);
 
+    /// <summary>
+    /// Returns the result of the "Lighten" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Lighten(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Max(backdrop, source);
+
     /// <summary>
     /// Returns the result of the "Overlay" compositing equation.
     /// </summary>
@@ -196,6 +269,19 @@ internal static partial class PorterDuffFunctions
         return Vector256.Min(Vector256.Create(1F), Avx.Blend(color, Vector256<float>.Zero, BlendAlphaControl));
     }
 
+    /// <summary>
+    /// Returns the result of the "Overlay" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Overlay(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> color = OverlayValueFunction(backdrop, source);
+        return Vector512.Min(Vector512.Create(1F), Vector512.ConditionalSelect(AlphaMask512(), Vector512<float>.Zero, color));
+    }
+
     /// <summary>
     /// Returns the result of the "HardLight" compositing equation.
     /// </summary>
@@ -225,6 +311,19 @@ internal static partial class PorterDuffFunctions
         return Vector256.Min(Vector256.Create(1F), Avx.Blend(color, Vector256<float>.Zero, BlendAlphaControl));
     }
 
+    /// <summary>
+    /// Returns the result of the "HardLight" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLight(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> color = OverlayValueFunction(source, backdrop);
+        return Vector512.Min(Vector512.Create(1F), Vector512.ConditionalSelect(AlphaMask512(), Vector512<float>.Zero, color));
+    }
+
     /// <summary>
     /// Helper function for Overlay and HardLight modes
     /// </summary>
@@ -253,6 +352,24 @@ internal static partial class PorterDuffFunctions
         return Avx.BlendVariable(left, right, cmp);
     }
 
+    /// <summary>
+    /// Helper function for Overlay and HardLight modes
+    /// </summary>
+    /// <param name="backdrop">Backdrop color element</param>
+    /// <param name="source">Source color element</param>
+    /// <returns>Overlay value</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayValueFunction(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> vOne = Vector512.Create(1F);
+        Vector512<float> left = (backdrop + backdrop) * source;
+
+        Vector512<float> vOneMinusSource = vOne - source;
+        Vector512<float> right = Vector512_.MultiplyAddNegated(vOne, vOneMinusSource + vOneMinusSource, vOne - backdrop);
+        Vector512<float> cmp = Avx512F.CompareGreaterThan(backdrop, Vector512.Create(.5F));
+        return Vector512.ConditionalSelect(cmp, right, left);
+    }
+
     /// <summary>
     /// Returns the result of the "Over" compositing equation.
     /// </summary>
@@ -312,6 +429,36 @@ internal static partial class PorterDuffFunctions
         return Numerics.UnPremultiply(color, alpha);
     }
 
+    /// <summary>
+    /// Returns the result of the "Over" compositing equation.
+    /// </summary>
+    /// <param name="destination">The destination vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="blend">The amount to blend. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Over(Vector512<float> destination, Vector512<float> source, Vector512<float> blend)
+    {
+        // calculate weights
+        Vector512<float> sW = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> dW = Vector512_.ShuffleNative(destination, ShuffleAlphaControl);
+
+        Vector512<float> blendW = sW * dW;
+        Vector512<float> dstW = dW - blendW;
+        Vector512<float> srcW = sW - blendW;
+
+        // calculate final alpha
+        Vector512<float> alpha = dstW + sW;
+
+        // calculate final color
+        Vector512<float> color = destination * dstW;
+        color = Vector512_.MultiplyAdd(color, source, srcW);
+        color = Vector512_.MultiplyAdd(color, blend, blendW);
+
+        // unpremultiply
+        return Numerics.UnPremultiply(color, alpha);
+    }
+
     /// <summary>
     /// Returns the result of the "Atop" compositing equation.
     /// </summary>
@@ -365,6 +512,31 @@ internal static partial class PorterDuffFunctions
         return Numerics.UnPremultiply(color, alpha);
     }
 
+    /// <summary>
+    /// Returns the result of the "Atop" compositing equation.
+    /// </summary>
+    /// <param name="destination">The destination vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="blend">The amount to blend. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Atop(Vector512<float> destination, Vector512<float> source, Vector512<float> blend)
+    {
+        // calculate final alpha
+        Vector512<float> alpha = Vector512_.ShuffleNative(destination, ShuffleAlphaControl);
+
+        // calculate weights
+        Vector512<float> sW = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> blendW = sW * alpha;
+        Vector512<float> dstW = alpha - blendW;
+
+        // calculate final color
+        Vector512<float> color = Vector512_.MultiplyAdd(blend * blendW, destination, dstW);
+
+        // unpremultiply
+        return Numerics.UnPremultiply(color, alpha);
+    }
+
     /// <summary>
     /// Returns the result of the "In" compositing equation.
     /// </summary>
@@ -402,6 +574,25 @@ internal static partial class PorterDuffFunctions
         return Numerics.UnPremultiply(color, alpha);
     }
 
+    /// <summary>
+    /// Returns the result of the "In" compositing equation.
+    /// </summary>
+    /// <param name="destination">The destination vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> In(Vector512<float> destination, Vector512<float> source)
+    {
+        // calculate alpha
+        Vector512<float> alpha = Vector512_.ShuffleNative(source * destination, ShuffleAlphaControl);
+
+        // premultiply
+        Vector512<float> color = source * alpha;
+
+        // unpremultiply
+        return Numerics.UnPremultiply(color, alpha);
+    }
+
     /// <summary>
     /// Returns the result of the "Out" compositing equation.
     /// </summary>
@@ -439,6 +630,25 @@ internal static partial class PorterDuffFunctions
         return Numerics.UnPremultiply(color, alpha);
     }
 
+    /// <summary>
+    /// Returns the result of the "Out" compositing equation.
+    /// </summary>
+    /// <param name="destination">The destination vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Out(Vector512<float> destination, Vector512<float> source)
+    {
+        // calculate alpha
+        Vector512<float> alpha = Vector512_.ShuffleNative(source * (Vector512.Create(1F) - destination), ShuffleAlphaControl);
+
+        // premultiply
+        Vector512<float> color = source * alpha;
+
+        // unpremultiply
+        return Numerics.UnPremultiply(color, alpha);
+    }
+
     /// <summary>
     /// Returns the result of the "XOr" compositing equation.
     /// </summary>
@@ -487,9 +697,41 @@ internal static partial class PorterDuffFunctions
         return Numerics.UnPremultiply(color, alpha);
     }
 
+    /// <summary>
+    /// Returns the result of the "XOr" compositing equation.
+    /// </summary>
+    /// <param name="destination">The destination vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Xor(Vector512<float> destination, Vector512<float> source)
+    {
+        // calculate weights
+        Vector512<float> sW = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> dW = Vector512_.ShuffleNative(destination, ShuffleAlphaControl);
+
+        Vector512<float> vOne = Vector512.Create(1F);
+        Vector512<float> srcW = vOne - dW;
+        Vector512<float> dstW = vOne - sW;
+
+        // calculate alpha
+        Vector512<float> alpha = Vector512_.MultiplyAdd(dW * dstW, sW, srcW);
+        Vector512<float> color = Vector512_.MultiplyAdd((dW * destination) * dstW, sW * source, srcW);
+
+        // unpremultiply
+        return Numerics.UnPremultiply(color, alpha);
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static Vector4 Clear(Vector4 backdrop, Vector4 source) => Vector4.Zero;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static Vector256<float> Clear(Vector256<float> backdrop, Vector256<float> source) => Vector256<float>.Zero;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> Clear(Vector512<float> backdrop, Vector512<float> source) => Vector512<float>.Zero;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> AlphaMask512()
+        => Vector512.Create(0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1).AsSingle();
 }

tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsSingleVector.cs

@@ -18,8 +18,8 @@ public class PorterDuffBulkVsSingleVector
     [GlobalSetup]
     public void Setup()
     {
-        this.backdrop = new Vector4[8 * 20];
+        this.backdrop = new Vector4[8 * 40];
-        this.source = new Vector4[8 * 20];
+        this.source = new Vector4[8 * 40];
 
         FillRandom(this.backdrop);
         FillRandom(this.source);
@@ -49,7 +49,7 @@ public class PorterDuffBulkVsSingleVector
         return result;
     }
 
-    [Benchmark(Description = "Avx")]
+    [Benchmark(Description = "Avx2")]
     public Vector256<float> OverlayValueFunction_Avx()
     {
         ref Vector256<float> backdrop = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference<Vector4>(this.backdrop));
@@ -65,4 +65,21 @@ public class PorterDuffBulkVsSingleVector
 
         return result;
     }
+
+    [Benchmark(Description = "Avx512")]
+    public Vector512<float> OverlayValueFunction_Avx512()
+    {
+        ref Vector512<float> backdrop = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference<Vector4>(this.backdrop));
+        ref Vector512<float> source = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference<Vector4>(this.source));
+
+        Vector512<float> result = default;
+        Vector512<float> opacity = Vector512.Create(.5F);
+        int count = this.backdrop.Length / 4;
+        for (nuint i = 0; i < (uint)count; i++)
+        {
+            result = PorterDuffFunctions.NormalSrcOver(Unsafe.Add(ref backdrop, i), Unsafe.Add(ref source, i), opacity);
+        }
+
+        return result;
+    }
 }

tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffCompositorTests.cs

@@ -59,7 +59,7 @@ public class PorterDuffCompositorTests
 
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX,
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512 | HwIntrinsics.DisableAVX,
             provider,
             mode.ToString());
     }

tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs

@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
-using Castle.Components.DictionaryAdapter;
 using SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 using SixLabors.ImageSharp.Tests.TestUtilities;
 
@@ -45,6 +44,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(NormalBlendFunctionData))]
+    public void NormalBlendFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.NormalSrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> MultiplyFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(1, 1, 1, 1) },
@@ -77,6 +92,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(MultiplyFunctionData))]
+    public void MultiplyFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.MultiplySrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> AddFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(1, 1, 1, 1) },
@@ -109,6 +140,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(AddFunctionData))]
+    public void AddFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.AddSrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> SubtractFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(0, 0, 0, 1) },
@@ -141,6 +188,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(SubtractFunctionData))]
+    public void SubtractFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.SubtractSrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> ScreenFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(1, 1, 1, 1) },
@@ -173,6 +236,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(ScreenFunctionData))]
+    public void ScreenFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.ScreenSrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> DarkenFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(1, 1, 1, 1) },
@@ -205,6 +284,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(DarkenFunctionData))]
+    public void DarkenFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.DarkenSrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> LightenFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(1, 1, 1, 1) },
@@ -237,6 +332,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(LightenFunctionData))]
+    public void LightenFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.LightenSrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> OverlayFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(1, 1, 1, 1) },
@@ -269,6 +380,22 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected256, actual, FloatComparer);
     }
 
+    [Theory]
+    [MemberData(nameof(OverlayFunctionData))]
+    public void OverlayFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.OverlaySrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
     public static TheoryData<TestVector4, TestVector4, float, TestVector4> HardLightFunctionData { get; } = new()
     {
         { new TestVector4(1, 1, 1, 1), new TestVector4(1, 1, 1, 1), 1, new TestVector4(1, 1, 1, 1) },
@@ -300,4 +427,27 @@ public class PorterDuffFunctionsTests
         Vector256<float> actual = PorterDuffFunctions.HardLightSrcOver(back256, source256, Vector256.Create(amount));
         Assert.Equal(expected256, actual, FloatComparer);
     }
+
+    [Theory]
+    [MemberData(nameof(HardLightFunctionData))]
+    public void HardLightFunction512(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> back512 = CreateVector512(back);
+        Vector512<float> source512 = CreateVector512(source);
+        Vector512<float> expected512 = CreateVector512(expected);
+        Vector512<float> actual = PorterDuffFunctions.HardLightSrcOver(back512, source512, Vector512.Create(amount));
+        Assert.Equal(expected512, actual, FloatComparer);
+    }
+
+    private static Vector512<float> CreateVector512(TestVector4 vector)
+        => Vector512.Create(
+            vector.X, vector.Y, vector.Z, vector.W,
+            vector.X, vector.Y, vector.Z, vector.W,
+            vector.X, vector.Y, vector.Z, vector.W,
+            vector.X, vector.Y, vector.Z, vector.W);
 }

tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTestsTPixel.cs

@@ -9,12 +9,21 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders;
 
 public class PorterDuffFunctionsTestsTPixel
 {
+    private const int BulkBlendCount = 4;
+
     private static Span<T> AsSpan<T>(T value)
         where T : struct
     {
         return new Span<T>(new[] { value });
     }
 
+    private static T[] CreateFilledArray<T>(T value)
+    {
+        T[] values = new T[BulkBlendCount];
+        values.AsSpan().Fill(value);
+        return values;
+    }
+
     public static TheoryData<object, object, float, object> NormalBlendFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
@@ -46,9 +55,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void NormalBlendFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.NormalSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.NormalSrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> MultiplyFunctionData = new()
@@ -86,9 +100,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void MultiplyFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.MultiplySrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.MultiplySrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> AddFunctionData = new()
@@ -136,9 +155,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void AddFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.AddSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.AddSrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> SubtractFunctionData = new()
@@ -176,9 +200,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void SubtractFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.SubtractSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.SubtractSrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> ScreenFunctionData = new()
@@ -216,9 +245,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void ScreenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.ScreenSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.ScreenSrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> DarkenFunctionData = new()
@@ -256,9 +290,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void DarkenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.DarkenSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.DarkenSrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> LightenFunctionData = new()
@@ -296,9 +335,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void LightenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.LightenSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.LightenSrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> OverlayFunctionData = new()
@@ -336,9 +380,14 @@ public class PorterDuffFunctionsTestsTPixel
     public void OverlayFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.OverlaySrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.OverlaySrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 
     public static TheoryData<object, object, float, object> HardLightFunctionData = new()
@@ -376,8 +425,13 @@ public class PorterDuffFunctionsTestsTPixel
     public void HardLightFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Span<TPixel> dest = new(new TPixel[1]);
+        TPixel[] dest = new TPixel[BulkBlendCount];
-        new DefaultPixelBlenders<TPixel>.HardLightSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+        new DefaultPixelBlenders<TPixel>.HardLightSrcOver().Blend(this.Configuration, dest, CreateFilledArray(back.AsPixel()), CreateFilledArray(source.AsPixel()), CreateFilledArray(amount));
-        VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
+
+        TPixel expectedPixel = expected.AsPixel();
+        foreach (TPixel pixel in dest)
+        {
+            VectorAssert.Equal(expectedPixel, pixel, 2);
+        }
     }
 }

tests/ImageSharp.Tests/TestUtilities/ApproximateFloatComparer.cs

@@ -15,7 +15,8 @@ internal readonly struct ApproximateFloatComparer :
     IEqualityComparer<Vector2>,
     IEqualityComparer<Vector4>,
     IEqualityComparer<ColorMatrix>,
-    IEqualityComparer<Vector256<float>>
+    IEqualityComparer<Vector256<float>>,
+    IEqualityComparer<Vector512<float>>
 {
     private readonly float epsilon;
 
@@ -78,4 +79,19 @@ internal readonly struct ApproximateFloatComparer :
         && this.Equals(x.GetElement(7), y.GetElement(7));
 
     public int GetHashCode([DisallowNull] Vector256<float> obj) => obj.GetHashCode();
+
+    public bool Equals(Vector512<float> x, Vector512<float> y)
+    {
+        for (int i = 0; i < Vector512<float>.Count; i++)
+        {
+            if (!this.Equals(x.GetElement(i), y.GetElement(i)))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public int GetHashCode([DisallowNull] Vector512<float> obj) => obj.GetHashCode();
 }