Merge branch 'main' into js/fix-2866-v4

.editorconfig

@@ -104,8 +104,8 @@ dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:war
 dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
 dotnet_style_parentheses_in_other_operators = always_for_clarity:suggestion
 # Expression-level preferences
-dotnet_style_object_initializer = true:warning
-dotnet_style_collection_initializer = true:warning
+dotnet_style_object_initializer = true:error
+dotnet_style_collection_initializer = true:error
 dotnet_style_explicit_tuple_names = true:warning
 dotnet_style_prefer_inferred_tuple_names = true:warning
 dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
@@ -135,9 +135,9 @@ csharp_style_prefer_null_check_over_type_check = true:warning
 # https://docs.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/language-rules#c-style-rules
 [*.{cs,csx,cake}]
 # 'var' preferences
-csharp_style_var_for_built_in_types = false:warning
-csharp_style_var_when_type_is_apparent = false:warning
-csharp_style_var_elsewhere = false:warning
+csharp_style_var_for_built_in_types = false:error
+csharp_style_var_when_type_is_apparent = false:error
+csharp_style_var_elsewhere = false:error
 # Expression-bodied members
 csharp_style_expression_bodied_methods = true:warning
 csharp_style_expression_bodied_constructors = true:warning
@@ -160,7 +160,7 @@ csharp_style_pattern_local_over_anonymous_function = true:warning
 csharp_style_deconstructed_variable_declaration = true:warning
 csharp_style_prefer_index_operator = true:warning
 csharp_style_prefer_range_operator = true:warning
-csharp_style_implicit_object_creation_when_type_is_apparent = true:warning
+csharp_style_implicit_object_creation_when_type_is_apparent = true:error
 # "Null" checking preferences
 csharp_style_throw_expression = true:warning
 csharp_style_conditional_delegate_call = true:warning

.gitattributes

@@ -136,3 +136,10 @@
 *.ico               filter=lfs diff=lfs merge=lfs -text
 *.cur               filter=lfs diff=lfs merge=lfs -text
 *.ani               filter=lfs diff=lfs merge=lfs -text
+*.heic              filter=lfs diff=lfs merge=lfs -text
+*.hif               filter=lfs diff=lfs merge=lfs -text
+*.avif              filter=lfs diff=lfs merge=lfs -text
+###############################################################################
+# Handle ICC files by git lfs
+###############################################################################
+*.icc               filter=lfs diff=lfs merge=lfs -text

shared-infrastructure

@@ -1 +1 @@
-Subproject commit 1dbfb576c83507645265c79e03369b66cdc0379f
+Subproject commit 5e13cde851a3d6e95d0dfdde2a57071f1efda9c3

src/ImageSharp/ColorProfiles/CieLab.cs

@@ -35,7 +35,6 @@ public readonly struct CieLab : IProfileConnectingSpace<CieLab, CieXyz>
     /// <param name="vector">The vector representing the l, a, b components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieLab(Vector3 vector)
-        : this()
     {
         this.L = vector.X;
         this.A = vector.Y;
@@ -82,6 +81,49 @@ public readonly struct CieLab : IProfileConnectingSpace<CieLab, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieLab left, CieLab right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 128F, 128F);
+        v3 /= new Vector3(100F, 255F, 255F);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static CieLab FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100F, 255, 255);
+        v3 -= new Vector3(0, 128F, 128F);
+        return new CieLab(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLab> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLab> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static CieLab FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
@@ -136,7 +178,7 @@ public readonly struct CieLab : IProfileConnectingSpace<CieLab, CieXyz>
         float yr = l > CieConstants.Kappa * CieConstants.Epsilon ? Numerics.Pow3((l + 16F) / 116F) : l / CieConstants.Kappa;
         float zr = fz3 > CieConstants.Epsilon ? fz3 : ((116F * fz) - 16F) / CieConstants.Kappa;
 
-        CieXyz whitePoint = options.WhitePoint;
+        CieXyz whitePoint = options.SourceWhitePoint;
         Vector3 wxyz = new(whitePoint.X, whitePoint.Y, whitePoint.Z);
         Vector3 xyzr = new(xr, yr, zr);
 

src/ImageSharp/ColorProfiles/CieLch.cs

@@ -42,6 +42,17 @@ public readonly struct CieLch : IColorProfile<CieLch, CieLab>
         this.H = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private CieLch(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        vector = Vector3.Clamp(vector, Min, Max);
+        this.L = vector.X;
+        this.C = vector.Y;
+        this.H = vector.Z;
+    }
+
     /// <summary>
     /// Gets the lightness dimension.
     /// <remarks>A value ranging between 0 (black), 100 (diffuse white) or higher (specular white).</remarks>
@@ -50,7 +61,7 @@ public readonly struct CieLch : IColorProfile<CieLch, CieLab>
 
     /// <summary>
     /// Gets the a chroma component.
-    /// <remarks>A value ranging from 0 to 200.</remarks>
+    /// <remarks>A value ranging from -200 to 200.</remarks>
     /// </summary>
     public float C { get; }
 
@@ -82,6 +93,49 @@ public readonly struct CieLch : IColorProfile<CieLch, CieLab>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieLch left, CieLch right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 200, 0);
+        v3 /= new Vector3(100, 400, 360);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static CieLch FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100, 400, 360);
+        v3 -= new Vector3(0, 200, 0);
+        return new CieLch(v3, true);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLch> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLch> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static CieLch FromProfileConnectingSpace(ColorConversionOptions options, in CieLab source)
     {

src/ImageSharp/ColorProfiles/CieLchuv.cs

@@ -35,7 +35,6 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
     /// <param name="vector">The vector representing the l, c, h components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieLchuv(Vector3 vector)
-        : this()
     {
         vector = Vector3.Clamp(vector, Min, Max);
         this.L = vector.X;
@@ -43,6 +42,16 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
         this.H = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private CieLchuv(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.L = vector.X;
+        this.C = vector.Y;
+        this.H = vector.Z;
+    }
+
     /// <summary>
     /// Gets the lightness dimension.
     /// <remarks>A value ranging between 0 (black), 100 (diffuse white) or higher (specular white).</remarks>
@@ -51,7 +60,7 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
 
     /// <summary>
     /// Gets the a chroma component.
-    /// <remarks>A value ranging from 0 to 200.</remarks>
+    /// <remarks>A value ranging from -200 to 200.</remarks>
     /// </summary>
     public float C { get; }
 
@@ -81,6 +90,49 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
     /// </returns>
     public static bool operator !=(CieLchuv left, CieLchuv right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 200, 0);
+        v3 /= new Vector3(100, 400, 360);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static CieLchuv FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100, 400, 360);
+        v3 -= new Vector3(0, 200, 0);
+        return new CieLchuv(v3, true);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLchuv> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLchuv> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static CieLchuv FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {

src/ImageSharp/ColorProfiles/CieLuv.cs

@@ -37,7 +37,6 @@ public readonly struct CieLuv : IColorProfile<CieLuv, CieXyz>
     /// <param name="vector">The vector representing the l, u, v components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieLuv(Vector3 vector)
-        : this()
     {
         this.L = vector.X;
         this.U = vector.Y;
@@ -84,6 +83,18 @@ public readonly struct CieLuv : IColorProfile<CieLuv, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieLuv left, CieLuv right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4() => throw new NotImplementedException();
+
+    /// <inheritdoc/>
+    public static CieLuv FromScaledVector4(Vector4 source) => throw new NotImplementedException();
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLuv> source, Span<Vector4> destination) => throw new NotImplementedException();
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLuv> destination) => throw new NotImplementedException();
+
     /// <inheritdoc/>
     public static CieLuv FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
@@ -143,7 +154,7 @@ public readonly struct CieLuv : IColorProfile<CieLuv, CieXyz>
         // Use doubles here for accuracy.
         // Conversion algorithm described here:
         // http://www.brucelindbloom.com/index.html?Eqn_Luv_to_XYZ.html
-        CieXyz whitePoint = options.WhitePoint;
+        CieXyz whitePoint = options.SourceWhitePoint;
 
         double l = this.L, u = this.U, v = this.V;
 

src/ImageSharp/ColorProfiles/CieXyy.cs

@@ -35,7 +35,6 @@ public readonly struct CieXyy : IColorProfile<CieXyy, CieXyz>
     /// <param name="vector">The vector representing the x, y, Y components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieXyy(Vector3 vector)
-        : this()
     {
         // Not clamping as documentation about this space only indicates "usual" ranges
         this.X = vector.X;
@@ -83,6 +82,38 @@ public readonly struct CieXyy : IColorProfile<CieXyy, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieXyy left, CieXyy right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+        => new(this.AsVector3Unsafe(), 1F);
+
+    /// <inheritdoc/>
+    public static CieXyy FromScaledVector4(Vector4 source)
+        => new(source.AsVector3());
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieXyy> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieXyy> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static CieXyy FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {

src/ImageSharp/ColorProfiles/CieXyz.cs

@@ -34,7 +34,6 @@ public readonly struct CieXyz : IProfileConnectingSpace<CieXyz, CieXyz>
     /// </summary>
     /// <param name="vector">The vector representing the x, y, z components.</param>
     public CieXyz(Vector3 vector)
-        : this()
     {
         this.X = vector.X;
         this.Y = vector.Y;
@@ -81,12 +80,85 @@ public readonly struct CieXyz : IProfileConnectingSpace<CieXyz, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieXyz left, CieXyz right) => !left.Equals(right);
 
-    /// <summary>
-    /// Returns a new <see cref="Vector3"/> representing this instance.
-    /// </summary>
-    /// <returns>The <see cref="Vector3"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToVector3() => new(this.X, this.Y, this.Z);
+    internal Vector3 ToVector3() => new(this.X, this.Y, this.Z);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal Vector4 ToVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 *= 32768F / 65535;
+        return new Vector4(v3, 1F);
+    }
+
+    internal static CieXyz FromVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        return new CieXyz(v3);
+    }
+
+    /// <inheritdoc/>
+    public static CieXyz FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= 65535 / 32768F;
+        return new CieXyz(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieXyz> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieXyz> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
+    internal static void FromVector4(ReadOnlySpan<Vector4> source, Span<CieXyz> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromVector4(source[i]);
+        }
+    }
+
+    internal static void ToVector4(ReadOnlySpan<CieXyz> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToVector4();
+        }
+    }
 
     /// <inheritdoc/>
     public static CieXyz FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
@@ -127,5 +199,5 @@ public readonly struct CieXyz : IProfileConnectingSpace<CieXyz, CieXyz>
     public bool Equals(CieXyz other)
         => this.AsVector3Unsafe() == other.AsVector3Unsafe();
 
-    private Vector3 AsVector3Unsafe() => Unsafe.As<CieXyz, Vector3>(ref Unsafe.AsRef(in this));
+    internal Vector3 AsVector3Unsafe() => Unsafe.As<CieXyz, Vector3>(ref Unsafe.AsRef(in this));
 }

src/ImageSharp/ColorProfiles/Cmyk.cs

@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.ColorProfiles;
 
 /// <summary>
 /// Represents an CMYK (cyan, magenta, yellow, keyline) color.
+/// <see href="https://en.wikipedia.org/wiki/CMYK_color_model"/>
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
 public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
@@ -36,7 +37,18 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Cmyk(Vector4 vector)
     {
-        vector = Numerics.Clamp(vector, Min, Max);
+        vector = Vector4.Clamp(vector, Min, Max);
+        this.C = vector.X;
+        this.M = vector.Y;
+        this.Y = vector.Z;
+        this.K = vector.W;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Cmyk(Vector4 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
         this.C = vector.X;
         this.M = vector.Y;
         this.Y = vector.Z;
@@ -89,16 +101,42 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Cmyk left, Cmyk right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector4 v4 = default;
+        v4 += this.AsVector4Unsafe();
+        return v4;
+    }
+
+    /// <inheritdoc/>
+    public static Cmyk FromScaledVector4(Vector4 source)
+        => new(source, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Cmyk> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<Cmyk, Vector4>(source).CopyTo(destination);
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Cmyk> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<Vector4, Cmyk>(source).CopyTo(destination);
+    }
+
     /// <inheritdoc/>
     public static Cmyk FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
     {
         // To CMY
-        Vector3 cmy = Vector3.One - source.ToScaledVector3();
+        Vector3 cmy = Vector3.One - source.AsVector3Unsafe();
 
         // To CMYK
         Vector3 k = new(MathF.Min(cmy.X, MathF.Min(cmy.Y, cmy.Z)));
 
-        if (MathF.Abs(k.X - 1F) < Constants.Epsilon)
+        if (k.X >= 1F - Constants.Epsilon)
         {
             return new Cmyk(0, 0, 0, 1F);
         }
@@ -124,7 +162,7 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
     /// <inheritdoc/>
     public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
     {
-        Vector3 rgb = (Vector3.One - new Vector3(this.C, this.M, this.Y)) * (Vector3.One - new Vector3(this.K));
+        Vector3 rgb = (Vector3.One - new Vector3(this.C, this.M, this.Y)) * (1F - this.K);
         return Rgb.FromScaledVector3(rgb);
     }
 
@@ -134,8 +172,7 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
         // TODO: We can possibly optimize this by using SIMD
         for (int i = 0; i < source.Length; i++)
         {
-            Cmyk cmyk = source[i];
-            destination[i] = cmyk.ToProfileConnectingSpace(options);
+            destination[i] = source[i].ToProfileConnectingSpace(options);
         }
     }
 

src/ImageSharp/ColorProfiles/ColorConversionOptions.cs

@@ -4,6 +4,7 @@
 using System.Numerics;
 using SixLabors.ImageSharp.ColorProfiles.WorkingSpaces;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.ColorProfiles;
 
@@ -13,11 +14,16 @@ namespace SixLabors.ImageSharp.ColorProfiles;
 public class ColorConversionOptions
 {
     private Matrix4x4 adaptationMatrix;
+    private YCbCrMatrix yCbCrMatrix;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ColorConversionOptions"/> class.
     /// </summary>
-    public ColorConversionOptions() => this.AdaptationMatrix = KnownChromaticAdaptationMatrices.Bradford;
+    public ColorConversionOptions()
+    {
+        this.AdaptationMatrix = KnownChromaticAdaptationMatrices.Bradford;
+        this.YCbCrMatrix = KnownYCbCrMatrices.BT601;
+    }
 
     /// <summary>
     /// Gets the memory allocator.
@@ -27,7 +33,7 @@ public class ColorConversionOptions
     /// <summary>
     /// Gets the source white point used for chromatic adaptation in conversions from/to XYZ color space.
     /// </summary>
-    public CieXyz WhitePoint { get; init; } = KnownIlluminants.D50;
+    public CieXyz SourceWhitePoint { get; init; } = KnownIlluminants.D50;
 
     /// <summary>
     /// Gets the destination white point used for chromatic adaptation in conversions from/to XYZ color space.
@@ -37,13 +43,36 @@ public class ColorConversionOptions
     /// <summary>
     /// Gets the source working space used for companding in conversions from/to XYZ color space.
     /// </summary>
-    public RgbWorkingSpace RgbWorkingSpace { get; init; } = KnownRgbWorkingSpaces.SRgb;
+    public RgbWorkingSpace SourceRgbWorkingSpace { get; init; } = KnownRgbWorkingSpaces.SRgb;
 
     /// <summary>
     /// Gets the destination working space used for companding in conversions from/to XYZ color space.
     /// </summary>
     public RgbWorkingSpace TargetRgbWorkingSpace { get; init; } = KnownRgbWorkingSpaces.SRgb;
 
+    /// <summary>
+    /// Gets the YCbCr matrix to used to perform conversions from/to RGB.
+    /// </summary>
+    public YCbCrMatrix YCbCrMatrix
+    {
+        get => this.yCbCrMatrix;
+        init
+        {
+            this.yCbCrMatrix = value;
+            this.TransposedYCbCrMatrix = value.Transpose();
+        }
+    }
+
+    /// <summary>
+    /// Gets the source ICC profile.
+    /// </summary>
+    public IccProfile? SourceIccProfile { get; init; }
+
+    /// <summary>
+    /// Gets the target ICC profile.
+    /// </summary>
+    public IccProfile? TargetIccProfile { get; init; }
+
     /// <summary>
     /// Gets the transformation matrix used in conversion to perform chromatic adaptation.
     /// <see cref="KnownChromaticAdaptationMatrices"/> for further information. Default is Bradford.
@@ -54,10 +83,12 @@ public class ColorConversionOptions
         init
         {
             this.adaptationMatrix = value;
-            Matrix4x4.Invert(value, out Matrix4x4 inverted);
+            _ = Matrix4x4.Invert(value, out Matrix4x4 inverted);
             this.InverseAdaptationMatrix = inverted;
         }
     }
 
+    internal YCbCrMatrix TransposedYCbCrMatrix { get; private set; }
+
     internal Matrix4x4 InverseAdaptationMatrix { get; private set; }
 }

src/ImageSharp/ColorProfiles/ColorProfileConverter.cs

@@ -12,7 +12,7 @@ public class ColorProfileConverter
     /// Initializes a new instance of the <see cref="ColorProfileConverter"/> class.
     /// </summary>
     public ColorProfileConverter()
-    : this(new())
+        : this(new())
     {
     }
 
@@ -33,8 +33,8 @@ public class ColorProfileConverter
                where TTo : struct, IColorProfile
     {
         CieXyz sourceWhitePoint = TFrom.GetChromaticAdaptionWhitePointSource() == ChromaticAdaptionWhitePointSource.WhitePoint
-            ? this.Options.WhitePoint
-            : this.Options.RgbWorkingSpace.WhitePoint;
+            ? this.Options.SourceWhitePoint
+            : this.Options.SourceRgbWorkingSpace.WhitePoint;
 
         CieXyz targetWhitePoint = TTo.GetChromaticAdaptionWhitePointSource() == ChromaticAdaptionWhitePointSource.WhitePoint
             ? this.Options.TargetWhitePoint
@@ -42,4 +42,7 @@ public class ColorProfileConverter
 
         return (sourceWhitePoint, targetWhitePoint);
     }
+
+    internal bool ShouldUseIccProfiles()
+        => this.Options.SourceIccProfile != null && this.Options.TargetIccProfile != null;
 }

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieLab.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieLabCieLab
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsCieLabCieLab
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieXyz.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieLabCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsCieLabCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabRgb.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieLabRgb
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsCieLabRgb
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieLab.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieXyzCieLab
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsCieXyzCieLab
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieXyz.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieXyzCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -29,6 +34,12 @@ internal static class ColorProfileConverterExtensionsCieXyzCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzRgb.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieXyzRgb
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsCieXyzRgb
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsIcc.cs

@@ -0,0 +1,731 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+internal static class ColorProfileConverterExtensionsIcc
+{
+    private static readonly float[] PcsV2FromBlackPointScale =
+        [0.9965153F, 0.9965269F, 0.9965208F, 1F,
+         0.9965153F, 0.9965269F, 0.9965208F, 1F,
+         0.9965153F, 0.9965269F, 0.9965208F, 1F,
+         0.9965153F, 0.9965269F, 0.9965208F, 1F];
+
+    private static readonly float[] PcsV2FromBlackPointOffset =
+        [0.00336F, 0.0034731F, 0.00287F, 0F,
+         0.00336F, 0.0034731F, 0.00287F, 0F,
+         0.00336F, 0.0034731F, 0.00287F, 0F,
+         0.00336F, 0.0034731F, 0.00287F, 0F];
+
+    private static readonly float[] PcsV2ToBlackPointScale =
+        [1.0034969F, 1.0034852F, 1.0034913F, 1F,
+         1.0034969F, 1.0034852F, 1.0034913F, 1F,
+         1.0034969F, 1.0034852F, 1.0034913F, 1F,
+         1.0034969F, 1.0034852F, 1.0034913F, 1F];
+
+    private static readonly float[] PcsV2ToBlackPointOffset =
+        [0.0033717495F, 0.0034852044F, 0.0028800198F, 0F,
+         0.0033717495F, 0.0034852044F, 0.0028800198F, 0F,
+         0.0033717495F, 0.0034852044F, 0.0028800198F, 0F,
+         0.0033717495F, 0.0034852044F, 0.0028800198F, 0F];
+
+    internal static TTo ConvertUsingIccProfile<TFrom, TTo>(this ColorProfileConverter converter, in TFrom source)
+        where TFrom : struct, IColorProfile<TFrom>
+        where TTo : struct, IColorProfile<TTo>
+    {
+        // TODO: Validation of ICC Profiles against color profile. Is this possible?
+        if (converter.Options.SourceIccProfile is null)
+        {
+            throw new InvalidOperationException("Source ICC profile is missing.");
+        }
+
+        if (converter.Options.TargetIccProfile is null)
+        {
+            throw new InvalidOperationException("Target ICC profile is missing.");
+        }
+
+        ConversionParams sourceParams = new(converter.Options.SourceIccProfile, toPcs: true);
+        ConversionParams targetParams = new(converter.Options.TargetIccProfile, toPcs: false);
+
+        ColorProfileConverter pcsConverter = new(new ColorConversionOptions
+        {
+            MemoryAllocator = converter.Options.MemoryAllocator,
+            SourceWhitePoint = new CieXyz(converter.Options.SourceIccProfile.Header.PcsIlluminant),
+            TargetWhitePoint = new CieXyz(converter.Options.TargetIccProfile.Header.PcsIlluminant),
+        });
+
+        // Normalize the source, then convert to the PCS space.
+        Vector4 sourcePcs = sourceParams.Converter.Calculate(source.ToScaledVector4());
+
+        // If both profiles need PCS adjustment, they both share the same unadjusted PCS space
+        // cancelling out the need to make the adjustment
+        // except if using TRC transforms, which always requires perceptual handling
+        // TODO: this does not include adjustment for absolute intent, which would double existing complexity, suggest throwing exception and addressing in future update
+        bool anyProfileNeedsPerceptualAdjustment = sourceParams.HasNoPerceptualHandling || targetParams.HasNoPerceptualHandling;
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        Vector4 targetPcs = anyProfileNeedsPerceptualAdjustment || oneProfileHasV2PerceptualAdjustment
+            ? GetTargetPcsWithPerceptualAdjustment(sourcePcs, sourceParams, targetParams, pcsConverter)
+            : GetTargetPcsWithoutAdjustment(sourcePcs, sourceParams, targetParams, pcsConverter);
+
+        return TTo.FromScaledVector4(targetParams.Converter.Calculate(targetPcs));
+    }
+
+    internal static void ConvertUsingIccProfile<TFrom, TTo>(this ColorProfileConverter converter, ReadOnlySpan<TFrom> source, Span<TTo> destination)
+        where TFrom : struct, IColorProfile<TFrom>
+        where TTo : struct, IColorProfile<TTo>
+    {
+        // TODO: Validation of ICC Profiles against color profile. Is this possible?
+        if (converter.Options.SourceIccProfile is null)
+        {
+            throw new InvalidOperationException("Source ICC profile is missing.");
+        }
+
+        if (converter.Options.TargetIccProfile is null)
+        {
+            throw new InvalidOperationException("Target ICC profile is missing.");
+        }
+
+        Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(destination));
+
+        ConversionParams sourceParams = new(converter.Options.SourceIccProfile, toPcs: true);
+        ConversionParams targetParams = new(converter.Options.TargetIccProfile, toPcs: false);
+
+        ColorProfileConverter pcsConverter = new(new ColorConversionOptions
+        {
+            MemoryAllocator = converter.Options.MemoryAllocator,
+            SourceWhitePoint = new CieXyz(converter.Options.SourceIccProfile.Header.PcsIlluminant),
+            TargetWhitePoint = new CieXyz(converter.Options.TargetIccProfile.Header.PcsIlluminant),
+        });
+
+        using IMemoryOwner<Vector4> pcsBuffer = converter.Options.MemoryAllocator.Allocate<Vector4>(source.Length);
+        Span<Vector4> pcs = pcsBuffer.GetSpan();
+
+        // Normalize the source, then convert to the PCS space.
+        TFrom.ToScaledVector4(source, pcs);
+        sourceParams.Converter.Calculate(pcs, pcs);
+
+        // If both profiles need PCS adjustment, they both share the same unadjusted PCS space
+        // cancelling out the need to make the adjustment
+        // except if using TRC transforms, which always requires perceptual handling
+        // TODO: this does not include adjustment for absolute intent, which would double existing complexity, suggest throwing exception and addressing in future update
+        bool anyProfileNeedsPerceptualAdjustment = sourceParams.HasNoPerceptualHandling || targetParams.HasNoPerceptualHandling;
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        if (anyProfileNeedsPerceptualAdjustment || oneProfileHasV2PerceptualAdjustment)
+        {
+            GetTargetPcsWithPerceptualAdjustment(pcs, sourceParams, targetParams, pcsConverter);
+        }
+        else
+        {
+            GetTargetPcsWithoutAdjustment(pcs, sourceParams, targetParams, pcsConverter);
+        }
+
+        // Convert to the target space.
+        targetParams.Converter.Calculate(pcs, pcs);
+        TTo.FromScaledVector4(pcs, destination);
+    }
+
+    private static Vector4 GetTargetPcsWithoutAdjustment(
+        Vector4 sourcePcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // Profile connecting spaces can only be Lab, XYZ.
+        // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+        // so ensure that Lab is using the correct encoding when a 16-bit LUT is used
+        switch (sourceParams.PcsType)
+        {
+            // Convert from Lab to XYZ.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                sourcePcs = sourceParams.Is16BitLutEntry ? LabV2ToLab(sourcePcs) : sourcePcs;
+                CieLab lab = CieLab.FromScaledVector4(sourcePcs);
+                CieXyz xyz = pcsConverter.Convert<CieLab, CieXyz>(in lab);
+                return xyz.ToScaledVector4();
+            }
+
+            // Convert from XYZ to Lab.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                CieXyz xyz = CieXyz.FromScaledVector4(sourcePcs);
+                CieLab lab = pcsConverter.Convert<CieXyz, CieLab>(in xyz);
+                Vector4 targetPcs = lab.ToScaledVector4();
+                return targetParams.Is16BitLutEntry ? LabToLabV2(targetPcs) : targetPcs;
+            }
+
+            // Convert from XYZ to XYZ.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                CieXyz xyz = CieXyz.FromScaledVector4(sourcePcs);
+                CieXyz targetXyz = pcsConverter.Convert<CieXyz, CieXyz>(in xyz);
+                return targetXyz.ToScaledVector4();
+            }
+
+            // Convert from Lab to Lab.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                // if both source and target LUT use same v2 LAB encoding, no need to correct them
+                if (sourceParams.Is16BitLutEntry && targetParams.Is16BitLutEntry)
+                {
+                    CieLab sourceLab = CieLab.FromScaledVector4(sourcePcs);
+                    CieLab targetLab = pcsConverter.Convert<CieLab, CieLab>(in sourceLab);
+                    return targetLab.ToScaledVector4();
+                }
+                else
+                {
+                    sourcePcs = sourceParams.Is16BitLutEntry ? LabV2ToLab(sourcePcs) : sourcePcs;
+                    CieLab sourceLab = CieLab.FromScaledVector4(sourcePcs);
+                    CieLab targetLab = pcsConverter.Convert<CieLab, CieLab>(in sourceLab);
+                    Vector4 targetPcs = targetLab.ToScaledVector4();
+                    return targetParams.Is16BitLutEntry ? LabToLabV2(targetPcs) : targetPcs;
+                }
+            }
+
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} to target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    private static void GetTargetPcsWithoutAdjustment(
+        Span<Vector4> pcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // Profile connecting spaces can only be Lab, XYZ.
+        // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+        // so ensure that Lab is using the correct encoding when a 16-bit LUT is used
+        switch (sourceParams.PcsType)
+        {
+            // Convert from Lab to XYZ.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                if (sourceParams.Is16BitLutEntry)
+                {
+                    LabV2ToLab(pcs, pcs);
+                }
+
+                using IMemoryOwner<CieLab> pcsFromBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsFrom = pcsFromBuffer.GetSpan();
+
+                using IMemoryOwner<CieXyz> pcsToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+                Span<CieXyz> pcsTo = pcsToBuffer.GetSpan();
+
+                CieLab.FromScaledVector4(pcs, pcsFrom);
+                pcsConverter.Convert<CieLab, CieXyz>(pcsFrom, pcsTo);
+
+                CieXyz.ToScaledVector4(pcsTo, pcs);
+                break;
+            }
+
+            // Convert from XYZ to Lab.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                using IMemoryOwner<CieXyz> pcsFromBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+                Span<CieXyz> pcsFrom = pcsFromBuffer.GetSpan();
+
+                using IMemoryOwner<CieLab> pcsToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsTo = pcsToBuffer.GetSpan();
+
+                CieXyz.FromScaledVector4(pcs, pcsFrom);
+                pcsConverter.Convert<CieXyz, CieLab>(pcsFrom, pcsTo);
+
+                CieLab.ToScaledVector4(pcsTo, pcs);
+
+                if (targetParams.Is16BitLutEntry)
+                {
+                    LabToLabV2(pcs, pcs);
+                }
+
+                break;
+            }
+
+            // Convert from XYZ to XYZ.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                using IMemoryOwner<CieXyz> pcsFromToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+                Span<CieXyz> pcsFromTo = pcsFromToBuffer.GetSpan();
+
+                CieXyz.FromScaledVector4(pcs, pcsFromTo);
+                pcsConverter.Convert<CieXyz, CieXyz>(pcsFromTo, pcsFromTo);
+
+                CieXyz.ToScaledVector4(pcsFromTo, pcs);
+                break;
+            }
+
+            // Convert from Lab to Lab.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                using IMemoryOwner<CieLab> pcsFromToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsFromTo = pcsFromToBuffer.GetSpan();
+
+                // if both source and target LUT use same v2 LAB encoding, no need to correct them
+                if (sourceParams.Is16BitLutEntry && targetParams.Is16BitLutEntry)
+                {
+                    CieLab.FromScaledVector4(pcs, pcsFromTo);
+                    pcsConverter.Convert<CieLab, CieLab>(pcsFromTo, pcsFromTo);
+                    CieLab.ToScaledVector4(pcsFromTo, pcs);
+                }
+                else
+                {
+                    if (sourceParams.Is16BitLutEntry)
+                    {
+                        LabV2ToLab(pcs, pcs);
+                    }
+
+                    CieLab.FromScaledVector4(pcs, pcsFromTo);
+                    pcsConverter.Convert<CieLab, CieLab>(pcsFromTo, pcsFromTo);
+                    CieLab.ToScaledVector4(pcsFromTo, pcs);
+
+                    if (targetParams.Is16BitLutEntry)
+                    {
+                        LabToLabV2(pcs, pcs);
+                    }
+                }
+
+                break;
+            }
+
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} to target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    /// <summary>
+    /// Effectively this is <see cref="GetTargetPcsWithoutAdjustment(Vector4, ConversionParams, ConversionParams, ColorProfileConverter)"/> with an extra step in the middle.
+    /// It adjusts PCS by compensating for the black point used for perceptual intent in v2 profiles.
+    /// The adjustment needs to be performed in XYZ space, potentially an overhead of 2 more conversions.
+    /// Not required if both spaces need V2 correction, since they both have the same understanding of the PCS.
+    /// Not compatible with PCS adjustment for absolute intent.
+    /// </summary>
+    /// <param name="sourcePcs">The source PCS values.</param>
+    /// <param name="sourceParams">The source profile parameters.</param>
+    /// <param name="targetParams">The target profile parameters.</param>
+    /// <param name="pcsConverter">The converter to use for the PCS adjustments.</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the source or target PCS is not supported.</exception>
+    private static Vector4 GetTargetPcsWithPerceptualAdjustment(
+        Vector4 sourcePcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // all conversions are funneled through XYZ in case PCS adjustments need to be made
+        CieXyz xyz;
+
+        switch (sourceParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab to modern v4 encoding when returned from a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+                sourcePcs = sourceParams.Is16BitLutEntry ? LabV2ToLab(sourcePcs) : sourcePcs;
+                CieLab lab = CieLab.FromScaledVector4(sourcePcs);
+                xyz = pcsConverter.Convert<CieLab, CieXyz>(in lab);
+                break;
+            case IccColorSpaceType.CieXyz:
+                xyz = CieXyz.FromScaledVector4(sourcePcs);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} is not supported");
+        }
+
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        // when converting from device to PCS with v2 perceptual intent
+        // the black point needs to be adjusted to v4 after converting the PCS values
+        if (sourceParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && sourceParams.HasV2PerceptualHandling))
+        {
+            Vector3 vector = xyz.ToVector3();
+
+            // when using LAB PCS, negative values are clipped before PCS adjustment (in DemoIccMAX)
+            if (sourceParams.PcsType == IccColorSpaceType.CieLab)
+            {
+                vector = Vector3.Max(vector, Vector3.Zero);
+            }
+
+            xyz = new CieXyz(AdjustPcsFromV2BlackPoint(vector));
+        }
+
+        // when converting from PCS to device with v2 perceptual intent
+        // the black point needs to be adjusted to v2 before converting the PCS values
+        if (targetParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && targetParams.HasV2PerceptualHandling))
+        {
+            Vector3 vector = AdjustPcsToV2BlackPoint(xyz.AsVector3Unsafe());
+
+            // when using XYZ PCS, negative values are clipped after PCS adjustment (in DemoIccMAX)
+            if (targetParams.PcsType == IccColorSpaceType.CieXyz)
+            {
+                vector = Vector3.Max(vector, Vector3.Zero);
+            }
+
+            xyz = new CieXyz(vector);
+        }
+
+        switch (targetParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab back to legacy encoding before using in a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+                CieLab lab = pcsConverter.Convert<CieXyz, CieLab>(in xyz);
+                Vector4 targetPcs = lab.ToScaledVector4();
+                return targetParams.Is16BitLutEntry ? LabToLabV2(targetPcs) : targetPcs;
+            case IccColorSpaceType.CieXyz:
+                return xyz.ToScaledVector4();
+            default:
+                throw new ArgumentOutOfRangeException($"Target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    /// <summary>
+    /// Effectively this is <see cref="GetTargetPcsWithoutAdjustment(Span{Vector4}, ConversionParams, ConversionParams, ColorProfileConverter)"/> with an extra step in the middle.
+    /// It adjusts PCS by compensating for the black point used for perceptual intent in v2 profiles.
+    /// The adjustment needs to be performed in XYZ space, potentially an overhead of 2 more conversions.
+    /// Not required if both spaces need V2 correction, since they both have the same understanding of the PCS.
+    /// Not compatible with PCS adjustment for absolute intent.
+    /// </summary>
+    /// <param name="pcs">The PCS values from the source.</param>
+    /// <param name="sourceParams">The source profile parameters.</param>
+    /// <param name="targetParams">The target profile parameters.</param>
+    /// <param name="pcsConverter">The converter to use for the PCS adjustments.</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the source or target PCS is not supported.</exception>
+    private static void GetTargetPcsWithPerceptualAdjustment(
+        Span<Vector4> pcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // All conversions are funneled through XYZ in case PCS adjustments need to be made
+        using IMemoryOwner<CieXyz> xyzBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+        Span<CieXyz> xyz = xyzBuffer.GetSpan();
+
+        switch (sourceParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab to modern v4 encoding when returned from a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+            {
+                if (sourceParams.Is16BitLutEntry)
+                {
+                    LabV2ToLab(pcs, pcs);
+                }
+
+                using IMemoryOwner<CieLab> pcsFromBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsFrom = pcsFromBuffer.GetSpan();
+                CieLab.FromScaledVector4(pcs, pcsFrom);
+                pcsConverter.Convert<CieLab, CieXyz>(pcsFrom, xyz);
+                break;
+            }
+
+            case IccColorSpaceType.CieXyz:
+                CieXyz.FromScaledVector4(pcs, xyz);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} is not supported");
+        }
+
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        using IMemoryOwner<Vector4> vectorBuffer = pcsConverter.Options.MemoryAllocator.Allocate<Vector4>(pcs.Length);
+        Span<Vector4> vector = vectorBuffer.GetSpan();
+
+        // When converting from device to PCS with v2 perceptual intent
+        // the black point needs to be adjusted to v4 after converting the PCS values
+        if (sourceParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && sourceParams.HasV2PerceptualHandling))
+        {
+            CieXyz.ToVector4(xyz, vector);
+
+            // When using LAB PCS, negative values are clipped before PCS adjustment (in DemoIccMAX)
+            if (sourceParams.PcsType == IccColorSpaceType.CieLab)
+            {
+                ClipNegative(vector);
+            }
+
+            AdjustPcsFromV2BlackPoint(vector, vector);
+            CieXyz.FromVector4(vector, xyz);
+        }
+
+        // When converting from PCS to device with v2 perceptual intent
+        // the black point needs to be adjusted to v2 before converting the PCS values
+        if (targetParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && targetParams.HasV2PerceptualHandling))
+        {
+            CieXyz.ToVector4(xyz, vector);
+            AdjustPcsToV2BlackPoint(vector, vector);
+
+            // When using XYZ PCS, negative values are clipped after PCS adjustment (in DemoIccMAX)
+            if (targetParams.PcsType == IccColorSpaceType.CieXyz)
+            {
+                ClipNegative(vector);
+            }
+
+            CieXyz.FromVector4(vector, xyz);
+        }
+
+        switch (targetParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab back to legacy encoding before using in a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+            {
+                using IMemoryOwner<CieLab> pcsToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsTo = pcsToBuffer.GetSpan();
+                pcsConverter.Convert<CieXyz, CieLab>(xyz, pcsTo);
+
+                CieLab.ToScaledVector4(pcsTo, pcs);
+
+                if (targetParams.Is16BitLutEntry)
+                {
+                    LabToLabV2(pcs, pcs);
+                }
+
+                break;
+            }
+
+            case IccColorSpaceType.CieXyz:
+                CieXyz.ToScaledVector4(xyz, pcs);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"Target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    // as per DemoIccMAX icPerceptual values in IccCmm.h
+    // refBlack = 0.00336F, 0.0034731F, 0.00287F
+    // refWhite = 0.9642F, 1.0000F, 0.8249F
+    // scale = 1 - (refBlack / refWhite)
+    // offset = refBlack
+    private static Vector3 AdjustPcsFromV2BlackPoint(Vector3 xyz)
+        => (xyz * new Vector3(0.9965153F, 0.9965269F, 0.9965208F)) + new Vector3(0.00336F, 0.0034731F, 0.00287F);
+
+    // as per DemoIccMAX icPerceptual values in IccCmm.h
+    // refBlack = 0.00336F, 0.0034731F, 0.00287F
+    // refWhite = 0.9642F, 1.0000F, 0.8249F
+    // scale = 1 / (1 - (refBlack / refWhite))
+    // offset = -refBlack * scale
+    private static Vector3 AdjustPcsToV2BlackPoint(Vector3 xyz)
+        => (xyz * new Vector3(1.0034969F, 1.0034852F, 1.0034913F)) - new Vector3(0.0033717495F, 0.0034852044F, 0.0028800198F);
+
+    private static void AdjustPcsFromV2BlackPoint(Span<Vector4> source, Span<Vector4> destination)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported &&
+            Vector<float>.Count <= Vector512<float>.Count &&
+            source.Length * 4 >= Vector<float>.Count)
+        {
+            // TODO: Check our constants. They may require scaling.
+            Vector<float> vScale = new(PcsV2FromBlackPointScale.AsSpan()[..Vector<float>.Count]);
+            Vector<float> vOffset = new(PcsV2FromBlackPointOffset.AsSpan()[..Vector<float>.Count]);
+
+            // SIMD loop
+            int i = 0;
+            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 and offset the vector
+                v *= vScale;
+                v += vOffset;
+
+                // Write the 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++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(0.9965153F, 0.9965269F, 0.9965208F, 1F);
+                s += new Vector4(0.00336F, 0.0034731F, 0.00287F, 0F);
+                destination[i] = s;
+            }
+        }
+        else
+        {
+            // Scalar fallback if SIMD is not supported
+            for (int i = 0; i < source.Length; i++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(0.9965153F, 0.9965269F, 0.9965208F, 1F);
+                s += new Vector4(0.00336F, 0.0034731F, 0.00287F, 0F);
+                destination[i] = s;
+            }
+        }
+    }
+
+    private static void AdjustPcsToV2BlackPoint(Span<Vector4> source, Span<Vector4> destination)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported &&
+            Vector<float>.Count <= Vector512<float>.Count &&
+            source.Length * 4 >= Vector<float>.Count)
+        {
+            // TODO: Check our constants. They may require scaling.
+            Vector<float> vScale = new(PcsV2ToBlackPointScale.AsSpan()[..Vector<float>.Count]);
+            Vector<float> vOffset = new(PcsV2ToBlackPointOffset.AsSpan()[..Vector<float>.Count]);
+
+            // SIMD loop
+            int i = 0;
+            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 and offset the vector
+                v *= vScale;
+                v -= vOffset;
+
+                // Write the 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++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(1.0034969F, 1.0034852F, 1.0034913F, 1F);
+                s -= new Vector4(0.0033717495F, 0.0034852044F, 0.0028800198F, 0F);
+                destination[i] = s;
+            }
+        }
+        else
+        {
+            // Scalar fallback if SIMD is not supported
+            for (int i = 0; i < source.Length; i++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(1.0034969F, 1.0034852F, 1.0034913F, 1F);
+                s -= new Vector4(0.0033717495F, 0.0034852044F, 0.0028800198F, 0F);
+                destination[i] = s;
+            }
+        }
+    }
+
+    private static void ClipNegative(Span<Vector4> source)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported && Vector<float>.Count >= source.Length * 4)
+        {
+            // SIMD loop
+            int i = 0;
+            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)]
+    private static Vector4 LabToLabV2(Vector4 input)
+        => input * 65280F / 65535F;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector4 LabV2ToLab(Vector4 input)
+        => input * 65535F / 65280F;
+
+    private static void LabToLabV2(Span<Vector4> source, Span<Vector4> destination)
+        => LabToLab(source, destination, 65280F / 65535F);
+
+    private static void LabV2ToLab(Span<Vector4> source, Span<Vector4> destination)
+        => LabToLab(source, destination, 65535F / 65280F);
+
+    private static void LabToLab(Span<Vector4> source, Span<Vector4> destination, [ConstantExpected] float scale)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported)
+        {
+            Vector<float> vScale = new(scale);
+            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
+    {
+        private readonly IccProfile profile;
+
+        internal ConversionParams(IccProfile profile, bool toPcs)
+        {
+            this.profile = profile;
+            this.Converter = toPcs ? new IccDataToPcsConverter(profile) : new IccPcsToDataConverter(profile);
+        }
+
+        internal IccConverterBase Converter { get; }
+
+        internal IccProfileHeader Header => this.profile.Header;
+
+        internal IccRenderingIntent Intent => this.Header.RenderingIntent;
+
+        internal IccColorSpaceType PcsType => this.Header.ProfileConnectionSpace;
+
+        internal IccVersion Version => this.Header.Version;
+
+        internal bool HasV2PerceptualHandling => this.Intent == IccRenderingIntent.Perceptual && this.Version.Major == 2;
+
+        internal bool HasNoPerceptualHandling => this.Intent == IccRenderingIntent.Perceptual && this.Converter.IsTrc;
+
+        internal bool Is16BitLutEntry => this.Converter.Is16BitLutEntry;
+    }
+}

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieLab.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsRgbCieLab
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsRgbCieLab
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieXyz.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsRgbCieXyz
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsRgbCieXyz
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbRgb.cs

@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsRgbRgb
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsRgbRgb
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.

src/ImageSharp/ColorProfiles/Hsl.cs

@@ -41,6 +41,16 @@ public readonly struct Hsl : IColorProfile<Hsl, Rgb>
         this.L = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Hsl(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.H = vector.X;
+        this.S = vector.Y;
+        this.L = vector.Z;
+    }
+
     /// <summary>
     /// Gets the hue component.
     /// <remarks>A value ranging between 0 and 360.</remarks>
@@ -83,6 +93,38 @@ public readonly struct Hsl : IColorProfile<Hsl, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Hsl left, Hsl right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+        => new(this.AsVector3Unsafe() / 360F, 1F);
+
+    /// <inheritdoc/>
+    public static Hsl FromScaledVector4(Vector4 source)
+        => new(source.AsVector3() * 360F, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Hsl> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Hsl> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static Hsl FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
     {

src/ImageSharp/ColorProfiles/Hsv.cs

@@ -41,6 +41,16 @@ public readonly struct Hsv : IColorProfile<Hsv, Rgb>
         this.V = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Hsv(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.H = vector.X;
+        this.S = vector.Y;
+        this.V = vector.Z;
+    }
+
     /// <summary>
     /// Gets the hue component.
     /// <remarks>A value ranging between 0 and 360.</remarks>
@@ -81,6 +91,38 @@ public readonly struct Hsv : IColorProfile<Hsv, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Hsv left, Hsv right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+        => new(this.AsVector3Unsafe() / 360F, 1F);
+
+    /// <inheritdoc/>
+    public static Hsv FromScaledVector4(Vector4 source)
+        => new(source.AsVector3() * 360F, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Hsv> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Hsv> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static Hsv FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
     {

src/ImageSharp/ColorProfiles/HunterLab.cs

@@ -80,6 +80,49 @@ public readonly struct HunterLab : IColorProfile<HunterLab, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(HunterLab left, HunterLab right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 128F, 128F);
+        v3 /= new Vector3(100F, 255F, 255F);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static HunterLab FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100F, 255, 255);
+        v3 -= new Vector3(0, 128F, 128F);
+        return new HunterLab(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<HunterLab> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<HunterLab> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static HunterLab FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
@@ -127,7 +170,7 @@ public readonly struct HunterLab : IColorProfile<HunterLab, CieXyz>
     {
         // Conversion algorithm described here:
         // http://en.wikipedia.org/wiki/Lab_color_space#Hunter_Lab
-        CieXyz whitePoint = options.WhitePoint;
+        CieXyz whitePoint = options.SourceWhitePoint;
         float l = this.L, a = this.A, b = this.B;
         float xn = whitePoint.X, yn = whitePoint.Y, zn = whitePoint.Z;
 

src/ImageSharp/ColorProfiles/IColorProfile.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
+
 namespace SixLabors.ImageSharp.ColorProfiles;
 
 /// <summary>
@@ -15,18 +17,60 @@ public interface IColorProfile
     public static abstract ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource();
 }
 
+/// <summary>
+/// Defines the contract for all color profiles.
+/// </summary>
+/// <typeparam name="TSelf">The type of color profile.</typeparam>
+public interface IColorProfile<TSelf> : IColorProfile, IEquatable<TSelf>
+    where TSelf : IColorProfile<TSelf>
+{
+    /// <summary>
+    /// Expands the pixel into a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// The vector components are typically expanded in least to greatest significance order.
+    /// </summary>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    public Vector4 ToScaledVector4();
+
+#pragma warning disable CA1000 // Do not declare static members on generic types
+    /// <summary>
+    /// Initializes the color instance from a generic a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// </summary>
+    /// <param name="source">The vector to load the pixel from.</param>
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    public static abstract TSelf FromScaledVector4(Vector4 source);
+
+    /// <summary>
+    /// Converts the span of colors to a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// </summary>
+    /// <param name="source">The color span to convert from.</param>
+    /// <param name="destination">The vector span to write the results to.</param>
+    public static abstract void ToScaledVector4(ReadOnlySpan<TSelf> source, Span<Vector4> destination);
+
+    /// <summary>
+    /// Converts the span of colors from a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// </summary>
+    /// <param name="source">The vector span to convert from.</param>
+    /// <param name="destination">The color span to write the results to.</param>
+    public static abstract void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<TSelf> destination);
+#pragma warning restore CA1000 // Do not declare static members on generic types
+}
+
 /// <summary>
 /// Defines the contract for all color profiles.
 /// </summary>
 /// <typeparam name="TSelf">The type of color profile.</typeparam>
 /// <typeparam name="TProfileSpace">The type of color profile connecting space.</typeparam>
-public interface IColorProfile<TSelf, TProfileSpace> : IColorProfile, IEquatable<TSelf>
+public interface IColorProfile<TSelf, TProfileSpace> : IColorProfile<TSelf>
     where TSelf : IColorProfile<TSelf, TProfileSpace>
     where TProfileSpace : struct, IProfileConnectingSpace
 {
 #pragma warning disable CA1000 // Do not declare static members on generic types
     /// <summary>
-    /// Converts the color from the profile connection space.
+    /// Initializes the color instance from the profile connection space.
     /// </summary>
     /// <param name="options">The color profile conversion options.</param>
     /// <param name="source">The color profile connecting space.</param>

src/ImageSharp/ColorProfiles/Icc/Calculators/ClutCalculator.cs

@@ -0,0 +1,506 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Implements interpolation methods for color profile lookup tables.
+/// Adapted from ICC Reference implementation:
+/// https://github.com/InternationalColorConsortium/DemoIccMAX/blob/79ecb74135ad47bac7d42692905a079839b7e105/IccProfLib/IccTagLut.cpp
+/// </summary>
+internal class ClutCalculator : IVector4Calculator
+{
+    private readonly int inputCount;
+    private readonly int outputCount;
+    private readonly float[] lut;
+    private readonly byte[] gridPointCount;
+    private readonly byte[] maxGridPoint;
+    private readonly int[] indexFactor;
+    private readonly int[] dimSize;
+    private readonly int nodeCount;
+    private readonly float[][] nodes;
+    private readonly float[] g;
+    private readonly uint[] ig;
+    private readonly float[] s;
+    private readonly float[] df;
+    private readonly uint[] nPower;
+    private int n000;
+    private int n001;
+    private int n010;
+    private int n011;
+    private int n100;
+    private int n101;
+    private int n110;
+    private int n111;
+    private int n1000;
+
+    public ClutCalculator(IccClut clut)
+    {
+        Guard.NotNull(clut, nameof(clut));
+        Guard.MustBeGreaterThan(clut.InputChannelCount, 0, nameof(clut.InputChannelCount));
+        Guard.MustBeGreaterThan(clut.OutputChannelCount, 0, nameof(clut.OutputChannelCount));
+
+        this.inputCount = clut.InputChannelCount;
+        this.outputCount = clut.OutputChannelCount;
+        this.g = new float[this.inputCount];
+        this.ig = new uint[this.inputCount];
+        this.s = new float[this.inputCount];
+        this.nPower = new uint[16];
+        this.lut = clut.Values;
+        this.nodeCount = (int)Math.Pow(2, clut.InputChannelCount);
+        this.df = new float[this.nodeCount];
+        this.nodes = new float[this.nodeCount][];
+        this.dimSize = new int[this.inputCount];
+        this.gridPointCount = clut.GridPointCount;
+        this.maxGridPoint = new byte[this.inputCount];
+        for (int i = 0; i < this.inputCount; i++)
+        {
+            this.maxGridPoint[i] = (byte)(this.gridPointCount[i] - 1);
+        }
+
+        this.dimSize[this.inputCount - 1] = this.outputCount;
+        for (int i = this.inputCount - 2; i >= 0; i--)
+        {
+            this.dimSize[i] = this.dimSize[i + 1] * this.gridPointCount[i + 1];
+        }
+
+        this.indexFactor = this.CalculateIndexFactor();
+    }
+
+    public unsafe Vector4 Calculate(Vector4 value)
+    {
+        Vector4 result = default;
+        switch (this.inputCount)
+        {
+            case 1:
+                this.Interpolate1d((float*)&value, (float*)&result);
+                break;
+            case 2:
+                this.Interpolate2d((float*)&value, (float*)&result);
+                break;
+            case 3:
+                this.Interpolate3d((float*)&value, (float*)&result);
+                break;
+            case 4:
+                this.Interpolate4d((float*)&value, (float*)&result);
+                break;
+            default:
+                this.InterpolateNd((float*)&value, (float*)&result);
+                break;
+        }
+
+        return result;
+    }
+
+    private int[] CalculateIndexFactor()
+    {
+        int[] factors = new int[16];
+        switch (this.inputCount)
+        {
+            case 1:
+                factors[0] = this.n000 = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                break;
+            case 2:
+                factors[0] = this.n000 = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                factors[2] = this.n010 = this.dimSize[1];
+                factors[3] = this.n011 = this.n001 + this.n010;
+                break;
+            case 3:
+                factors[0] = this.n000 = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                factors[2] = this.n010 = this.dimSize[1];
+                factors[3] = this.n011 = this.n001 + this.n010;
+                factors[4] = this.n100 = this.dimSize[2];
+                factors[5] = this.n101 = this.n100 + this.n001;
+                factors[6] = this.n110 = this.n100 + this.n010;
+                factors[7] = this.n111 = this.n110 + this.n001;
+                break;
+            case 4:
+                factors[0] = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                factors[2] = this.n010 = this.dimSize[1];
+                factors[3] = factors[2] + factors[1];
+                factors[4] = this.n100 = this.dimSize[2];
+                factors[5] = factors[4] + factors[1];
+                factors[6] = factors[4] + factors[2];
+                factors[7] = factors[4] + factors[3];
+                factors[8] = this.n1000 = this.dimSize[3];
+                factors[9] = factors[8] + factors[1];
+                factors[10] = factors[8] + factors[2];
+                factors[11] = factors[8] + factors[3];
+                factors[12] = factors[8] + factors[4];
+                factors[13] = factors[8] + factors[5];
+                factors[14] = factors[8] + factors[6];
+                factors[15] = factors[8] + factors[7];
+                break;
+            default:
+                // Initialize ND interpolation variables.
+                factors[0] = 0;
+                int count;
+                for (count = 0; count < this.inputCount; count++)
+                {
+                    this.nPower[count] = (uint)(1 << (this.inputCount - 1 - count));
+                }
+
+                uint[] nPower = [0, 1];
+                count = 0;
+                int nFlag = 1;
+                for (uint j = 1; j < this.nodeCount; j++)
+                {
+                    if (j == nPower[1])
+                    {
+                        factors[j] = this.dimSize[count];
+                        nPower[0] = (uint)(1 << count);
+                        count++;
+                        nPower[1] = (uint)(1 << count);
+                        nFlag = 1;
+                    }
+                    else
+                    {
+                        factors[j] = factors[nPower[0]] + factors[nFlag];
+                        nFlag++;
+                    }
+                }
+
+                break;
+        }
+
+        return factors;
+    }
+
+    /// <summary>
+    /// One dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate1d(float* srcPixel, float* destPixel)
+    {
+        byte mx = this.maxGridPoint[0];
+
+        float x = UnitClip(srcPixel[0]) * mx;
+
+        uint ix = (uint)x;
+
+        float u = x - ix;
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        float nu = (float)(1.0 - u);
+
+        int i;
+        Span<float> p = this.lut.AsSpan((int)(ix * this.n001));
+
+        // Normalize grid units.
+        float dF0 = nu;
+        float dF1 = u;
+
+        int offset = 0;
+        for (i = 0; i < this.outputCount; i++)
+        {
+            destPixel[i] = (float)((p[offset + this.n000] * dF0) + (p[offset + this.n001] * dF1));
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Two dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate2d(float* srcPixel, float* destPixel)
+    {
+        byte mx = this.maxGridPoint[0];
+        byte my = this.maxGridPoint[1];
+
+        float x = UnitClip(srcPixel[0]) * mx;
+        float y = UnitClip(srcPixel[1]) * my;
+
+        uint ix = (uint)x;
+        uint iy = (uint)y;
+
+        float u = x - ix;
+        float t = y - iy;
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        if (iy == my)
+        {
+            iy--;
+            t = 1.0f;
+        }
+
+        float nt = (float)(1.0 - t);
+        float nu = (float)(1.0 - u);
+
+        int i;
+        Span<float> p = this.lut.AsSpan((int)((ix * this.n001) + (iy * this.n010)));
+
+        // Normalize grid units.
+        float dF0 = nt * nu;
+        float dF1 = nt * u;
+        float dF2 = t * nu;
+        float dF3 = t * u;
+
+        int offset = 0;
+        for (i = 0; i < this.outputCount; i++)
+        {
+            destPixel[i] = (float)((p[offset + this.n000] * dF0) + (p[offset + this.n001] * dF1) + (p[offset + this.n010] * dF2) + (p[offset + this.n011] * dF3));
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Three dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate3d(float* srcPixel, float* destPixel)
+    {
+        byte mx = this.maxGridPoint[0];
+        byte my = this.maxGridPoint[1];
+        byte mz = this.maxGridPoint[2];
+
+        float x = UnitClip(srcPixel[0]) * mx;
+        float y = UnitClip(srcPixel[1]) * my;
+        float z = UnitClip(srcPixel[2]) * mz;
+
+        uint ix = (uint)x;
+        uint iy = (uint)y;
+        uint iz = (uint)z;
+
+        float u = x - ix;
+        float t = y - iy;
+        float s = z - iz;
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        if (iy == my)
+        {
+            iy--;
+            t = 1.0f;
+        }
+
+        if (iz == mz)
+        {
+            iz--;
+            s = 1.0f;
+        }
+
+        float ns = (float)(1.0 - s);
+        float nt = (float)(1.0 - t);
+        float nu = (float)(1.0 - u);
+
+        Span<float> p = this.lut.AsSpan((int)((ix * this.n001) + (iy * this.n010) + (iz * this.n100)));
+
+        // Normalize grid units
+        float dF0 = ns * nt * nu;
+        float dF1 = ns * nt * u;
+        float dF2 = ns * t * nu;
+        float dF3 = ns * t * u;
+        float dF4 = s * nt * nu;
+        float dF5 = s * nt * u;
+        float dF6 = s * t * nu;
+        float dF7 = s * t * u;
+
+        int offset = 0;
+        for (int i = 0; i < this.outputCount; i++)
+        {
+            destPixel[i] = (float)((p[offset + this.n000] * dF0) +
+                                   (p[offset + this.n001] * dF1) +
+                                   (p[offset + this.n010] * dF2) +
+                                   (p[offset + this.n011] * dF3) +
+                                   (p[offset + this.n100] * dF4) +
+                                   (p[offset + this.n101] * dF5) +
+                                   (p[offset + this.n110] * dF6) +
+                                   (p[offset + this.n111] * dF7));
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Four dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate4d(float* srcPixel, float* destPixel)
+    {
+        byte mw = this.maxGridPoint[0];
+        byte mx = this.maxGridPoint[1];
+        byte my = this.maxGridPoint[2];
+        byte mz = this.maxGridPoint[3];
+
+        float w = UnitClip(srcPixel[0]) * mw;
+        float x = UnitClip(srcPixel[1]) * mx;
+        float y = UnitClip(srcPixel[2]) * my;
+        float z = UnitClip(srcPixel[3]) * mz;
+
+        uint iw = (uint)w;
+        uint ix = (uint)x;
+        uint iy = (uint)y;
+        uint iz = (uint)z;
+
+        float v = w - iw;
+        float u = x - ix;
+        float t = y - iy;
+        float s = z - iz;
+
+        if (iw == mw)
+        {
+            iw--;
+            v = 1.0f;
+        }
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        if (iy == my)
+        {
+            iy--;
+            t = 1.0f;
+        }
+
+        if (iz == mz)
+        {
+            iz--;
+            s = 1.0f;
+        }
+
+        float ns = (float)(1.0 - s);
+        float nt = (float)(1.0 - t);
+        float nu = (float)(1.0 - u);
+        float nv = (float)(1.0 - v);
+
+        Span<float> p = this.lut.AsSpan((int)((iw * this.n001) + (ix * this.n010) + (iy * this.n100) + (iz * this.n1000)));
+
+        // Normalize grid units.
+        float[] dF =
+        [
+            ns * nt * nu * nv,
+            ns * nt * nu * v,
+            ns * nt * u * nv,
+            ns * nt * u * v,
+            ns * t * nu * nv,
+            ns * t * nu * v,
+            ns * t * u * nv,
+            ns * t * u * v,
+            s * nt * nu * nv,
+            s * nt * nu * v,
+            s * nt * u * nv,
+            s * nt * u * v,
+            s * t * nu * nv,
+            s * t * nu * v,
+            s * t * u * nv,
+            s * t * u * v,
+        ];
+
+        int offset = 0;
+        for (int i = 0; i < this.outputCount; i++)
+        {
+            float pv = 0.0f;
+            for (int j = 0; j < 16; j++)
+            {
+                pv += p[offset + this.indexFactor[j]] * dF[j];
+            }
+
+            destPixel[i] = pv;
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Generic N-dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void InterpolateNd(float* srcPixel, float* destPixel)
+    {
+        int index = 0;
+        for (int i = 0; i < this.inputCount; i++)
+        {
+            this.g[i] = UnitClip(srcPixel[i]) * this.maxGridPoint[i];
+            this.ig[i] = (uint)this.g[i];
+            this.s[this.inputCount - 1 - i] = this.g[i] - this.ig[i];
+            if (this.ig[i] == this.maxGridPoint[i])
+            {
+                this.ig[i]--;
+                this.s[this.inputCount - 1 - i] = 1.0f;
+            }
+
+            index += (int)this.ig[i] * this.dimSize[i];
+        }
+
+        Span<float> p = this.lut.AsSpan(index);
+        float[] temp = new float[2];
+        bool nFlag = false;
+
+        for (int i = 0; i < this.nodeCount; i++)
+        {
+            this.df[i] = 1.0f;
+        }
+
+        for (int i = 0; i < this.inputCount; i++)
+        {
+            temp[0] = 1.0f - this.s[i];
+            temp[1] = this.s[i];
+            index = (int)this.nPower[i];
+            for (int j = 0; j < this.nodeCount; j++)
+            {
+                this.df[j] *= temp[nFlag ? 1 : 0];
+                if ((j + 1) % index == 0)
+                {
+                    nFlag = !nFlag;
+                }
+            }
+
+            nFlag = false;
+        }
+
+        int offset = 0;
+        for (int i = 0; i < this.outputCount; i++)
+        {
+            float pv = 0;
+            for (int j = 0; j < this.nodeCount; j++)
+            {
+                pv += p[offset + this.indexFactor[j]] * this.df[j];
+            }
+
+            destPixel[i] = pv;
+            offset++;
+        }
+    }
+
+    private static float UnitClip(float v)
+    {
+        if (v < 0)
+        {
+            return 0;
+        }
+
+        if (v > 1.0)
+        {
+            return 1.0f;
+        }
+
+        return v;
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/ColorTrcCalculator.cs

@@ -0,0 +1,65 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class ColorTrcCalculator : IVector4Calculator
+{
+    private readonly TrcCalculator curveCalculator;
+    private readonly Matrix4x4 matrix;
+    private readonly bool toPcs;
+
+    public ColorTrcCalculator(
+        IccXyzTagDataEntry redMatrixColumn,
+        IccXyzTagDataEntry greenMatrixColumn,
+        IccXyzTagDataEntry blueMatrixColumn,
+        IccTagDataEntry redTrc,
+        IccTagDataEntry greenTrc,
+        IccTagDataEntry blueTrc,
+        bool toPcs)
+    {
+        this.toPcs = toPcs;
+        this.curveCalculator = new TrcCalculator([redTrc, greenTrc, blueTrc], !toPcs);
+
+        Vector3 mr = redMatrixColumn.Data[0];
+        Vector3 mg = greenMatrixColumn.Data[0];
+        Vector3 mb = blueMatrixColumn.Data[0];
+        this.matrix = new Matrix4x4(mr.X, mr.Y, mr.Z, 0, mg.X, mg.Y, mg.Z, 0, mb.X, mb.Y, mb.Z, 0, 0, 0, 0, 1);
+
+        if (!toPcs)
+        {
+            Matrix4x4.Invert(this.matrix, out this.matrix);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value)
+    {
+        if (this.toPcs)
+        {
+            // input is always linear RGB
+            value = this.curveCalculator.Calculate(value);
+            CieXyz xyz = new(Vector4.Transform(value, this.matrix).AsVector3());
+
+            // when data to PCS, output from calculator is descaled XYZ
+            // but downstream process requires scaled XYZ
+            // (see DemoMaxICC IccCmm.cpp : CIccXformMatrixTRC::Apply)
+            return xyz.ToScaledVector4();
+        }
+        else
+        {
+            // input is always XYZ
+            Vector4 xyz = Vector4.Transform(value, this.matrix);
+
+            // when data to PCS, upstream process provides scaled XYZ
+            // but input to calculator is descaled XYZ
+            // (see DemoMaxICC IccCmm.cpp : CIccXformMatrixTRC::Apply)
+            xyz = new(CieXyz.FromScaledVector4(xyz).AsVector3Unsafe(), 1);
+            return this.curveCalculator.Calculate(xyz);
+        }
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.CalculationType.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class CurveCalculator
+{
+    private enum CalculationType
+    {
+        Identity,
+        Gamma,
+        Lut,
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class CurveCalculator : ISingleCalculator
+{
+    private readonly LutCalculator lutCalculator;
+    private readonly float gamma;
+    private readonly CalculationType type;
+
+    public CurveCalculator(IccCurveTagDataEntry entry, bool inverted)
+    {
+        if (entry.IsIdentityResponse)
+        {
+            this.type = CalculationType.Identity;
+        }
+        else if (entry.IsGamma)
+        {
+            this.gamma = entry.Gamma;
+            if (inverted)
+            {
+                this.gamma = 1f / this.gamma;
+            }
+
+            this.type = CalculationType.Gamma;
+        }
+        else
+        {
+            this.lutCalculator = new LutCalculator(entry.CurveData, inverted);
+            this.type = CalculationType.Lut;
+        }
+    }
+
+    public float Calculate(float value)
+        => this.type switch
+        {
+            CalculationType.Identity => value,
+            CalculationType.Gamma => MathF.Pow(value, this.gamma), // TODO: This could be optimized using a LUT. See SrgbCompanding
+            CalculationType.Lut => this.lutCalculator.Calculate(value),
+            _ => throw new InvalidOperationException("Invalid calculation type"),
+        };
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/GrayTrcCalculator.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class GrayTrcCalculator : IVector4Calculator
+{
+    private readonly TrcCalculator calculator;
+
+    public GrayTrcCalculator(IccTagDataEntry grayTrc, bool toPcs)
+        => this.calculator = new TrcCalculator(new IccTagDataEntry[] { grayTrc }, !toPcs);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value) => this.calculator.Calculate(value);
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/ISingleCalculator.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Represents an ICC calculator with a single floating point value and result
+/// </summary>
+internal interface ISingleCalculator
+{
+    /// <summary>
+    /// Calculates a result from the given value
+    /// </summary>
+    /// <param name="value">The input value</param>
+    /// <returns>The calculated result</returns>
+    float Calculate(float value);
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/IVector4Calculator.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Represents an ICC calculator with <see cref="Vector4"/> values and results
+/// </summary>
+internal interface IVector4Calculator
+{
+    /// <summary>
+    /// Calculates a result from the given values
+    /// </summary>
+    /// <param name="value">The input values</param>
+    /// <returns>The calculated result</returns>
+    Vector4 Calculate(Vector4 value);
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.CalculationType.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class LutABCalculator
+{
+    private enum CalculationType
+    {
+        AtoB = 1 << 3,
+        BtoA = 1 << 4,
+
+        SingleCurve = 1,
+        CurveMatrix = 2,
+        CurveClut = 3,
+        Full = 4,
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.cs

@@ -0,0 +1,135 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class LutABCalculator : IVector4Calculator
+{
+    private CalculationType type;
+    private TrcCalculator curveACalculator;
+    private TrcCalculator curveBCalculator;
+    private TrcCalculator curveMCalculator;
+    private MatrixCalculator matrixCalculator;
+    private ClutCalculator clutCalculator;
+
+    public LutABCalculator(IccLutAToBTagDataEntry entry)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
+        this.type |= CalculationType.AtoB;
+    }
+
+    public LutABCalculator(IccLutBToATagDataEntry entry)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
+        this.type |= CalculationType.BtoA;
+    }
+
+    public Vector4 Calculate(Vector4 value)
+    {
+        switch (this.type)
+        {
+            case CalculationType.Full | CalculationType.AtoB:
+                value = this.curveACalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                value = this.curveMCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.Full | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                value = this.curveMCalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveACalculator.Calculate(value);
+
+            case CalculationType.CurveClut | CalculationType.AtoB:
+                value = this.curveACalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.CurveClut | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveACalculator.Calculate(value);
+
+            case CalculationType.CurveMatrix | CalculationType.AtoB:
+                value = this.curveMCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.CurveMatrix | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveMCalculator.Calculate(value);
+
+            case CalculationType.SingleCurve | CalculationType.AtoB:
+            case CalculationType.SingleCurve | CalculationType.BtoA:
+                return this.curveBCalculator.Calculate(value);
+
+            default:
+                throw new InvalidOperationException("Invalid calculation type");
+        }
+    }
+
+    private void Init(IccTagDataEntry[] curveA, IccTagDataEntry[] curveB, IccTagDataEntry[] curveM, Vector3? matrix3x1, Matrix4x4? matrix3x3, IccClut clut)
+    {
+        bool hasACurve = curveA != null;
+        bool hasBCurve = curveB != null;
+        bool hasMCurve = curveM != null;
+        bool hasMatrix = matrix3x1 != null && matrix3x3 != null;
+        bool hasClut = clut != null;
+
+        if (hasBCurve && hasMatrix && hasMCurve && hasClut && hasACurve)
+        {
+            this.type = CalculationType.Full;
+        }
+        else if (hasBCurve && hasClut && hasACurve)
+        {
+            this.type = CalculationType.CurveClut;
+        }
+        else if (hasBCurve && hasMatrix && hasMCurve)
+        {
+            this.type = CalculationType.CurveMatrix;
+        }
+        else if (hasBCurve)
+        {
+            this.type = CalculationType.SingleCurve;
+        }
+        else
+        {
+            throw new InvalidIccProfileException("AToB or BToA tag has an invalid configuration");
+        }
+
+        if (hasACurve)
+        {
+            this.curveACalculator = new TrcCalculator(curveA, false);
+        }
+
+        if (hasBCurve)
+        {
+            this.curveBCalculator = new TrcCalculator(curveB, false);
+        }
+
+        if (hasMCurve)
+        {
+            this.curveMCalculator = new TrcCalculator(curveM, false);
+        }
+
+        if (hasMatrix)
+        {
+            this.matrixCalculator = new MatrixCalculator(matrix3x3.Value, matrix3x1.Value);
+        }
+
+        if (hasClut)
+        {
+            this.clutCalculator = new ClutCalculator(clut);
+        }
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/LutCalculator.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class LutCalculator : ISingleCalculator
+{
+    private readonly float[] lut;
+    private readonly bool inverse;
+
+    public LutCalculator(float[] lut, bool inverse)
+    {
+        Guard.NotNull(lut, nameof(lut));
+
+        this.lut = lut;
+        this.inverse = inverse;
+    }
+
+    public float Calculate(float value)
+    {
+        if (this.inverse)
+        {
+            return this.LookupInverse(value);
+        }
+
+        return this.Lookup(value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float Lookup(float value)
+    {
+        value = Math.Max(value, 0);
+
+        float factor = value * (this.lut.Length - 1);
+        int index = (int)factor;
+        float low = this.lut[index];
+
+        float high = 1F;
+        if (index < this.lut.Length - 1)
+        {
+            high = this.lut[index + 1];
+        }
+
+        return low + ((high - low) * (factor - index));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float LookupInverse(float value)
+    {
+        int index = Array.BinarySearch(this.lut, value);
+        if (index >= 0)
+        {
+            return index / (float)(this.lut.Length - 1);
+        }
+
+        index = ~index;
+        if (index == 0)
+        {
+            return 0;
+        }
+        else if (index == this.lut.Length)
+        {
+            return 1;
+        }
+
+        float high = this.lut[index];
+        float low = this.lut[index - 1];
+
+        float valuePercent = (value - low) / (high - low);
+        float lutRange = 1 / (float)(this.lut.Length - 1);
+        float lutLow = (index - 1) / (float)(this.lut.Length - 1);
+
+        return lutLow + (valuePercent * lutRange);
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/LutEntryCalculator.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class LutEntryCalculator : IVector4Calculator
+{
+    private LutCalculator[] inputCurve;
+    private LutCalculator[] outputCurve;
+    private ClutCalculator clutCalculator;
+    private Matrix4x4 matrix;
+    private bool doTransform;
+
+    public LutEntryCalculator(IccLut8TagDataEntry lut)
+    {
+        Guard.NotNull(lut, nameof(lut));
+        this.Init(lut.InputValues, lut.OutputValues, lut.ClutValues, lut.Matrix);
+        this.Is16Bit = false;
+    }
+
+    public LutEntryCalculator(IccLut16TagDataEntry lut)
+    {
+        Guard.NotNull(lut, nameof(lut));
+        this.Init(lut.InputValues, lut.OutputValues, lut.ClutValues, lut.Matrix);
+        this.Is16Bit = true;
+    }
+
+    internal bool Is16Bit { get; }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value)
+    {
+        if (this.doTransform)
+        {
+            value = Vector4.Transform(value, this.matrix);
+        }
+
+        value = CalculateLut(this.inputCurve, value);
+        value = this.clutCalculator.Calculate(value);
+        return CalculateLut(this.outputCurve, value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector4 CalculateLut(LutCalculator[] lut, Vector4 value)
+    {
+        ref float f = ref Unsafe.As<Vector4, float>(ref value);
+        for (int i = 0; i < lut.Length; i++)
+        {
+            Unsafe.Add(ref f, i) = lut[i].Calculate(Unsafe.Add(ref f, i));
+        }
+
+        return value;
+    }
+
+    private void Init(IccLut[] inputCurve, IccLut[] outputCurve, IccClut clut, Matrix4x4 matrix)
+    {
+        this.inputCurve = InitLut(inputCurve);
+        this.outputCurve = InitLut(outputCurve);
+        this.clutCalculator = new ClutCalculator(clut);
+        this.matrix = matrix;
+
+        this.doTransform = !matrix.IsIdentity && inputCurve.Length == 3;
+    }
+
+    private static LutCalculator[] InitLut(IccLut[] curves)
+    {
+        LutCalculator[] calculators = new LutCalculator[curves.Length];
+        for (int i = 0; i < curves.Length; i++)
+        {
+            calculators[i] = new LutCalculator(curves[i].Values, false);
+        }
+
+        return calculators;
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/MatrixCalculator.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class MatrixCalculator : IVector4Calculator
+{
+    private Matrix4x4 matrix2D;
+    private Vector4 matrix1D;
+
+    public MatrixCalculator(Matrix4x4 matrix3x3, Vector3 matrix3x1)
+    {
+        this.matrix2D = matrix3x3;
+        this.matrix1D = new Vector4(matrix3x1, 0);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value)
+    {
+        Vector4 transformed = Vector4.Transform(value, this.matrix2D);
+        return Vector4.Add(this.matrix1D, transformed);
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/ParametricCurveCalculator.cs

@@ -0,0 +1,130 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class ParametricCurveCalculator : ISingleCalculator
+{
+    private readonly IccParametricCurve curve;
+    private readonly IccParametricCurveType type;
+    private const IccParametricCurveType InvertedFlag = (IccParametricCurveType)(1 << 3);
+
+    public ParametricCurveCalculator(IccParametricCurveTagDataEntry entry, bool inverted)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.curve = entry.Curve;
+        this.type = entry.Curve.Type;
+
+        if (inverted)
+        {
+            this.type |= InvertedFlag;
+        }
+    }
+
+    public float Calculate(float value)
+        => this.type switch
+        {
+            IccParametricCurveType.Type1 => this.CalculateGamma(value),
+            IccParametricCurveType.Cie122_1996 => this.CalculateCie122(value),
+            IccParametricCurveType.Iec61966_3 => this.CalculateIec61966(value),
+            IccParametricCurveType.SRgb => this.CalculateSRgb(value),
+            IccParametricCurveType.Type5 => this.CalculateType5(value),
+            IccParametricCurveType.Type1 | InvertedFlag => this.CalculateInvertedGamma(value),
+            IccParametricCurveType.Cie122_1996 | InvertedFlag => this.CalculateInvertedCie122(value),
+            IccParametricCurveType.Iec61966_3 | InvertedFlag => this.CalculateInvertedIec61966(value),
+            IccParametricCurveType.SRgb | InvertedFlag => this.CalculateInvertedSRgb(value),
+            IccParametricCurveType.Type5 | InvertedFlag => this.CalculateInvertedType5(value),
+            _ => throw new InvalidIccProfileException("ParametricCurve"),
+        };
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateGamma(float value) => MathF.Pow(value, this.curve.G);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateCie122(float value)
+    {
+        if (value >= -this.curve.B / this.curve.A)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G);
+        }
+
+        return 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateIec61966(float value)
+    {
+        if (value >= -this.curve.B / this.curve.A)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G) + this.curve.C;
+        }
+
+        return this.curve.C;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateSRgb(float value)
+    {
+        if (value >= this.curve.D)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G);
+        }
+
+        return this.curve.C * value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateType5(float value)
+    {
+        if (value >= this.curve.D)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G) + this.curve.E;
+        }
+
+        return (this.curve.C * value) + this.curve.F;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedGamma(float value)
+        => MathF.Pow(value, 1 / this.curve.G);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedCie122(float value)
+        => (MathF.Pow(value, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedIec61966(float value)
+    {
+        if (value >= this.curve.C)
+        {
+            return (MathF.Pow(value - this.curve.C, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+        }
+
+        return -this.curve.B / this.curve.A;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedSRgb(float value)
+    {
+        if (value >= MathF.Pow((this.curve.A * this.curve.D) + this.curve.B, this.curve.G))
+        {
+            return (MathF.Pow(value, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+        }
+
+        return value / this.curve.C;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedType5(float value)
+    {
+        if (value >= (this.curve.C * this.curve.D) + this.curve.F)
+        {
+            return (MathF.Pow(value - this.curve.E, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+        }
+
+        return (value - this.curve.F) / this.curve.C;
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/TrcCalculator.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class TrcCalculator : IVector4Calculator
+{
+    private readonly ISingleCalculator[] calculators;
+
+    public TrcCalculator(IccTagDataEntry[] entries, bool inverted)
+    {
+        Guard.NotNull(entries, nameof(entries));
+
+        this.calculators = new ISingleCalculator[entries.Length];
+        for (int i = 0; i < entries.Length; i++)
+        {
+            this.calculators[i] = entries[i] switch
+            {
+                IccCurveTagDataEntry curve => new CurveCalculator(curve, inverted),
+                IccParametricCurveTagDataEntry parametricCurve => new ParametricCurveCalculator(parametricCurve, inverted),
+                _ => throw new InvalidIccProfileException("Invalid Entry."),
+            };
+        }
+    }
+
+    public unsafe Vector4 Calculate(Vector4 value)
+    {
+        ref float f = ref Unsafe.As<Vector4, float>(ref value);
+        for (int i = 0; i < this.calculators.Length; i++)
+        {
+            Unsafe.Add(ref f, i) = this.calculators[i].Calculate(Unsafe.Add(ref f, i));
+        }
+
+        return value;
+    }
+}

src/ImageSharp/ColorProfiles/Icc/IccConverterBase.Checks.cs

@@ -0,0 +1,155 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    private static ConversionMethod GetConversionMethod(IccProfile profile, IccRenderingIntent renderingIntent) => profile.Header.Class switch
+    {
+        IccProfileClass.InputDevice or
+        IccProfileClass.DisplayDevice or
+        IccProfileClass.OutputDevice or
+        IccProfileClass.ColorSpace => CheckMethod1(profile, renderingIntent),
+        IccProfileClass.DeviceLink or IccProfileClass.Abstract => CheckMethod2(profile),
+        _ => ConversionMethod.Invalid,
+    };
+
+    private static ConversionMethod CheckMethod1(IccProfile profile, IccRenderingIntent renderingIntent)
+    {
+        ConversionMethod method = CheckMethodD(profile, renderingIntent);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        method = CheckMethodA(profile, renderingIntent);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        method = CheckMethodA0(profile);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        method = CheckMethodTrc(profile);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodD(IccProfile profile, IccRenderingIntent renderingIntent)
+    {
+        if ((HasTag(profile, IccProfileTag.DToB0) || HasTag(profile, IccProfileTag.BToD0))
+            && renderingIntent == IccRenderingIntent.Perceptual)
+        {
+            return ConversionMethod.D0;
+        }
+
+        if ((HasTag(profile, IccProfileTag.DToB1) || HasTag(profile, IccProfileTag.BToD1))
+            && renderingIntent == IccRenderingIntent.MediaRelativeColorimetric)
+        {
+            return ConversionMethod.D1;
+        }
+
+        if ((HasTag(profile, IccProfileTag.DToB2) || HasTag(profile, IccProfileTag.BToD2))
+            && renderingIntent == IccRenderingIntent.Saturation)
+        {
+            return ConversionMethod.D2;
+        }
+
+        if ((HasTag(profile, IccProfileTag.DToB3) || HasTag(profile, IccProfileTag.BToD3))
+            && renderingIntent == IccRenderingIntent.AbsoluteColorimetric)
+        {
+            return ConversionMethod.D3;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodA(IccProfile profile, IccRenderingIntent renderingIntent)
+    {
+        if ((HasTag(profile, IccProfileTag.AToB0) || HasTag(profile, IccProfileTag.BToA0))
+            && renderingIntent == IccRenderingIntent.Perceptual)
+        {
+            return ConversionMethod.A0;
+        }
+
+        if ((HasTag(profile, IccProfileTag.AToB1) || HasTag(profile, IccProfileTag.BToA1))
+            && renderingIntent == IccRenderingIntent.MediaRelativeColorimetric)
+        {
+            return ConversionMethod.A1;
+        }
+
+        if ((HasTag(profile, IccProfileTag.AToB2) || HasTag(profile, IccProfileTag.BToA2))
+            && renderingIntent == IccRenderingIntent.Saturation)
+        {
+            return ConversionMethod.A2;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodA0(IccProfile profile)
+    {
+        bool valid = HasTag(profile, IccProfileTag.AToB0) || HasTag(profile, IccProfileTag.BToA0);
+        return valid ? ConversionMethod.A0 : ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodTrc(IccProfile profile)
+    {
+        if (HasTag(profile, IccProfileTag.RedMatrixColumn)
+            && HasTag(profile, IccProfileTag.GreenMatrixColumn)
+            && HasTag(profile, IccProfileTag.BlueMatrixColumn)
+            && HasTag(profile, IccProfileTag.RedTrc)
+            && HasTag(profile, IccProfileTag.GreenTrc)
+            && HasTag(profile, IccProfileTag.BlueTrc))
+        {
+            return ConversionMethod.ColorTrc;
+        }
+
+        if (HasTag(profile, IccProfileTag.GrayTrc))
+        {
+            return ConversionMethod.GrayTrc;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethod2(IccProfile profile)
+    {
+        if (HasTag(profile, IccProfileTag.DToB0) || HasTag(profile, IccProfileTag.BToD0))
+        {
+            return ConversionMethod.D0;
+        }
+
+        if (HasTag(profile, IccProfileTag.AToB0) || HasTag(profile, IccProfileTag.AToB0))
+        {
+            return ConversionMethod.A0;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static bool HasTag(IccProfile profile, IccProfileTag tag)
+        => profile.Entries.Any(t => t.TagSignature == tag);
+
+    private static IccTagDataEntry GetTag(IccProfile profile, IccProfileTag tag)
+        => Array.Find(profile.Entries, t => t.TagSignature == tag);
+
+    private static T GetTag<T>(IccProfile profile, IccProfileTag tag)
+        where T : IccTagDataEntry
+        => profile.Entries.OfType<T>().FirstOrDefault(t => t.TagSignature == tag);
+}

src/ImageSharp/ColorProfiles/Icc/IccConverterBase.ConversionMethod.cs

@@ -0,0 +1,66 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    /// <summary>
+    /// Conversion methods with ICC profiles
+    /// </summary>
+    private enum ConversionMethod
+    {
+        /// <summary>
+        /// Conversion using anything but Multi Process Elements with perceptual rendering intent
+        /// </summary>
+        A0,
+
+        /// <summary>
+        /// Conversion using anything but Multi Process Elements with relative colorimetric rendering intent
+        /// </summary>
+        A1,
+
+        /// <summary>
+        /// Conversion using anything but Multi Process Elements with saturation rendering intent
+        /// </summary>
+        A2,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with perceptual rendering intent
+        /// </summary>
+        D0,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with relative colorimetric rendering intent
+        /// </summary>
+        D1,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with saturation rendering intent
+        /// </summary>
+        D2,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with absolute colorimetric rendering intent
+        /// </summary>
+        D3,
+
+        /// <summary>
+        /// Conversion of more than one channel using tone reproduction curves
+        /// </summary>
+        ColorTrc,
+
+        /// <summary>
+        /// Conversion of exactly one channel using a tone reproduction curve
+        /// </summary>
+        GrayTrc,
+
+        /// <summary>
+        /// No valid conversion method available or found
+        /// </summary>
+        Invalid,
+    }
+}

src/ImageSharp/ColorProfiles/Icc/IccConverterbase.Conversions.cs

@@ -0,0 +1,109 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    private IVector4Calculator calculator;
+
+    internal bool Is16BitLutEntry => this.calculator is LutEntryCalculator { Is16Bit: true };
+
+    internal bool IsTrc => this.calculator is ColorTrcCalculator or GrayTrcCalculator;
+
+    /// <summary>
+    /// Checks the profile for available conversion methods and gathers all the information's necessary for it.
+    /// </summary>
+    /// <param name="profile">The profile to use for the conversion.</param>
+    /// <param name="toPcs">True if the conversion is to the Profile Connection Space.</param>
+    /// <param name="renderingIntent">The wanted rendering intent. Can be ignored if not available.</param>
+    /// <exception cref="InvalidIccProfileException">Invalid conversion method.</exception>
+    protected void Init(IccProfile profile, bool toPcs, IccRenderingIntent renderingIntent)
+        => this.calculator = GetConversionMethod(profile, renderingIntent) switch
+        {
+            ConversionMethod.D0 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB0) :
+                                InitD(profile, IccProfileTag.BToD0),
+            ConversionMethod.D1 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB1) :
+                                InitD(profile, IccProfileTag.BToD1),
+            ConversionMethod.D2 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB2) :
+                                InitD(profile, IccProfileTag.BToD2),
+            ConversionMethod.D3 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB3) :
+                                InitD(profile, IccProfileTag.BToD3),
+            ConversionMethod.A0 => toPcs ?
+                                InitA(profile, IccProfileTag.AToB0) :
+                                InitA(profile, IccProfileTag.BToA0),
+            ConversionMethod.A1 => toPcs ?
+                                InitA(profile, IccProfileTag.AToB1) :
+                                InitA(profile, IccProfileTag.BToA1),
+            ConversionMethod.A2 => toPcs ?
+                                InitA(profile, IccProfileTag.AToB2) :
+                                InitA(profile, IccProfileTag.BToA2),
+            ConversionMethod.ColorTrc => InitColorTrc(profile, toPcs),
+            ConversionMethod.GrayTrc => InitGrayTrc(profile, toPcs),
+            _ => throw new InvalidIccProfileException("Invalid conversion method."),
+        };
+
+    private static IVector4Calculator InitA(IccProfile profile, IccProfileTag tag)
+        => GetTag(profile, tag) switch
+        {
+            IccLut8TagDataEntry lut8 => new LutEntryCalculator(lut8),
+            IccLut16TagDataEntry lut16 => new LutEntryCalculator(lut16),
+            IccLutAToBTagDataEntry lutAtoB => new LutABCalculator(lutAtoB),
+            IccLutBToATagDataEntry lutBtoA => new LutABCalculator(lutBtoA),
+            _ => throw new InvalidIccProfileException("Invalid entry."),
+        };
+
+    private static IVector4Calculator InitD(IccProfile profile, IccProfileTag tag)
+    {
+        IccMultiProcessElementsTagDataEntry entry = GetTag<IccMultiProcessElementsTagDataEntry>(profile, tag)
+            ?? throw new InvalidIccProfileException("Entry is null.");
+
+        throw new NotImplementedException("Multi process elements are not supported");
+    }
+
+    private static ColorTrcCalculator InitColorTrc(IccProfile profile, bool toPcs)
+    {
+        IccXyzTagDataEntry redMatrixColumn = GetTag<IccXyzTagDataEntry>(profile, IccProfileTag.RedMatrixColumn);
+        IccXyzTagDataEntry greenMatrixColumn = GetTag<IccXyzTagDataEntry>(profile, IccProfileTag.GreenMatrixColumn);
+        IccXyzTagDataEntry blueMatrixColumn = GetTag<IccXyzTagDataEntry>(profile, IccProfileTag.BlueMatrixColumn);
+
+        IccTagDataEntry redTrc = GetTag(profile, IccProfileTag.RedTrc);
+        IccTagDataEntry greenTrc = GetTag(profile, IccProfileTag.GreenTrc);
+        IccTagDataEntry blueTrc = GetTag(profile, IccProfileTag.BlueTrc);
+
+        if (redMatrixColumn == null ||
+            greenMatrixColumn == null ||
+            blueMatrixColumn == null ||
+            redTrc == null ||
+            greenTrc == null ||
+            blueTrc == null)
+        {
+            throw new InvalidIccProfileException("Missing matrix column or channel.");
+        }
+
+        return new ColorTrcCalculator(
+            redMatrixColumn,
+            greenMatrixColumn,
+            blueMatrixColumn,
+            redTrc,
+            greenTrc,
+            blueTrc,
+            toPcs);
+    }
+
+    private static GrayTrcCalculator InitGrayTrc(IccProfile profile, bool toPcs)
+    {
+        IccTagDataEntry entry = GetTag(profile, IccProfileTag.GrayTrc);
+        return new GrayTrcCalculator(entry, toPcs);
+    }
+}

src/ImageSharp/ColorProfiles/Icc/IccConverterbase.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccConverterBase"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    /// <param name="toPcs">True if the conversion is to the profile connection space (PCS); False if the conversion is to the data space</param>
+    protected IccConverterBase(IccProfile profile, bool toPcs)
+    {
+        Guard.NotNull(profile, nameof(profile));
+        this.Init(profile, toPcs, profile.Header.RenderingIntent);
+    }
+
+    /// <summary>
+    /// Converts colors with the initially provided ICC profile
+    /// </summary>
+    /// <param name="value">The value to convert</param>
+    /// <returns>The converted value</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value) => this.calculator.Calculate(value);
+
+    /// <summary>
+    /// Converts colors with the initially provided ICC profile
+    /// </summary>
+    /// <param name="source">The source colors</param>
+    /// <param name="destination">The destination colors</param>
+    public void Calculate(ReadOnlySpan<Vector4> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = this.Calculate(source[i]);
+        }
+    }
+}

src/ImageSharp/ColorProfiles/Icc/IccDataToDataConverter.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccDataToDataConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccDataToDataConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccDataToDataConverter(IccProfile profile)
+        : base(profile, true) // toPCS is true because in this case the PCS space is also a data space
+    {
+    }
+}

src/ImageSharp/ColorProfiles/Icc/IccDataToPcsConverter.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccDataToPcsConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccDataToPcsConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccDataToPcsConverter(IccProfile profile)
+        : base(profile, true)
+    {
+    }
+}

src/ImageSharp/ColorProfiles/Icc/IccPcsToDataConverter.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccPcsToDataConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccPcsToDataConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccPcsToDataConverter(IccProfile profile)
+        : base(profile, false)
+    {
+    }
+}

src/ImageSharp/ColorProfiles/Icc/IccPcsToPcsConverter.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccPcsToPcsConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccPcsToPcsConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccPcsToPcsConverter(IccProfile profile)
+        : base(profile, true)
+    {
+    }
+}

src/ImageSharp/ColorProfiles/Icc/SrgbV4Profile.Generated.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+// <auto-generated />
+
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal static class SrgbV4Profile
+{
+    // Generated using the sRGB-v4.icc profile found at https://github.com/saucecontrol/Compact-ICC-Profiles
+    private static ReadOnlySpan<byte> Data => new byte[]
+    {
+        0, 0, 1, 224, 108, 99, 109, 115, 4, 32, 0, 0, 109, 110, 116, 114, 82, 71, 66, 32, 88, 89, 90, 32, 7, 226, 0, 3, 0,
+        20, 0, 9, 0, 14, 0, 29, 97, 99, 115, 112, 77, 83, 70, 84, 0, 0, 0, 0, 115, 97, 119, 115, 99, 116, 114, 108, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 246, 214, 0, 1, 0, 0, 0, 0, 211, 45, 104, 97, 110, 100, 163, 178, 171,
+        223, 92, 167, 3, 18, 168, 85, 164, 236, 53, 122, 209, 243, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 100, 101, 115, 99, 0, 0, 0, 252, 0, 0, 0, 36, 99,
+        112, 114, 116, 0, 0, 1, 32, 0, 0, 0, 34, 119, 116, 112, 116, 0, 0, 1, 68, 0, 0, 0, 20, 99, 104, 97, 100, 0, 0,
+        1, 88, 0, 0, 0, 44, 114, 88, 89, 90, 0, 0, 1, 132, 0, 0, 0, 20, 103, 88, 89, 90, 0, 0, 1, 152, 0, 0, 0,
+        20, 98, 88, 89, 90, 0, 0, 1, 172, 0, 0, 0, 20, 114, 84, 82, 67, 0, 0, 1, 192, 0, 0, 0, 32, 103, 84, 82, 67,
+        0, 0, 1, 192, 0, 0, 0, 32, 98, 84, 82, 67, 0, 0, 1, 192, 0, 0, 0, 32, 109, 108, 117, 99, 0, 0, 0, 0, 0,
+        0, 0, 1, 0, 0, 0, 12, 101, 110, 85, 83, 0, 0, 0, 8, 0, 0, 0, 28, 0, 115, 0, 82, 0, 71, 0, 66, 109, 108,
+        117, 99, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 12, 101, 110, 85, 83, 0, 0, 0, 6, 0, 0, 0, 28, 0, 67, 0,
+        67, 0, 48, 0, 33, 88, 89, 90, 32, 0, 0, 0, 0, 0, 0, 246, 214, 0, 1, 0, 0, 0, 0, 211, 45, 115, 102, 51, 50,
+        0, 0, 0, 0, 0, 1, 12, 63, 0, 0, 5, 221, 255, 255, 243, 38, 0, 0, 7, 144, 0, 0, 253, 146, 255, 255, 251, 161, 255,
+        255, 253, 162, 0, 0, 3, 220, 0, 0, 192, 113, 88, 89, 90, 32, 0, 0, 0, 0, 0, 0, 111, 160, 0, 0, 56, 242, 0, 0,
+        3, 143, 88, 89, 90, 32, 0, 0, 0, 0, 0, 0, 98, 150, 0, 0, 183, 137, 0, 0, 24, 218, 88, 89, 90, 32, 0, 0, 0,
+        0, 0, 0, 36, 160, 0, 0, 15, 133, 0, 0, 182, 196, 112, 97, 114, 97, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 102, 105,
+        0, 0, 242, 167, 0, 0, 13, 89, 0, 0, 19, 208, 0, 0, 10, 91,
+    };
+
+    private static readonly Lazy<IccProfile> LazyIccProfile = new(() => GetIccProfile());
+
+    public static IccProfile GetProfile() => LazyIccProfile.Value;
+
+    private static IccProfile GetIccProfile()
+    {
+        byte[] buffer = new byte[Data.Length];
+        Data.CopyTo(buffer);
+        return new IccProfile(buffer);
+    }
+}
+

src/ImageSharp/ColorProfiles/KnownYCbCrMatrices.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// Provides standard YCbCr matrices for RGB to YCbCr conversion.
+/// </summary>
+public static class KnownYCbCrMatrices
+{
+#pragma warning disable SA1137 // Elements should have the same indentation
+#pragma warning disable SA1117 // Parameters should be on same line or separate lines
+    /// <summary>
+    /// ITU-R BT.601 (SD video standard).
+    /// </summary>
+    public static readonly YCbCrMatrix BT601 = new(
+        new Matrix4x4(
+            0.299000F, 0.587000F, 0.114000F, 0F,
+           -0.168736F, -0.331264F, 0.500000F, 0F,
+            0.500000F, -0.418688F, -0.081312F, 0F,
+            0F, 0F, 0F, 1F),
+        new Matrix4x4(
+            1.000000F, 0.000000F, 1.402000F, 0F,
+            1.000000F, -0.344136F, -0.714136F, 0F,
+            1.000000F, 1.772000F, 0.000000F, 0F,
+            0F, 0F, 0F, 1F),
+        new Vector3(0F, 0.5F, 0.5F));
+
+    /// <summary>
+    /// ITU-R BT.709 (HD video, sRGB standard).
+    /// </summary>
+    public static readonly YCbCrMatrix BT709 = new(
+        new Matrix4x4(
+            0.212600F, 0.715200F, 0.072200F, 0F,
+           -0.114572F, -0.385428F, 0.500000F, 0F,
+            0.500000F, -0.454153F, -0.045847F, 0F,
+            0F, 0F, 0F, 1F),
+        new Matrix4x4(
+            1.000000F, 0.000000F, 1.574800F, 0F,
+            1.000000F, -0.187324F, -0.468124F, 0F,
+            1.000000F, 1.855600F, 0.000000F, 0F,
+            0F, 0F, 0F, 1F),
+        new Vector3(0F, 0.5F, 0.5F));
+
+    /// <summary>
+    /// ITU-R BT.2020 (UHD/4K video standard).
+    /// </summary>
+    public static readonly YCbCrMatrix BT2020 = new(
+        new Matrix4x4(
+            0.262700F, 0.678000F, 0.059300F, 0F,
+           -0.139630F, -0.360370F, 0.500000F, 0F,
+            0.500000F, -0.459786F, -0.040214F, 0F,
+            0F, 0F, 0F, 1F),
+        new Matrix4x4(
+            1.000000F, 0.000000F, 1.474600F, 0F,
+            1.000000F, -0.164553F, -0.571353F, 0F,
+            1.000000F, 1.881400F, 0.000000F, 0F,
+            0F, 0F, 0F, 1F),
+        new Vector3(0F, 0.5F, 0.5F));
+}

src/ImageSharp/ColorProfiles/Lms.cs

@@ -82,20 +82,53 @@ public readonly struct Lms : IColorProfile<Lms, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Lms left, Lms right) => !left.Equals(right);
 
-    /// <summary>
-    /// Returns a new <see cref="Vector3"/> representing this instance.
-    /// </summary>
-    /// <returns>The <see cref="Vector3"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToVector3() => new(this.L, this.M, this.S);
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(1F);
+        v3 /= 2F;
+        return new Vector4(v3, 1F);
+    }
 
     /// <inheritdoc/>
-    public static Lms FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
+    public static Lms FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= 2F;
+        v3 -= new Vector3(1F);
+        return new Lms(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Lms> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Lms> destination)
     {
-        Vector3 vector = Vector3.Transform(source.ToVector3(), options.AdaptationMatrix);
-        return new Lms(vector);
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
     }
 
+    /// <inheritdoc/>
+    public static Lms FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
+        => new(Vector3.Transform(source.AsVector3Unsafe(), options.AdaptationMatrix));
+
     /// <inheritdoc/>
     public static void FromProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<CieXyz> source, Span<Lms> destination)
     {
@@ -110,10 +143,7 @@ public readonly struct Lms : IColorProfile<Lms, CieXyz>
 
     /// <inheritdoc/>
     public CieXyz ToProfileConnectingSpace(ColorConversionOptions options)
-    {
-        Vector3 vector = Vector3.Transform(this.ToVector3(), options.InverseAdaptationMatrix);
-        return new CieXyz(vector);
-    }
+        => new(Vector3.Transform(this.AsVector3Unsafe(), options.InverseAdaptationMatrix));
 
     /// <inheritdoc/>
     public static void ToProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Lms> source, Span<CieXyz> destination)

src/ImageSharp/ColorProfiles/Rgb.cs

@@ -81,11 +81,54 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgb left, Rgb right) => !left.Equals(right);
 
+    /// <summary>
+    /// Initializes the color instance from a generic scaled <see cref="Vector4"/>.
+    /// </summary>
+    /// <param name="source">The vector to load the color from.</param>
+    /// <returns>The <see cref="Rgb"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb FromScaledVector4(Vector4 source)
+        => new(source.AsVector3());
+
+    /// <summary>
+    /// Expands the color into a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and usually clamped between <value>0</value> and <value>1</value>.
+    /// The vector components are typically expanded in least to greatest significance order.
+    /// </summary>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 ToScaledVector4()
+        => new(this.ToScaledVector3(), 1F);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Rgb> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Rgb> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static Rgb FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
         // Convert to linear rgb then compress.
-        Rgb linear = new(Vector3.Transform(source.ToVector3(), GetCieXyzToRgbMatrix(options.TargetRgbWorkingSpace)));
+        Rgb linear = new(Vector3.Transform(source.AsVector3Unsafe(), GetCieXyzToRgbMatrix(options.TargetRgbWorkingSpace)));
         return FromScaledVector4(options.TargetRgbWorkingSpace.Compress(linear.ToScaledVector4()));
     }
 
@@ -98,7 +141,7 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
         for (int i = 0; i < source.Length; i++)
         {
             // Convert to linear rgb then compress.
-            Rgb linear = new(Vector3.Transform(source[i].ToVector3(), matrix));
+            Rgb linear = new(Vector3.Transform(source[i].AsVector3Unsafe(), matrix));
             Vector4 nonlinear = options.TargetRgbWorkingSpace.Compress(linear.ToScaledVector4());
             destination[i] = FromScaledVector4(nonlinear);
         }
@@ -108,10 +151,10 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     public CieXyz ToProfileConnectingSpace(ColorConversionOptions options)
     {
         // First expand to linear rgb
-        Rgb linear = FromScaledVector4(options.RgbWorkingSpace.Expand(this.ToScaledVector4()));
+        Rgb linear = FromScaledVector4(options.SourceRgbWorkingSpace.Expand(this.ToScaledVector4()));
 
         // Then convert to xyz
-        return new CieXyz(Vector3.Transform(linear.ToScaledVector3(), GetRgbToCieXyzMatrix(options.RgbWorkingSpace)));
+        return new CieXyz(Vector3.Transform(linear.ToScaledVector3(), GetRgbToCieXyzMatrix(options.SourceRgbWorkingSpace)));
     }
 
     /// <inheritdoc/>
@@ -119,13 +162,13 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     {
         Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        Matrix4x4 matrix = GetRgbToCieXyzMatrix(options.RgbWorkingSpace);
+        Matrix4x4 matrix = GetRgbToCieXyzMatrix(options.SourceRgbWorkingSpace);
         for (int i = 0; i < source.Length; i++)
         {
             Rgb rgb = source[i];
 
             // First expand to linear rgb
-            Rgb linear = FromScaledVector4(options.RgbWorkingSpace.Expand(rgb.ToScaledVector4()));
+            Rgb linear = FromScaledVector4(options.SourceRgbWorkingSpace.Expand(rgb.ToScaledVector4()));
 
             // Then convert to xyz
             destination[i] = new CieXyz(Vector3.Transform(linear.ToScaledVector3(), matrix));
@@ -133,7 +176,8 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     }
 
     /// <inheritdoc/>
-    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource() => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource()
+        => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
 
     /// <summary>
     /// Initializes the color instance from a generic scaled <see cref="Vector3"/>.
@@ -141,19 +185,8 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     /// <param name="source">The vector to load the color from.</param>
     /// <returns>The <see cref="Rgb"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Rgb FromScaledVector3(Vector3 source) => new(Vector3.Clamp(source, Vector3.Zero, Vector3.One));
-
-    /// <summary>
-    /// Initializes the color instance from a generic scaled <see cref="Vector4"/>.
-    /// </summary>
-    /// <param name="source">The vector to load the color from.</param>
-    /// <returns>The <see cref="Rgb"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Rgb FromScaledVector4(Vector4 source)
-    {
-        source = Vector4.Clamp(source, Vector4.Zero, Vector4.One);
-        return new(source.X, source.Y, source.Z);
-    }
+    public static Rgb FromScaledVector3(Vector3 source)
+        => new(source);
 
     /// <summary>
     /// Initializes the color instance for a source clamped between <value>0</value> and <value>1</value>
@@ -161,7 +194,8 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     /// <param name="source">The source to load the color from.</param>
     /// <returns>The <see cref="Rgb"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Rgb Clamp(Rgb source) => new(Vector3.Clamp(new(source.R, source.G, source.B), Vector3.Zero, Vector3.One));
+    public static Rgb Clamp(Rgb source)
+        => new(Vector3.Clamp(source.AsVector3Unsafe(), Vector3.Zero, Vector3.One));
 
     /// <summary>
     /// Expands the color into a generic ("scaled") <see cref="Vector3"/> representation
@@ -170,24 +204,12 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     /// </summary>
     /// <returns>The <see cref="Vector3"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToScaledVector3() => Clamp(this).ToVector3();
-
-    /// <summary>
-    /// Expands the color into a generic <see cref="Vector3"/> representation.
-    /// The vector components are typically expanded in least to greatest significance order.
-    /// </summary>
-    /// <returns>The <see cref="Vector3"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToVector3() => new(this.R, this.G, this.B);
-
-    /// <summary>
-    /// Expands the color into a generic ("scaled") <see cref="Vector4"/> representation
-    /// with values scaled and usually clamped between <value>0</value> and <value>1</value>.
-    /// The vector components are typically expanded in least to greatest significance order.
-    /// </summary>
-    /// <returns>The <see cref="Vector4"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector4 ToScaledVector4() => new(this.ToScaledVector3(), 1f);
+    public Vector3 ToScaledVector3()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        return v3;
+    }
 
     /// <inheritdoc/>
     public override int GetHashCode() => HashCode.Combine(this.R, this.G, this.B);
@@ -203,7 +225,7 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     public bool Equals(Rgb other)
         => this.AsVector3Unsafe() == other.AsVector3Unsafe();
 
-    private Vector3 AsVector3Unsafe() => Unsafe.As<Rgb, Vector3>(ref Unsafe.AsRef(in this));
+    internal Vector3 AsVector3Unsafe() => Unsafe.As<Rgb, Vector3>(ref Unsafe.AsRef(in this));
 
     private static Matrix4x4 GetCieXyzToRgbMatrix(RgbWorkingSpace workingSpace)
     {
@@ -249,7 +271,7 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
 
         Matrix4x4.Invert(xyzMatrix, out Matrix4x4 inverseXyzMatrix);
 
-        Vector3 vector = Vector3.Transform(workingSpace.WhitePoint.ToVector3(), inverseXyzMatrix);
+        Vector3 vector = Vector3.Transform(workingSpace.WhitePoint.AsVector3Unsafe(), inverseXyzMatrix);
 
         // Use transposed Rows/Columns
         return new Matrix4x4

src/ImageSharp/ColorProfiles/VonKriesChromaticAdaptation.cs

@@ -34,9 +34,9 @@ public static class VonKriesChromaticAdaptation
             return new(source.X, source.Y, source.Z);
         }
 
-        Vector3 sourceColorLms = Vector3.Transform(source.ToVector3(), matrix);
-        Vector3 sourceWhitePointLms = Vector3.Transform(from.ToVector3(), matrix);
-        Vector3 targetWhitePointLms = Vector3.Transform(to.ToVector3(), matrix);
+        Vector3 sourceColorLms = Vector3.Transform(source.AsVector3Unsafe(), matrix);
+        Vector3 sourceWhitePointLms = Vector3.Transform(from.AsVector3Unsafe(), matrix);
+        Vector3 targetWhitePointLms = Vector3.Transform(to.AsVector3Unsafe(), matrix);
 
         Vector3 vector = targetWhitePointLms / sourceWhitePointLms;
         Vector3 targetColorLms = Vector3.Multiply(vector, sourceColorLms);
@@ -76,8 +76,8 @@ public static class VonKriesChromaticAdaptation
         ref CieXyz sourceBase = ref MemoryMarshal.GetReference(source);
         ref CieXyz destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        Vector3 sourceWhitePointLms = Vector3.Transform(from.ToVector3(), matrix);
-        Vector3 targetWhitePointLms = Vector3.Transform(to.ToVector3(), matrix);
+        Vector3 sourceWhitePointLms = Vector3.Transform(from.AsVector3Unsafe(), matrix);
+        Vector3 targetWhitePointLms = Vector3.Transform(to.AsVector3Unsafe(), matrix);
 
         Vector3 vector = targetWhitePointLms / sourceWhitePointLms;
 
@@ -86,7 +86,7 @@ public static class VonKriesChromaticAdaptation
             ref CieXyz sp = ref Unsafe.Add(ref sourceBase, i);
             ref CieXyz dp = ref Unsafe.Add(ref destinationBase, i);
 
-            Vector3 sourceColorLms = Vector3.Transform(sp.ToVector3(), matrix);
+            Vector3 sourceColorLms = Vector3.Transform(sp.AsVector3Unsafe(), matrix);
 
             Vector3 targetColorLms = Vector3.Multiply(vector, sourceColorLms);
             dp = new CieXyz(Vector3.Transform(targetColorLms, inverseMatrix));

src/ImageSharp/ColorProfiles/Y.cs

@@ -0,0 +1,142 @@
+// 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.ColorProfiles;
+
+/// <summary>
+/// Represents a Y (luminance) color.
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct Y : IColorProfile<Y, Rgb>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Y"/> struct.
+    /// </summary>
+    /// <param name="l">The luminance component.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Y(float l) => this.L = Numerics.Clamp(l, 0, 1);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Y(float l, bool _) => this.L = l;
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+
+    /// <summary>
+    /// Gets the luminance component.
+    /// </summary>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    public float L { get; }
+
+    /// <summary>
+    /// Compares two <see cref="Y"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="Y"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="Y"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator ==(Y left, Y right) => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="Y"/> objects for inequality.
+    /// </summary>
+    /// <param name="left">The <see cref="Y"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="Y"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator !=(Y left, Y right) => !left.Equals(right);
+
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4() => new(this.L);
+
+    /// <inheritdoc/>
+    public static Y FromScaledVector4(Vector4 source) => new(source.X, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Y> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Y> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
+    /// <inheritdoc/>
+    public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
+        => new(this.L, this.L, this.L);
+
+    /// <inheritdoc/>
+    public static Y FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    {
+        Matrix4x4 m = options.YCbCrMatrix.Forward;
+        float offset = options.YCbCrMatrix.Offset.X;
+        return new(Vector3.Dot(source.AsVector3Unsafe(), new Vector3(m.M11, m.M12, m.M13)) + offset);
+    }
+
+    /// <inheritdoc/>
+    public static void ToProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Y> source, Span<Rgb> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToProfileConnectingSpace(options);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Rgb> source, Span<Y> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            Rgb rgb = source[i];
+            destination[i] = FromProfileConnectingSpace(options, in rgb);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource()
+        => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override int GetHashCode()
+        => this.L.GetHashCode();
+
+    /// <inheritdoc/>
+    public override string ToString()
+        => FormattableString.Invariant($"Y({this.L:#0.##})");
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+        => obj is Y other && this.Equals(other);
+
+    /// <inheritdoc/>
+    public bool Equals(Y other) => this.L == other.L;
+}

src/ImageSharp/ColorProfiles/YCbCr.cs

@@ -8,15 +8,13 @@ using System.Runtime.InteropServices;
 namespace SixLabors.ImageSharp.ColorProfiles;
 
 /// <summary>
-/// Represents an YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification for the JFIF use with Jpeg.
-/// <see href="http://en.wikipedia.org/wiki/YCbCr"/>
-/// <see href="http://www.ijg.org/files/T-REC-T.871-201105-I!!PDF-E.pdf"/>
+/// Represents an YCbCr (luminance, blue chroma, red chroma) color.
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
 public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
 {
     private static readonly Vector3 Min = Vector3.Zero;
-    private static readonly Vector3 Max = new(255);
+    private static readonly Vector3 Max = Vector3.One;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="YCbCr"/> struct.
@@ -43,21 +41,31 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
         this.Cr = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private YCbCr(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.Y = vector.X;
+        this.Cb = vector.Y;
+        this.Cr = vector.Z;
+    }
+
     /// <summary>
     /// Gets the Y luminance component.
-    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
     /// </summary>
     public float Y { get; }
 
     /// <summary>
     /// Gets the Cb chroma component.
-    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
     /// </summary>
     public float Cb { get; }
 
     /// <summary>
     /// Gets the Cr chroma component.
-    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
     /// </summary>
     public float Cr { get; }
 
@@ -83,18 +91,49 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
     public static bool operator !=(YCbCr left, YCbCr right) => !left.Equals(right);
 
     /// <inheritdoc/>
-    public static YCbCr FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    public Vector4 ToScaledVector4()
     {
-        Vector3 rgb = source.ToScaledVector3() * Max;
-        float r = rgb.X;
-        float g = rgb.Y;
-        float b = rgb.Z;
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        return new Vector4(v3, 1F);
+    }
 
-        float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
-        float cb = 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b));
-        float cr = 128F + ((0.5F * r) - (0.418688F * g) - (0.081312F * b));
+    /// <inheritdoc/>
+    public static YCbCr FromScaledVector4(Vector4 source)
+        => new(source.AsVector3(), true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<YCbCr> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        return new YCbCr(y, cb, cr);
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<YCbCr> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static YCbCr FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    {
+        Vector3 rgb = source.AsVector3Unsafe();
+        Matrix4x4 m = options.TransposedYCbCrMatrix.Forward;
+        Vector3 offset = options.TransposedYCbCrMatrix.Offset;
+
+        return new YCbCr(Vector3.Transform(rgb, m) + offset, true);
     }
 
     /// <inheritdoc/>
@@ -113,15 +152,11 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
     /// <inheritdoc/>
     public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
     {
-        float y = this.Y;
-        float cb = this.Cb - 128F;
-        float cr = this.Cr - 128F;
-
-        float r = MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero);
-        float g = MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero);
-        float b = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
+        Matrix4x4 m = options.TransposedYCbCrMatrix.Inverse;
+        Vector3 offset = options.TransposedYCbCrMatrix.Offset;
+        Vector3 normalized = this.AsVector3Unsafe() - offset;
 
-        return Rgb.FromScaledVector3(new Vector3(r, g, b) / Max);
+        return Rgb.FromScaledVector3(Vector3.Transform(normalized, m));
     }
 
     /// <inheritdoc/>
@@ -132,8 +167,7 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
         // TODO: We can optimize this by using SIMD
         for (int i = 0; i < source.Length; i++)
         {
-            YCbCr ycbcr = source[i];
-            destination[i] = ycbcr.ToProfileConnectingSpace(options);
+            destination[i] = source[i].ToProfileConnectingSpace(options);
         }
     }
 

src/ImageSharp/ColorProfiles/YcbCrMatrix.cs

@@ -0,0 +1,61 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.WorkingSpaces;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// <para>
+/// Represents a YCbCr color matrix containing forward and inverse transformation matrices,
+/// and the chrominance offsets to apply for full-range encoding
+/// </para>
+/// <para>
+/// These matrices must be selected to match the characteristics of the associated <see cref="RgbWorkingSpace"/>,
+/// including its transfer function (gamma or companding) and chromaticity coordinates. Using mismatched matrices and
+/// working spaces will produce incorrect conversions.
+/// </para>
+/// </summary>
+public readonly struct YCbCrMatrix
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YCbCrMatrix"/> struct.
+    /// </summary>
+    /// <param name="forward">
+    /// The forward transformation matrix from RGB to YCbCr. The matrix must include the
+    /// standard chrominance offsets in the fourth column, such as <c>(0, 0.5, 0.5)</c>.
+    /// </param>
+    /// <param name="inverse">
+    /// The inverse transformation matrix from YCbCr to RGB. This matrix expects that
+    /// chrominance offsets have already been subtracted prior to application.
+    /// </param>
+    /// <param name="offset">
+    /// The chrominance offsets to be added after the forward conversion,
+    /// and subtracted before the inverse conversion. Usually <c>(0, 0.5, 0.5)</c>.
+    /// </param>
+    public YCbCrMatrix(Matrix4x4 forward, Matrix4x4 inverse, Vector3 offset)
+    {
+        this.Forward = forward;
+        this.Inverse = inverse;
+        this.Offset = offset;
+    }
+
+    /// <summary>
+    /// Gets the matrix used to convert gamma-encoded RGB to YCbCr.
+    /// </summary>
+    public Matrix4x4 Forward { get; }
+
+    /// <summary>
+    /// Gets the matrix used to convert YCbCr back to gamma-encoded RGB.
+    /// </summary>
+    public Matrix4x4 Inverse { get; }
+
+    /// <summary>
+    /// Gets the chrominance offset vector to apply during encoding (add) or decoding (subtract).
+    /// </summary>
+    public Vector3 Offset { get; }
+
+    internal YCbCrMatrix Transpose()
+        => new(Matrix4x4.Transpose(this.Forward), Matrix4x4.Transpose(this.Inverse), this.Offset);
+}

src/ImageSharp/ColorProfiles/YccK.cs

@@ -0,0 +1,206 @@
+// 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.ColorProfiles;
+
+/// <summary>
+/// Represents a YCCK (luminance, blue chroma, red chroma, black) color.
+/// YCCK is not a true color space but a reversible transform of CMYK, where the CMY components
+/// are converted to YCbCr using the ITU-R BT.601 standard, and the K (black) component is preserved separately.
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct YccK : IColorProfile<YccK, Rgb>
+{
+    private static readonly Vector4 Min = Vector4.Zero;
+    private static readonly Vector4 Max = Vector4.One;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YccK"/> struct.
+    /// </summary>
+    /// <param name="y">The y luminance component.</param>
+    /// <param name="cb">The cb chroma component.</param>
+    /// <param name="cr">The cr chroma component.</param>
+    /// <param name="k">The keyline black component.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public YccK(float y, float cb, float cr, float k)
+        : this(new Vector4(y, cb, cr, k))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YccK"/> struct.
+    /// </summary>
+    /// <param name="vector">The vector representing the c, m, y, k components.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public YccK(Vector4 vector)
+    {
+        vector = Vector4.Clamp(vector, Min, Max);
+        this.Y = vector.X;
+        this.Cb = vector.Y;
+        this.Cr = vector.Z;
+        this.K = vector.W;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private YccK(Vector4 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.Y = vector.X;
+        this.Cb = vector.Y;
+        this.Cr = vector.Z;
+        this.K = vector.W;
+    }
+
+    /// <summary>
+    /// Gets the Y luminance component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float Y { get; }
+
+    /// <summary>
+    /// Gets the C (blue) chroma component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float Cb { get; }
+
+    /// <summary>
+    /// Gets the C (red) chroma component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float Cr { get; }
+
+    /// <summary>
+    /// Gets the keyline black color component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float K { get; }
+
+    /// <summary>
+    /// Compares two <see cref="YccK"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="YccK"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="YccK"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator ==(YccK left, YccK right) => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="YccK"/> objects for inequality.
+    /// </summary>
+    /// <param name="left">The <see cref="YccK"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="YccK"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator !=(YccK left, YccK right) => !left.Equals(right);
+
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector4 v4 = default;
+        v4 += this.AsVector4Unsafe();
+        return v4;
+    }
+
+    /// <inheritdoc/>
+    public static YccK FromScaledVector4(Vector4 source)
+        => new(source, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<YccK> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<YccK, Vector4>(source).CopyTo(destination);
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<YccK> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<Vector4, YccK>(source).CopyTo(destination);
+    }
+
+    /// <inheritdoc/>
+    public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
+    {
+        Matrix4x4 m = options.TransposedYCbCrMatrix.Inverse;
+        Vector3 offset = options.TransposedYCbCrMatrix.Offset;
+        Vector3 normalized = this.AsVector3Unsafe() - offset;
+
+        return Rgb.FromScaledVector3(Vector3.Transform(normalized, m) * (1F - this.K));
+    }
+
+    /// <inheritdoc/>
+    public static YccK FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    {
+        Matrix4x4 m = options.TransposedYCbCrMatrix.Forward;
+        Vector3 offset = options.TransposedYCbCrMatrix.Offset;
+
+        Vector3 rgb = source.AsVector3Unsafe();
+        float k = 1F - MathF.Max(rgb.X, MathF.Max(rgb.Y, rgb.Z));
+
+        if (k >= 1F - Constants.Epsilon)
+        {
+            return new YccK(new Vector4(0F, 0.5F, 0.5F, 1F), true);
+        }
+
+        rgb /= 1F - k;
+        return new YccK(new Vector4(Vector3.Transform(rgb, m), k) + new Vector4(offset, 0F));
+    }
+
+    /// <inheritdoc/>
+    public static void ToProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<YccK> source, Span<Rgb> destination)
+    {
+        // TODO: We can possibly optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToProfileConnectingSpace(options);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Rgb> source, Span<YccK> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            Rgb rgb = source[i];
+            destination[i] = FromProfileConnectingSpace(options, in rgb);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource()
+        => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override int GetHashCode()
+        => HashCode.Combine(this.Y, this.Cb, this.Cr, this.K);
+
+    /// <inheritdoc/>
+    public override string ToString()
+        => FormattableString.Invariant($"YccK({this.Y:#0.##}, {this.Cb:#0.##}, {this.Cr:#0.##}, {this.K:#0.##})");
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+        => obj is YccK other && this.Equals(other);
+
+    /// <inheritdoc/>
+    public bool Equals(YccK other)
+        => this.AsVector4Unsafe() == other.AsVector4Unsafe();
+
+    private Vector3 AsVector3Unsafe() => Unsafe.As<YccK, Vector3>(ref Unsafe.AsRef(in this));
+
+    private Vector4 AsVector4Unsafe() => Unsafe.As<YccK, Vector4>(ref Unsafe.AsRef(in this));
+}

src/ImageSharp/Common/Extensions/Vector4Extensions.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#if !NET9_0_OR_GREATER
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp;
+
+internal static class Vector4Extensions
+{
+    /// <summary>
+    /// Reinterprets a <see cref="Vector4" /> as a new <see cref="Vector3" />.
+    /// </summary>
+    /// <param name="value">The vector to reinterpret.</param>
+    /// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector3" />.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector3 AsVector3(this Vector4 value) => value.AsVector128().AsVector3();
+}
+#endif

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

@@ -616,35 +616,7 @@ internal static partial class SimdUtils
                 return Fma.MultiplyAdd(vm1, vm0, va);
             }
 
-            return Avx.Add(Avx.Multiply(vm0, vm1), va);
-        }
-
-        /// <summary>
-        /// Performs a multiplication and an addition of the <see cref="Vector128{Single}"/>.
-        /// TODO: Fix. The arguments are in a different order to the FMA intrinsic.
-        /// </summary>
-        /// <remarks>ret = (vm0 * vm1) + va</remarks>
-        /// <param name="va">The vector to add to the 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.AlwaysInline)]
-        public static Vector128<float> MultiplyAdd(
-            Vector128<float> va,
-            Vector128<float> vm0,
-            Vector128<float> vm1)
-        {
-            if (Fma.IsSupported)
-            {
-                return Fma.MultiplyAdd(vm1, vm0, va);
-            }
-
-            if (AdvSimd.IsSupported)
-            {
-                return AdvSimd.Add(AdvSimd.Multiply(vm0, vm1), va);
-            }
-
-            return Sse.Add(Sse.Multiply(vm0, vm1), va);
+            return va + (vm0 * vm1);
         }
 
         /// <summary>

src/ImageSharp/Common/Helpers/SimdUtils.cs

@@ -1,11 +1,11 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp;
@@ -36,30 +36,39 @@ internal static partial class SimdUtils
 
     /// <summary>
     /// Rounds all values in 'v' to the nearest integer following <see cref="MidpointRounding.ToEven"/> semantics.
-    /// Source:
-    /// <see>
-    ///     <cref>https://github.com/g-truc/glm/blob/master/glm/simd/common.h#L110</cref>
-    /// </see>
     /// </summary>
     /// <param name="v">The vector</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static Vector<float> FastRound(this Vector<float> v)
     {
-        if (Avx2.IsSupported)
+        // .NET9+ has a built-in method for this Vector.Round
+        if (Avx2.IsSupported && Vector<float>.Count == Vector256<float>.Count)
         {
             ref Vector256<float> v256 = ref Unsafe.As<Vector<float>, Vector256<float>>(ref v);
             Vector256<float> vRound = Avx.RoundToNearestInteger(v256);
             return Unsafe.As<Vector256<float>, Vector<float>>(ref vRound);
         }
-        else
+
+        if (Sse41.IsSupported && Vector<float>.Count == Vector128<float>.Count)
+        {
+            ref Vector128<float> v128 = ref Unsafe.As<Vector<float>, Vector128<float>>(ref v);
+            Vector128<float> vRound = Sse41.RoundToNearestInteger(v128);
+            return Unsafe.As<Vector128<float>, Vector<float>>(ref vRound);
+        }
+
+        if (AdvSimd.IsSupported && Vector<float>.Count == Vector128<float>.Count)
         {
-            var magic0 = new Vector<int>(int.MinValue); // 0x80000000
-            var sgn0 = Vector.AsVectorSingle(magic0);
-            var and0 = Vector.BitwiseAnd(sgn0, v);
-            var or0 = Vector.BitwiseOr(and0, new Vector<float>(8388608.0f));
-            var add0 = Vector.Add(v, or0);
-            return Vector.Subtract(add0, or0);
+            ref Vector128<float> v128 = ref Unsafe.As<Vector<float>, Vector128<float>>(ref v);
+            Vector128<float> vRound = AdvSimd.RoundToNearest(v128);
+            return Unsafe.As<Vector128<float>, Vector<float>>(ref vRound);
         }
+
+        // https://github.com/g-truc/glm/blob/master/glm/simd/common.h#L11
+        Vector<float> sign = v & new Vector<float>(-0F);
+        Vector<float> val_2p23_f32 = sign | new Vector<float>(8388608F);
+
+        val_2p23_f32 = (v + val_2p23_f32) - val_2p23_f32;
+        return val_2p23_f32 | sign;
     }
 
     [Conditional("DEBUG")]

src/ImageSharp/Common/Helpers/Vector128Utilities.cs

@@ -193,13 +193,65 @@ internal static class Vector128Utilities
             return AdvSimd.ConvertToInt32RoundToEven(vector);
         }
 
-        Vector128<float> sign = vector & Vector128.Create(-0.0f);
-        Vector128<float> val_2p23_f32 = sign | Vector128.Create(8388608.0f);
+        Vector128<float> sign = vector & Vector128.Create(-0F);
+        Vector128<float> val_2p23_f32 = sign | Vector128.Create(8388608F);
 
         val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
         return Vector128.ConvertToInt32(val_2p23_f32 | sign);
     }
 
+    /// <summary>
+    /// Rounds all values in <paramref name="vector"/> to the nearest integer
+    /// following <see cref="MidpointRounding.ToEven"/> semantics.
+    /// </summary>
+    /// <param name="vector">The vector</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<float> RoundToNearestInteger(Vector128<float> vector)
+    {
+        if (Sse41.IsSupported)
+        {
+            return Sse41.RoundToNearestInteger(vector);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.RoundToNearest(vector);
+        }
+
+        Vector128<float> sign = vector & Vector128.Create(-0F);
+        Vector128<float> val_2p23_f32 = sign | Vector128.Create(8388608F);
+
+        val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
+        return val_2p23_f32 | sign;
+    }
+
+    /// <summary>
+    /// Performs a multiplication and an addition of the <see cref="Vector128{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = (vm0 * vm1) + va</remarks>
+    /// <param name="va">The vector to add to the 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(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<float> MultiplyAdd(
+        Vector128<float> va,
+        Vector128<float> vm0,
+        Vector128<float> vm1)
+    {
+        if (Fma.IsSupported)
+        {
+            return Fma.MultiplyAdd(vm1, vm0, va);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.FusedMultiplyAdd(va, vm0, vm1);
+        }
+
+        return va + (vm0 * vm1);
+    }
+
     /// <summary>
     /// Packs signed 16-bit integers to unsigned 8-bit integers and saturates.
     /// </summary>

src/ImageSharp/Common/Helpers/Vector256Utilities.cs

@@ -103,13 +103,55 @@ internal static class Vector256Utilities
             return Vector256.Create(lower, upper);
         }
 
-        Vector256<float> sign = vector & Vector256.Create(-0.0f);
-        Vector256<float> val_2p23_f32 = sign | Vector256.Create(8388608.0f);
+        Vector256<float> sign = vector & Vector256.Create(-0F);
+        Vector256<float> val_2p23_f32 = sign | Vector256.Create(8388608F);
 
         val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
         return Vector256.ConvertToInt32(val_2p23_f32 | sign);
     }
 
+    /// <summary>
+    /// Rounds all values in <paramref name="vector"/> to the nearest integer
+    /// following <see cref="MidpointRounding.ToEven"/> semantics.
+    /// </summary>
+    /// <param name="vector">The vector</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> RoundToNearestInteger(Vector256<float> vector)
+    {
+        if (Avx.IsSupported)
+        {
+            return Avx.RoundToNearestInteger(vector);
+        }
+
+        Vector256<float> sign = vector & Vector256.Create(-0F);
+        Vector256<float> val_2p23_f32 = sign | Vector256.Create(8388608F);
+
+        val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
+        return val_2p23_f32 | sign;
+    }
+
+    /// <summary>
+    /// Performs a multiplication and an addition of the <see cref="Vector256{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = (vm0 * vm1) + va</remarks>
+    /// <param name="va">The vector to add to the 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(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyAdd(
+        Vector256<float> va,
+        Vector256<float> vm0,
+        Vector256<float> vm1)
+    {
+        if (Fma.IsSupported)
+        {
+            return Fma.MultiplyAdd(vm0, vm1, va);
+        }
+
+        return va + (vm0 * vm1);
+    }
+
     [DoesNotReturn]
     private static void ThrowUnreachableException() => throw new UnreachableException();
 }

src/ImageSharp/Common/Helpers/Vector512Utilities.cs

@@ -110,6 +110,51 @@ internal static class Vector512Utilities
         return Vector512.ConvertToInt32(val_2p23_f32 | sign);
     }
 
+    /// <summary>
+    /// Rounds all values in <paramref name="vector"/> to the nearest integer
+    /// following <see cref="MidpointRounding.ToEven"/> semantics.
+    /// </summary>
+    /// <param name="vector">The vector</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> RoundToNearestInteger(Vector512<float> vector)
+    {
+        if (Avx512F.IsSupported)
+        {
+            // imm8 = 0b1000:
+            //   imm8[7:4] = 0b0000 -> preserve 0 fractional bits (round to whole numbers)
+            //   imm8[3:0] = 0b1000 -> _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC (round to nearest even, suppress exceptions)
+            return Avx512F.RoundScale(vector, 0b0000_1000);
+        }
+
+        Vector512<float> sign = vector & Vector512.Create(-0F);
+        Vector512<float> val_2p23_f32 = sign | Vector512.Create(8388608F);
+
+        val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
+        return val_2p23_f32 | sign;
+    }
+
+    /// <summary>
+    /// Performs a multiplication and an addition of the <see cref="Vector512{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = (vm0 * vm1) + va</remarks>
+    /// <param name="va">The vector to add to the 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(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyAdd(
+        Vector512<float> va,
+        Vector512<float> vm0,
+        Vector512<float> vm1)
+    {
+        if (Avx512F.IsSupported)
+        {
+            return Avx512F.FusedMultiplyAdd(vm0, vm1, va);
+        }
+
+        return va + (vm0 * vm1);
+    }
+
     [DoesNotReturn]
     private static void ThrowUnreachableException() => throw new UnreachableException();
 }

src/ImageSharp/Formats/ColorProfileHandling.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats;
+
+/// <summary>
+/// Provides enumeration of methods that control how ICC profiles are handled during decode.
+/// </summary>
+public enum ColorProfileHandling
+{
+    /// <summary>
+    /// Leaves any embedded ICC color profiles intact.
+    /// </summary>
+    Preserve,
+
+    /// <summary>
+    /// Transforms the pixels of the image based on the conversion of any embedded ICC color profiles to sRGB V4 profile.
+    /// The original profile is then replaced.
+    /// </summary>
+    Convert
+}

src/ImageSharp/Formats/DecoderOptions.cs

@@ -60,5 +60,11 @@ public sealed class DecoderOptions
     /// </summary>
     public SegmentIntegrityHandling SegmentIntegrityHandling { get; init; } = SegmentIntegrityHandling.IgnoreNonCritical;
 
+    /// <summary>
+    /// Gets a value that controls how ICC profiles are handled during decode.
+    /// TODO: Implement this.
+    /// </summary>
+    internal ColorProfileHandling ColorProfileHandling { get; init; }
+
     internal void SetConfiguration(Configuration configuration) => this.configuration = configuration;
 }

src/ImageSharp/Formats/ImageDecoder.cs

@@ -46,10 +46,10 @@ public abstract class ImageDecoder : IImageDecoder
         where TPixel : unmanaged, IPixel<TPixel>
     {
         Image<TPixel> image = await WithSeekableMemoryStreamAsync(
-                options,
-                stream,
-                (s, ct) => this.Decode<TPixel>(options, s, ct),
-                cancellationToken).ConfigureAwait(false);
+            options,
+            stream,
+            (s, ct) => this.Decode<TPixel>(options, s, ct),
+            cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.Configuration, image);
 

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

@@ -13,14 +13,14 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values) =>
-            ConvertToRgbInplace(values, this.MaximumValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values) =>
+            ConvertToRgbInPlace(values, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, this.MaximumValue, r, g, b);
+        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)
+        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue)
         {
             Span<float> c0 = values.Component0;
             Span<float> c1 = values.Component1;
@@ -42,7 +42,7 @@ internal abstract partial class JpegColorConverterBase
             }
         }
 
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
+        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;
@@ -51,9 +51,9 @@ internal abstract partial class JpegColorConverterBase
 
             for (int i = 0; i < c.Length; i++)
             {
-                float ctmp = 255f - r[i];
-                float mtmp = 255f - g[i];
-                float ytmp = 255f - b[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)

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

@@ -1,104 +0,0 @@
-// 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.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class CmykVector : JpegColorConverterVector
-    {
-        public CmykVector(int precision)
-            : base(JpegColorSpace.Cmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> cBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> mBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> yBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector<float> kBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector<float> c = ref Unsafe.Add(ref cBase, i);
-                ref Vector<float> m = ref Unsafe.Add(ref mBase, i);
-                ref Vector<float> y = ref Unsafe.Add(ref yBase, i);
-                Vector<float> k = Unsafe.Add(ref kBase, i);
-
-                k *= scale;
-                c *= k;
-                m *= k;
-                y *= k;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-             => CmykScalar.ConvertToRgbInplace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgbInplaceVectorized(in values, this.MaximumValue, r, g, b);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgbInplaceRemainder(values, this.MaximumValue, r, g, b);
-
-        public static void ConvertFromRgbInplaceVectorized(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
-        {
-            ref Vector<float> destC =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> destM =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> destY =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector<float> destK =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector<float> srcR =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(r));
-            ref Vector<float> srcG =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(g));
-            ref Vector<float> srcB =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(b));
-
-            // Used for the color conversion
-            var scale = new Vector<float>(maxValue);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector<float> ktmp = Vector.Min(ctmp, Vector.Min(mtmp, ytmp));
-
-                var kMask = Vector.Equals(ktmp, scale);
-                ctmp = Vector.AndNot((ctmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
-                mtmp = Vector.AndNot((mtmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
-                ytmp = Vector.AndNot((ytmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
-
-                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;
-            }
-        }
-
-        public static void ConvertFromRgbInplaceRemainder(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
-            => CmykScalar.ConvertFromRgb(values, maxValue, r, g, b);
-    }
-}

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

@@ -1,24 +1,23 @@
-// Copyright (c) Six Labors.
+// 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.Arm;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class CmykArm64 : JpegColorConverterArm64
+    internal sealed class CmykVector128 : JpegColorConverterVector128
     {
-        public CmykArm64(int precision)
+        public CmykVector128(int precision)
             : base(JpegColorSpace.Cmyk, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> c0Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -30,20 +29,20 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
 
             // Used for the color conversion
-            var scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
+            Vector128<float> scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
 
-            nint n = (nint)(uint)values.Component0.Length / Vector128<float>.Count;
-            for (nint i = 0; i < n; i++)
+            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 = AdvSimd.Multiply(k, scale);
-                c = AdvSimd.Multiply(c, k);
-                m = AdvSimd.Multiply(m, k);
-                y = AdvSimd.Multiply(y, k);
+                k *= scale;
+                c *= k;
+                m *= k;
+                y *= k;
             }
         }
 
@@ -69,26 +68,27 @@ internal abstract partial class JpegColorConverterBase
             ref Vector128<float> srcB =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            var scale = Vector128.Create(maxValue);
+            Vector128<float> scale = Vector128.Create(maxValue);
 
-            nint n = (nint)(uint)values.Component0.Length / Vector128<float>.Count;
-            for (nint i = 0; i < n; i++)
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
             {
-                Vector128<float> ctmp = AdvSimd.Subtract(scale, Unsafe.Add(ref srcR, i));
-                Vector128<float> mtmp = AdvSimd.Subtract(scale, Unsafe.Add(ref srcG, i));
-                Vector128<float> ytmp = AdvSimd.Subtract(scale, Unsafe.Add(ref srcB, i));
-                Vector128<float> ktmp = AdvSimd.Min(ctmp, AdvSimd.Min(mtmp, ytmp));
+                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 = AdvSimd.Not(AdvSimd.CompareEqual(ktmp, scale));
+                Vector128<float> kMask = ~Vector128.Equals(ktmp, scale);
+                Vector128<float> divisor = scale - ktmp;
 
-                ctmp = AdvSimd.And(AdvSimd.Arm64.Divide(AdvSimd.Subtract(ctmp, ktmp), AdvSimd.Subtract(scale, ktmp)), kMask);
-                mtmp = AdvSimd.And(AdvSimd.Arm64.Divide(AdvSimd.Subtract(mtmp, ktmp), AdvSimd.Subtract(scale, ktmp)), kMask);
-                ytmp = AdvSimd.And(AdvSimd.Arm64.Divide(AdvSimd.Subtract(ytmp, ktmp), AdvSimd.Subtract(scale, ktmp)), kMask);
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
 
-                Unsafe.Add(ref destC, i) = AdvSimd.Subtract(scale, AdvSimd.Multiply(ctmp, scale));
-                Unsafe.Add(ref destM, i) = AdvSimd.Subtract(scale, AdvSimd.Multiply(mtmp, scale));
-                Unsafe.Add(ref destY, i) = AdvSimd.Subtract(scale, AdvSimd.Multiply(ytmp, scale));
-                Unsafe.Add(ref destK, i) = AdvSimd.Subtract(scale, ktmp);
+                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.CmykAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector256.cs

@@ -1,24 +1,23 @@
-// Copyright (c) Six Labors.
+// 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.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class CmykAvx : JpegColorConverterAvx
+    internal sealed class CmykVector256 : JpegColorConverterVector256
     {
-        public CmykAvx(int precision)
+        public CmykVector256(int precision)
             : base(JpegColorSpace.Cmyk, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -30,7 +29,7 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
 
             // Used for the color conversion
-            var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
+            Vector256<float> scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
@@ -40,10 +39,10 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector256<float> y = ref Unsafe.Add(ref c2Base, i);
                 Vector256<float> k = Unsafe.Add(ref c3Base, i);
 
-                k = Avx.Multiply(k, scale);
-                c = Avx.Multiply(c, k);
-                m = Avx.Multiply(m, k);
-                y = Avx.Multiply(y, k);
+                k *= scale;
+                c *= k;
+                m *= k;
+                y *= k;
             }
         }
 
@@ -69,26 +68,27 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> srcB =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            var scale = Vector256.Create(maxValue);
+            Vector256<float> scale = Vector256.Create(maxValue);
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
             {
-                Vector256<float> ctmp = Avx.Subtract(scale, Unsafe.Add(ref srcR, i));
-                Vector256<float> mtmp = Avx.Subtract(scale, Unsafe.Add(ref srcG, i));
-                Vector256<float> ytmp = Avx.Subtract(scale, Unsafe.Add(ref srcB, i));
-                Vector256<float> ktmp = Avx.Min(ctmp, Avx.Min(mtmp, ytmp));
+                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 = Avx.CompareNotEqual(ktmp, scale);
+                Vector256<float> kMask = ~Vector256.Equals(ktmp, scale);
+                Vector256<float> divisor = scale - ktmp;
 
-                ctmp = Avx.And(Avx.Divide(Avx.Subtract(ctmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
-                mtmp = Avx.And(Avx.Divide(Avx.Subtract(mtmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
-                ytmp = Avx.And(Avx.Divide(Avx.Subtract(ytmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
 
-                Unsafe.Add(ref destC, i) = Avx.Subtract(scale, Avx.Multiply(ctmp, scale));
-                Unsafe.Add(ref destM, i) = Avx.Subtract(scale, Avx.Multiply(mtmp, scale));
-                Unsafe.Add(ref destY, i) = Avx.Subtract(scale, Avx.Multiply(ytmp, scale));
-                Unsafe.Add(ref destK, i) = Avx.Subtract(scale, ktmp);
+                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

@@ -0,0 +1,103 @@
+// 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.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class CmykVector512 : JpegColorConverterVector512
+    {
+        public CmykVector512(int precision)
+            : base(JpegColorSpace.Cmyk, 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> 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.GrayScaleScalar.cs

@@ -8,22 +8,22 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class GrayscaleScalar : JpegColorConverterScalar
+    internal sealed class GrayScaleScalar : JpegColorConverterScalar
     {
-        public GrayscaleScalar(int precision)
+        public GrayScaleScalar(int precision)
             : base(JpegColorSpace.Grayscale, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgbInplace(values.Component0, this.MaximumValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(values.Component0, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertCoreInplaceFromRgb(values, r, g, b);
+        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(Span<float> values, float maxValue)
+        internal static void ConvertToRgbInPlace(Span<float> values, float maxValue)
         {
             ref float valuesRef = ref MemoryMarshal.GetReference(values);
             float scale = 1 / maxValue;
@@ -34,15 +34,14 @@ internal abstract partial class JpegColorConverterBase
             }
         }
 
-        internal static void ConvertCoreInplaceFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        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++)
             {
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                float luma = (0.299f * rLane[i]) + (0.587f * gLane[i]) + (0.114f * bLane[i]);
-                c0[i] = luma;
+                // 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.GrayScaleVector.cs

@@ -1,72 +0,0 @@
-// 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.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class GrayScaleVector : JpegColorConverterVector
-    {
-        public GrayScaleVector(int precision)
-            : base(JpegColorSpace.Grayscale, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> cBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            var scale = new Vector<float>(1 / this.MaximumValue);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector<float> c0 = ref Unsafe.Add(ref cBase, i);
-                c0 *= scale;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => GrayscaleScalar.ConvertToRgbInplace(values.Component0, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector<float> destLuma =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector<float> srcR =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector<float> srcG =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector<float> srcB =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            var rMult = new Vector<float>(0.299f);
-            var gMult = new Vector<float>(0.587f);
-            var bMult = new Vector<float>(0.114f);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> r = Unsafe.Add(ref srcR, i);
-                Vector<float> g = Unsafe.Add(ref srcR, i);
-                Vector<float> b = Unsafe.Add(ref srcR, i);
-
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuma, i) = (rMult * r) + (gMult * g) + (bMult * b);
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => GrayscaleScalar.ConvertCoreInplaceFromRgb(values, r, g, b);
-    }
-}

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

@@ -1,37 +1,36 @@
-// Copyright (c) Six Labors.
+// 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.Arm;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class GrayscaleArm : JpegColorConverterArm
+    internal sealed class GrayScaleVector128 : JpegColorConverterVector128
     {
-        public GrayscaleArm(int precision)
+        public GrayScaleVector128(int precision)
             : base(JpegColorSpace.Grayscale, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> c0Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
 
             // Used for the color conversion
-            var scale = Vector128.Create(1 / this.MaximumValue);
+            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
 
             nuint n = values.Component0.Vector128Count<float>();
             for (nuint i = 0; i < n; i++)
             {
                 ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                c0 = AdvSimd.Multiply(c0, scale);
+                c0 *= scale;
             }
         }
 
@@ -49,9 +48,9 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
 
             // Used for the color conversion
-            var f0299 = Vector128.Create(0.299f);
-            var f0587 = Vector128.Create(0.587f);
-            var f0114 = Vector128.Create(0.114f);
+            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++)
@@ -60,8 +59,8 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector128<float> g = ref Unsafe.Add(ref srcGreen, i);
                 ref Vector128<float> b = ref Unsafe.Add(ref srcBlue, i);
 
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuminance, i) = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f0114, b), f0587, g), f0299, r);
+                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                Unsafe.Add(ref destLuminance, i) = Vector128Utilities.MultiplyAdd(Vector128Utilities.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
             }
         }
     }

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

@@ -1,37 +1,36 @@
-// Copyright (c) Six Labors.
+// 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;
-using static SixLabors.ImageSharp.SimdUtils;
+using Vector256_ = SixLabors.ImageSharp.Common.Helpers.Vector256Utilities;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class GrayscaleAvx : JpegColorConverterAvx
+    internal sealed class GrayScaleVector256 : JpegColorConverterVector256
     {
-        public GrayscaleAvx(int precision)
+        public GrayScaleVector256(int precision)
             : base(JpegColorSpace.Grayscale, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
 
             // Used for the color conversion
-            var scale = Vector256.Create(1 / this.MaximumValue);
+            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
             {
                 ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                c0 = Avx.Multiply(c0, scale);
+                c0 *= scale;
             }
         }
 
@@ -49,9 +48,9 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
 
             // Used for the color conversion
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
+            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++)
@@ -60,8 +59,8 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector256<float> g = ref Unsafe.Add(ref srcGreen, i);
                 ref Vector256<float> b = ref Unsafe.Add(ref srcBlue, i);
 
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuminance, i) = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
+                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                Unsafe.Add(ref destLuminance, i) = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
             }
         }
     }

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

@@ -0,0 +1,75 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using Vector512_ = SixLabors.ImageSharp.Common.Helpers.Vector512Utilities;
+
+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/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> c0Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+
+            // 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> c0 = ref Unsafe.Add(ref c0Base, i);
+                c0 *= scale;
+            }
+        }
+
+        /// <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_.MultiplyAdd(Vector512_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+            => GrayScaleScalar.ConvertToRgbInPlace(values.Component0, 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.RgbScalar.cs

@@ -13,25 +13,25 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgbInplace(values, this.MaximumValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(values, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, r, g, b);
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(values, rLane, gLane, bLane);
 
-        internal static void ConvertToRgbInplace(ComponentValues values, float maxValue)
+        internal static void ConvertToRgbInPlace(ComponentValues values, float maxValue)
         {
-            GrayscaleScalar.ConvertToRgbInplace(values.Component0, maxValue);
-            GrayscaleScalar.ConvertToRgbInplace(values.Component1, maxValue);
-            GrayscaleScalar.ConvertToRgbInplace(values.Component2, maxValue);
+            GrayScaleScalar.ConvertToRgbInPlace(values.Component0, maxValue);
+            GrayScaleScalar.ConvertToRgbInPlace(values.Component1, maxValue);
+            GrayScaleScalar.ConvertToRgbInPlace(values.Component2, maxValue);
         }
 
-        internal static void ConvertFromRgb(ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+        internal static void ConvertFromRgb(ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
-            r.CopyTo(values.Component0);
-            g.CopyTo(values.Component1);
-            b.CopyTo(values.Component2);
+            rLane.CopyTo(values.Component0);
+            gLane.CopyTo(values.Component1);
+            bLane.CopyTo(values.Component2);
         }
     }
 }

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

@@ -1,59 +0,0 @@
-// 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.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class RgbVector : JpegColorConverterVector
-    {
-        public RgbVector(int precision)
-            : base(JpegColorSpace.RGB, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> rBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> gBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> bBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            var scale = new Vector<float>(1 / this.MaximumValue);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector<float> r = ref Unsafe.Add(ref rBase, i);
-                ref Vector<float> g = ref Unsafe.Add(ref gBase, i);
-                ref Vector<float> b = ref Unsafe.Add(ref bBase, i);
-                r *= scale;
-                g *= scale;
-                b *= scale;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => RgbScalar.ConvertToRgbInplace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-        {
-            r.CopyTo(values.Component0);
-            g.CopyTo(values.Component1);
-            b.CopyTo(values.Component2);
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => RgbScalar.ConvertFromRgb(values, r, g, b);
-    }
-}

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

@@ -1,25 +1,23 @@
-// Copyright (c) Six Labors.
+// 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.Arm;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class RgbArm : JpegColorConverterArm
+    internal sealed class RgbVector128 : JpegColorConverterVector128
     {
-        public RgbArm(int precision)
+        public RgbVector128(int precision)
             : base(JpegColorSpace.RGB, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> rBase =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -29,16 +27,16 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
             // Used for the color conversion
-            var scale = Vector128.Create(1 / this.MaximumValue);
+            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 = AdvSimd.Multiply(r, scale);
-                g = AdvSimd.Multiply(g, scale);
-                b = AdvSimd.Multiply(b, scale);
+                r *= scale;
+                g *= scale;
+                b *= scale;
             }
         }
 

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

@@ -1,24 +1,23 @@
-// Copyright (c) Six Labors.
+// 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.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class RgbAvx : JpegColorConverterAvx
+    internal sealed class RgbVector256 : JpegColorConverterVector256
     {
-        public RgbAvx(int precision)
+        public RgbVector256(int precision)
             : base(JpegColorSpace.RGB, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> rBase =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -28,16 +27,16 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
             // Used for the color conversion
-            var scale = Vector256.Create(1 / this.MaximumValue);
+            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 = Avx.Multiply(r, scale);
-                g = Avx.Multiply(g, scale);
-                b = Avx.Multiply(b, scale);
+                r *= scale;
+                g *= scale;
+                b *= scale;
             }
         }
 

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

@@ -0,0 +1,59 @@
+// 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.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/>
+        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.YCbCrScalar.cs

@@ -19,14 +19,14 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgbInplace(values, this.MaximumValue, this.HalfValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, this.HalfValue, r, g, b);
+        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)
+        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue, float halfValue)
         {
             Span<float> c0 = values.Component0;
             Span<float> c1 = values.Component1;

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

@@ -1,126 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YCbCrVector : JpegColorConverterVector
-    {
-        public YCbCrVector(int precision)
-            : base(JpegColorSpace.YCbCr, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> c0Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> c1Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> c2Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            var chromaOffset = new Vector<float>(-this.HalfValue);
-
-            var scale = new Vector<float>(1 / this.MaximumValue);
-            var rCrMult = new Vector<float>(YCbCrScalar.RCrMult);
-            var gCbMult = new Vector<float>(-YCbCrScalar.GCbMult);
-            var gCrMult = new Vector<float>(-YCbCrScalar.GCrMult);
-            var bCbMult = new Vector<float>(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                Vector<float> y = Unsafe.Add(ref c0Base, i);
-                Vector<float> cb = Unsafe.Add(ref c1Base, i) + chromaOffset;
-                Vector<float> cr = Unsafe.Add(ref c2Base, i) + chromaOffset;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector<float> r = y + (cr * rCrMult);
-                Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
-                Vector<float> b = y + (cb * bCbMult);
-
-                r = r.FastRound();
-                g = g.FastRound();
-                b = b.FastRound();
-                r *= scale;
-                g *= scale;
-                b *= scale;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => YCbCrScalar.ConvertToRgbInplace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector<float> destY =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> destCb =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> destCr =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector<float> srcR =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector<float> srcG =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector<float> srcB =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            var chromaOffset = new Vector<float>(this.HalfValue);
-
-            var rYMult = new Vector<float>(0.299f);
-            var gYMult = new Vector<float>(0.587f);
-            var bYMult = new Vector<float>(0.114f);
-
-            var rCbMult = new Vector<float>(0.168736f);
-            var gCbMult = new Vector<float>(0.331264f);
-            var bCbMult = new Vector<float>(0.5f);
-
-            var rCrMult = new Vector<float>(0.5f);
-            var gCrMult = new Vector<float>(0.418688f);
-            var bCrMult = new Vector<float>(0.081312f);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> r = Unsafe.Add(ref srcR, i);
-                Vector<float> g = Unsafe.Add(ref srcG, i);
-                Vector<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)
-                Unsafe.Add(ref destY, i) = (rYMult * r) + (gYMult * g) + (bYMult * b);
-                Unsafe.Add(ref destCb, i) = chromaOffset - (rCbMult * r) - (gCbMult * g) + (bCbMult * b);
-                Unsafe.Add(ref destCr, i) = chromaOffset + (rCrMult * r) - (gCrMult * g) - (bCrMult * b);
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => YCbCrScalar.ConvertFromRgb(values, this.HalfValue, r, g, b);
-    }
-}

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

@@ -1,27 +1,24 @@
-// Copyright (c) Six Labors.
+// 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.Arm;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
+using Vector128_ = SixLabors.ImageSharp.Common.Helpers.Vector128Utilities;
 
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class YCbCrArm : JpegColorConverterArm
+    internal sealed class YCbCrVector128 : JpegColorConverterVector128
     {
-        public YCbCrArm(int precision)
+        public YCbCrVector128(int precision)
             : base(JpegColorSpace.YCbCr, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> c0Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -30,16 +27,15 @@ internal abstract partial class JpegColorConverterBase
             ref Vector128<float> c2Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
-            // Used for the color conversion
-            var chromaOffset = Vector128.Create(-this.HalfValue);
-            var scale = Vector128.Create(1 / this.MaximumValue);
-            var rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
+            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 = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
+            nuint n = values.Component0.Vector128Count<float>();
             for (nuint i = 0; i < n; i++)
             {
                 // y = yVals[i];
@@ -50,19 +46,19 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
 
                 Vector128<float> y = c0;
-                Vector128<float> cb = AdvSimd.Add(c1, chromaOffset);
-                Vector128<float> cr = AdvSimd.Add(c2, chromaOffset);
+                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 = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector128<float> g = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector128<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+                Vector128<float> r = Vector128_.MultiplyAdd(y, cr, rCrMult);
+                Vector128<float> g = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector128<float> b = Vector128_.MultiplyAdd(y, cb, bCbMult);
 
-                r = AdvSimd.Multiply(AdvSimd.RoundToNearest(r), scale);
-                g = AdvSimd.Multiply(AdvSimd.RoundToNearest(g), scale);
-                b = AdvSimd.Multiply(AdvSimd.RoundToNearest(b), scale);
+                r = Vector128_.RoundToNearestInteger(r) * scale;
+                g = Vector128_.RoundToNearestInteger(g) * scale;
+                b = Vector128_.RoundToNearestInteger(b) * scale;
 
                 c0 = r;
                 c1 = g;
@@ -87,19 +83,17 @@ internal abstract partial class JpegColorConverterBase
             ref Vector128<float> srcB =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            // Used for the color conversion
-            var chromaOffset = Vector128.Create(this.HalfValue);
-
-            var f0299 = Vector128.Create(0.299f);
-            var f0587 = Vector128.Create(0.587f);
-            var f0114 = Vector128.Create(0.114f);
-            var fn0168736 = Vector128.Create(-0.168736f);
-            var fn0331264 = Vector128.Create(-0.331264f);
-            var fn0418688 = Vector128.Create(-0.418688f);
-            var fn0081312F = Vector128.Create(-0.081312F);
-            var f05 = Vector128.Create(0.5f);
-
-            nuint n = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
+            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);
@@ -109,9 +103,9 @@ internal abstract partial class JpegColorConverterBase
                 // 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 = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector128<float> cb = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector128<float> cr = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+                Vector128<float> y = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
 
                 Unsafe.Add(ref destY, i) = y;
                 Unsafe.Add(ref destCb, i) = cb;

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

@@ -1,26 +1,24 @@
-// Copyright (c) Six Labors.
+// 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;
-using static SixLabors.ImageSharp.SimdUtils;
+using Vector256_ = SixLabors.ImageSharp.Common.Helpers.Vector256Utilities;
 
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class YCbCrAvx : JpegColorConverterAvx
+    internal sealed class YCbCrVector256 : JpegColorConverterVector256
     {
-        public YCbCrAvx(int precision)
+        public YCbCrVector256(int precision)
             : base(JpegColorSpace.YCbCr, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -29,13 +27,12 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> c2Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
-            // Used for the color conversion
-            var chromaOffset = Vector256.Create(-this.HalfValue);
-            var scale = Vector256.Create(1 / this.MaximumValue);
-            var rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
+            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>();
@@ -49,19 +46,19 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
 
                 Vector256<float> y = c0;
-                Vector256<float> cb = Avx.Add(c1, chromaOffset);
-                Vector256<float> cr = Avx.Add(c2, chromaOffset);
+                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 = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector256<float> g = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+                Vector256<float> r = Vector256_.MultiplyAdd(y, cr, rCrMult);
+                Vector256<float> g = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector256<float> b = Vector256_.MultiplyAdd(y, cb, bCbMult);
 
-                r = Avx.Multiply(Avx.RoundToNearestInteger(r), scale);
-                g = Avx.Multiply(Avx.RoundToNearestInteger(g), scale);
-                b = Avx.Multiply(Avx.RoundToNearestInteger(b), scale);
+                r = Vector256_.RoundToNearestInteger(r) * scale;
+                g = Vector256_.RoundToNearestInteger(g) * scale;
+                b = Vector256_.RoundToNearestInteger(b) * scale;
 
                 c0 = r;
                 c1 = g;
@@ -86,17 +83,15 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> srcB =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            // Used for the color conversion
-            var chromaOffset = Vector256.Create(this.HalfValue);
-
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
-            var fn0168736 = Vector256.Create(-0.168736f);
-            var fn0331264 = Vector256.Create(-0.331264f);
-            var fn0418688 = Vector256.Create(-0.418688f);
-            var fn0081312F = Vector256.Create(-0.081312F);
-            var f05 = Vector256.Create(0.5f);
+            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++)
@@ -108,9 +103,9 @@ internal abstract partial class JpegColorConverterBase
                 // 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 = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector256<float> cb = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector256<float> cr = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+                Vector256<float> y = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
 
                 Unsafe.Add(ref destY, i) = y;
                 Unsafe.Add(ref destCb, i) = cb;

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

@@ -0,0 +1,123 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using Vector512_ = SixLabors.ImageSharp.Common.Helpers.Vector512Utilities;
+
+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/>
+        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_.MultiplyAdd(y, cr, rCrMult);
+                Vector512<float> g = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector512<float> b = Vector512_.MultiplyAdd(y, cb, bCbMult);
+
+                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_.MultiplyAdd(Vector512_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                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.YccKArm64.cs

@@ -1,133 +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 System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKArm64 : JpegColorConverterArm64
-    {
-        public YccKArm64(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
-            var chromaOffset = Vector128.Create(-this.HalfValue);
-            var scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
-            var max = Vector128.Create(this.MaximumValue);
-            var rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
-
-            // Walking 8 elements at one step:
-            nuint n = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
-            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 = AdvSimd.Add(c1, chromaOffset);
-                Vector128<float> cr = AdvSimd.Add(c2, chromaOffset);
-                Vector128<float> scaledK = AdvSimd.Multiply(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 = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector128<float> g =
-                    HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector128<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
-
-                r = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(r));
-                g = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(g));
-                b = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(b));
-
-                r = AdvSimd.Multiply(r, scaledK);
-                g = AdvSimd.Multiply(g, scaledK);
-                b = AdvSimd.Multiply(b, scaledK);
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykArm64.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
-            var maxSampleValue = Vector128.Create(this.MaximumValue);
-
-            var chromaOffset = Vector128.Create(this.HalfValue);
-
-            var f0299 = Vector128.Create(0.299f);
-            var f0587 = Vector128.Create(0.587f);
-            var f0114 = Vector128.Create(0.114f);
-            var fn0168736 = Vector128.Create(-0.168736f);
-            var fn0331264 = Vector128.Create(-0.331264f);
-            var fn0418688 = Vector128.Create(-0.418688f);
-            var fn0081312F = Vector128.Create(-0.081312F);
-            var f05 = Vector128.Create(0.5f);
-
-            nuint n = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> r = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcR, i));
-                Vector128<float> g = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcG, i));
-                Vector128<float> b = AdvSimd.Subtract(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 = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector128<float> cb = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector128<float> cr = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(fn0081312F, b), fn0418688, g), f05, r));
-
-                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.YccKScalar.cs

@@ -19,14 +19,14 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgpInplace(values, this.MaximumValue, this.HalfValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgpInPlace(values, this.MaximumValue, this.HalfValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, this.HalfValue, this.MaximumValue, r, g, b);
+        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 ConvertToRgpInplace(in ComponentValues values, float maxValue, float halfValue)
+        public static void ConvertToRgpInPlace(in ComponentValues values, float maxValue, float halfValue)
         {
             Span<float> c0 = values.Component0;
             Span<float> c1 = values.Component1;

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

@@ -1,136 +0,0 @@
-// 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.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKVector : JpegColorConverterVector
-    {
-        public YccKVector(int precision)
-            : base(JpegColorSpace.Ycck, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> c0Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> c1Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> c2Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector<float> kBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            var chromaOffset = new Vector<float>(-this.HalfValue);
-            var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
-            var max = new Vector<float>(this.MaximumValue);
-            var rCrMult = new Vector<float>(YCbCrScalar.RCrMult);
-            var gCbMult = new Vector<float>(-YCbCrScalar.GCbMult);
-            var gCrMult = new Vector<float>(-YCbCrScalar.GCrMult);
-            var bCbMult = new Vector<float>(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                // k = kVals[i] / 256F;
-                ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
-
-                Vector<float> y = c0;
-                Vector<float> cb = c1 + chromaOffset;
-                Vector<float> cr = c2 + chromaOffset;
-                Vector<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);
-                Vector<float> r = y + (cr * rCrMult);
-                Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
-                Vector<float> b = y + (cb * bCbMult);
-
-                r = (max - r.FastRound()) * scaledK;
-                g = (max - g.FastRound()) * scaledK;
-                b = (max - b.FastRound()) * scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => YccKScalar.ConvertToRgpInplace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykVector.ConvertFromRgbInplaceVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
-
-            // cmyk -> ycck
-            ref Vector<float> destY =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> destCb =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> destCr =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector<float> srcR = ref destY;
-            ref Vector<float> srcG = ref destCb;
-            ref Vector<float> srcB = ref destCr;
-
-            var maxSampleValue = new Vector<float>(this.MaximumValue);
-
-            var chromaOffset = new Vector<float>(this.HalfValue);
-
-            var rYMult = new Vector<float>(0.299f);
-            var gYMult = new Vector<float>(0.587f);
-            var bYMult = new Vector<float>(0.114f);
-
-            var rCbMult = new Vector<float>(0.168736f);
-            var gCbMult = new Vector<float>(0.331264f);
-            var bCbMult = new Vector<float>(0.5f);
-
-            var rCrMult = new Vector<float>(0.5f);
-            var gCrMult = new Vector<float>(0.418688f);
-            var bCrMult = new Vector<float>(0.081312f);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
-                Vector<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
-                Vector<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)
-                Unsafe.Add(ref destY, i) = (rYMult * r) + (gYMult * g) + (bYMult * b);
-                Unsafe.Add(ref destCb, i) = chromaOffset - (rCbMult * r) - (gCbMult * g) + (bCbMult * b);
-                Unsafe.Add(ref destCr, i) = chromaOffset + (rCrMult * r) - (gCrMult * g) - (bCrMult * b);
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-        {
-            // rgb -> cmyk
-            CmykScalar.ConvertFromRgb(in values, this.MaximumValue, r, g, b);
-
-            // cmyk -> ycck
-            YccKScalar.ConvertFromRgb(in values, this.HalfValue, this.MaximumValue, r, g, b);
-        }
-    }
-}

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

@@ -0,0 +1,130 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using Vector128_ = SixLabors.ImageSharp.Common.Helpers.Vector128Utilities;
+
+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_.MultiplyAdd(y, cr, rCrMult);
+                Vector128<float> g = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector128<float> b = Vector128_.MultiplyAdd(y, cb, bCbMult);
+
+                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 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_.MultiplyAdd(Vector128_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                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.YccKAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector256.cs

@@ -1,25 +1,24 @@
-// Copyright (c) Six Labors.
+// 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;
-using static SixLabors.ImageSharp.SimdUtils;
+using Vector256_ = SixLabors.ImageSharp.Common.Helpers.Vector256Utilities;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class YccKAvx : JpegColorConverterAvx
+    internal sealed class YccKVector256 : JpegColorConverterVector256
     {
-        public YccKAvx(int precision)
+        public YccKVector256(int precision)
             : base(JpegColorSpace.Ycck, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -31,13 +30,13 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
 
             // Used for the color conversion
-            var chromaOffset = Vector256.Create(-this.HalfValue);
-            var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
-            var max = Vector256.Create(this.MaximumValue);
-            var rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
+            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>();
@@ -51,25 +50,24 @@ internal abstract partial class JpegColorConverterBase
                 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 = Avx.Add(c1, chromaOffset);
-                Vector256<float> cr = Avx.Add(c2, chromaOffset);
-                Vector256<float> scaledK = Avx.Multiply(Unsafe.Add(ref kBase, i), scale);
+                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 = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector256<float> g =
-                    HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+                Vector256<float> r = Vector256_.MultiplyAdd(y, cr, rCrMult);
+                Vector256<float> g = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector256<float> b = Vector256_.MultiplyAdd(y, cb, bCbMult);
 
-                r = Avx.Subtract(max, Avx.RoundToNearestInteger(r));
-                g = Avx.Subtract(max, Avx.RoundToNearestInteger(g));
-                b = Avx.Subtract(max, Avx.RoundToNearestInteger(b));
+                r = max - Vector256_.RoundToNearestInteger(r);
+                g = max - Vector256_.RoundToNearestInteger(g);
+                b = max - Vector256_.RoundToNearestInteger(b);
 
-                r = Avx.Multiply(r, scaledK);
-                g = Avx.Multiply(g, scaledK);
-                b = Avx.Multiply(b, scaledK);
+                r *= scaledK;
+                g *= scaledK;
+                b *= scaledK;
 
                 c0 = r;
                 c1 = g;
@@ -81,7 +79,7 @@ internal abstract partial class JpegColorConverterBase
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
             // rgb -> cmyk
-            CmykAvx.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+            CmykVector256.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
 
             // cmyk -> ycck
             ref Vector256<float> destY =
@@ -96,32 +94,32 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> srcB = ref destCr;
 
             // Used for the color conversion
-            var maxSampleValue = Vector256.Create(this.MaximumValue);
+            Vector256<float> maxSampleValue = Vector256.Create(this.MaximumValue);
 
-            var chromaOffset = Vector256.Create(this.HalfValue);
+            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue);
 
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
-            var fn0168736 = Vector256.Create(-0.168736f);
-            var fn0331264 = Vector256.Create(-0.331264f);
-            var fn0418688 = Vector256.Create(-0.418688f);
-            var fn0081312F = Vector256.Create(-0.081312F);
-            var f05 = Vector256.Create(0.5f);
+            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 = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcR, i));
-                Vector256<float> g = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcG, i));
-                Vector256<float> b = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcB, 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 = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector256<float> cb = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector256<float> cr = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+                Vector256<float> y = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
 
                 Unsafe.Add(ref destY, i) = y;
                 Unsafe.Add(ref destCb, i) = cb;

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

@@ -0,0 +1,144 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using Vector512_ = SixLabors.ImageSharp.Common.Helpers.Vector512Utilities;
+
+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_.MultiplyAdd(y, cr, rCrMult);
+                Vector512<float> g = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector512<float> b = Vector512_.MultiplyAdd(y, cb, bCbMult);
+
+                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/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+            => YccKScalar.ConvertToRgpInPlace(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_.MultiplyAdd(Vector512_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                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)
+        {
+            // rgb -> cmyk
+            CmykScalar.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+            // cmyk -> ycck
+            YccKScalar.ConvertFromRgb(in values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
+        }
+    }
+}

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

@@ -1,35 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Avx"/> 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 JpegColorConverterArm64 : JpegColorConverterBase
-    {
-        protected JpegColorConverterArm64(JpegColorSpace colorSpace, int precision)
-            : base(colorSpace, precision)
-        {
-        }
-
-        public static bool IsSupported => AdvSimd.Arm64.IsSupported;
-
-        public sealed override bool IsAvailable => IsSupported;
-
-        public sealed override int ElementsPerBatch => Vector128<float>.Count;
-    }
-}

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

@@ -71,25 +71,14 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     /// <exception cref="InvalidImageContentException">Invalid colorspace.</exception>
     public static JpegColorConverterBase GetConverter(JpegColorSpace colorSpace, int precision)
-    {
-        JpegColorConverterBase converter = Array.Find(
-            Converters,
-            c => c.ColorSpace == colorSpace
-            && c.Precision == precision);
-
-        if (converter is null)
-        {
-            throw new InvalidImageContentException($"Could not find any converter for JpegColorSpace {colorSpace}!");
-        }
-
-        return converter;
-    }
+        => Array.Find(Converters, c => c.ColorSpace == colorSpace && c.Precision == precision)
+        ?? throw new InvalidImageContentException($"Could not find any converter for JpegColorSpace {colorSpace}!");
 
     /// <summary>
-    /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space inplace.
+    /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space in-place.
     /// </summary>
-    /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
-    public abstract void ConvertToRgbInplace(in ComponentValues values);
+    /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
+    public abstract void ConvertToRgbInPlace(in ComponentValues values);
 
     /// <summary>
     /// Converts RGB lanes to jpeg component values.
@@ -101,31 +90,25 @@ internal abstract partial class JpegColorConverterBase
     public abstract void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
 
     /// <summary>
-    /// Returns the <see cref="JpegColorConverterBase"/>s for all supported colorspaces and precisions.
+    /// Returns the <see cref="JpegColorConverterBase"/>s for all supported color spaces and precisions.
     /// </summary>
     private static JpegColorConverterBase[] CreateConverters()
-    {
-        // 5 color types with 2 supported precisions: 8 bit & 12 bit
-        const int colorConvertersCount = 5 * 2;
-
-        JpegColorConverterBase[] converters = new JpegColorConverterBase[colorConvertersCount];
-
-        // 8-bit converters
-        converters[0] = GetYCbCrConverter(8);
-        converters[1] = GetYccKConverter(8);
-        converters[2] = GetCmykConverter(8);
-        converters[3] = GetGrayScaleConverter(8);
-        converters[4] = GetRgbConverter(8);
-
-        // 12-bit converters
-        converters[5] = GetYCbCrConverter(12);
-        converters[6] = GetYccKConverter(12);
-        converters[7] = GetCmykConverter(12);
-        converters[8] = GetGrayScaleConverter(12);
-        converters[9] = GetRgbConverter(12);
-
-        return converters;
-    }
+        => [
+
+            // 8-bit converters
+            GetYCbCrConverter(8),
+            GetYccKConverter(8),
+            GetCmykConverter(8),
+            GetGrayScaleConverter(8),
+            GetRgbConverter(8),
+
+            // 12-bit converters
+            GetYCbCrConverter(12),
+            GetYccKConverter(12),
+            GetCmykConverter(12),
+            GetGrayScaleConverter(12),
+            GetRgbConverter(12),
+        ];
 
     /// <summary>
     /// Returns the <see cref="JpegColorConverterBase"/>s for the YCbCr colorspace.
@@ -133,19 +116,19 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetYCbCrConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new YCbCrAvx(precision);
+            return new YCbCrVector512(precision);
         }
 
-        if (JpegColorConverterArm.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new YCbCrArm(precision);
+            return new YCbCrVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new YCbCrVector(precision);
+            return new YCbCrVector128(precision);
         }
 
         return new YCbCrScalar(precision);
@@ -157,19 +140,19 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetYccKConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new YccKAvx(precision);
+            return new YccKVector512(precision);
         }
 
-        if (JpegColorConverterArm64.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new YccKArm64(precision);
+            return new YccKVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new YccKVector(precision);
+            return new YccKVector128(precision);
         }
 
         return new YccKScalar(precision);
@@ -181,19 +164,19 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetCmykConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new CmykAvx(precision);
+            return new CmykVector512(precision);
         }
 
-        if (JpegColorConverterArm64.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new CmykArm64(precision);
+            return new CmykVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new CmykVector(precision);
+            return new CmykVector128(precision);
         }
 
         return new CmykScalar(precision);
@@ -205,22 +188,22 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetGrayScaleConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new GrayscaleAvx(precision);
+            return new GrayScaleVector512(precision);
         }
 
-        if (JpegColorConverterArm.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new GrayscaleArm(precision);
+            return new GrayScaleVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new GrayScaleVector(precision);
+            return new GrayScaleVector128(precision);
         }
 
-        return new GrayscaleScalar(precision);
+        return new GrayScaleScalar(precision);
     }
 
     /// <summary>
@@ -229,19 +212,19 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetRgbConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new RgbAvx(precision);
+            return new RgbVector512(precision);
         }
 
-        if (JpegColorConverterArm.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new RgbArm(precision);
+            return new RgbVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new RgbVector(precision);
+            return new RgbVector128(precision);
         }
 
         return new RgbScalar(precision);
@@ -295,7 +278,7 @@ internal abstract partial class JpegColorConverterBase
             // In case of grayscale, Component1 and Component2 point to Component0 memory area
             this.Component1 = this.ComponentCount > 1 ? componentBuffers[1].DangerousGetRowSpan(row) : this.Component0;
             this.Component2 = this.ComponentCount > 2 ? componentBuffers[2].DangerousGetRowSpan(row) : this.Component0;
-            this.Component3 = this.ComponentCount > 3 ? componentBuffers[3].DangerousGetRowSpan(row) : Span<float>.Empty;
+            this.Component3 = this.ComponentCount > 3 ? componentBuffers[3].DangerousGetRowSpan(row) : [];
         }
 
         /// <summary>
@@ -314,7 +297,7 @@ internal abstract partial class JpegColorConverterBase
             // In case of grayscale, Component1 and Component2 point to Component0 memory area
             this.Component1 = this.ComponentCount > 1 ? processors[1].GetColorBufferRowSpan(row) : this.Component0;
             this.Component2 = this.ComponentCount > 2 ? processors[2].GetColorBufferRowSpan(row) : this.Component0;
-            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : Span<float>.Empty;
+            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : [];
         }
 
         /// <summary>
@@ -333,7 +316,7 @@ internal abstract partial class JpegColorConverterBase
             // In case of grayscale, Component1 and Component2 point to Component0 memory area
             this.Component1 = this.ComponentCount > 1 ? processors[1].GetColorBufferRowSpan(row) : this.Component0;
             this.Component2 = this.ComponentCount > 2 ? processors[2].GetColorBufferRowSpan(row) : this.Component0;
-            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : Span<float>.Empty;
+            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : [];
         }
 
         internal ComponentValues(
@@ -353,9 +336,9 @@ internal abstract partial class JpegColorConverterBase
         public ComponentValues Slice(int start, int length)
         {
             Span<float> c0 = this.Component0.Slice(start, length);
-            Span<float> c1 = this.Component1.Length > 0 ? this.Component1.Slice(start, length) : Span<float>.Empty;
-            Span<float> c2 = this.Component2.Length > 0 ? this.Component2.Slice(start, length) : Span<float>.Empty;
-            Span<float> c3 = this.Component3.Length > 0 ? this.Component3.Slice(start, length) : Span<float>.Empty;
+            Span<float> c1 = this.Component1.Length > 0 ? this.Component1.Slice(start, length) : [];
+            Span<float> c2 = this.Component2.Length > 0 ? this.Component2.Slice(start, length) : [];
+            Span<float> c3 = this.Component3.Length > 0 ? this.Component3.Slice(start, length) : [];
 
             return new ComponentValues(this.ComponentCount, c0, c1, c2, c3);
         }

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

@@ -36,7 +36,7 @@ internal abstract partial class JpegColorConverterBase
         public override int ElementsPerBatch => Vector<float>.Count;
 
         /// <inheritdoc/>
-        public sealed override void ConvertToRgbInplace(in ComponentValues values)
+        public sealed override void ConvertToRgbInPlace(in ComponentValues values)
         {
             DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
 
@@ -46,7 +46,7 @@ internal abstract partial class JpegColorConverterBase
             int simdCount = length - remainder;
             if (simdCount > 0)
             {
-                this.ConvertToRgbInplaceVectorized(values.Slice(0, simdCount));
+                this.ConvertToRgbInPlaceVectorized(values.Slice(0, simdCount));
             }
 
             // Jpeg images width is always divisible by 8 without a remainder
@@ -56,12 +56,12 @@ internal abstract partial class JpegColorConverterBase
             // remainder pixels
             if (remainder > 0)
             {
-                this.ConvertToRgbInplaceScalarRemainder(values.Slice(simdCount, remainder));
+                this.ConvertToRgbInPlaceScalarRemainder(values.Slice(simdCount, remainder));
             }
         }
 
         /// <inheritdoc/>
-        public sealed override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+        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.");
 
@@ -73,9 +73,9 @@ internal abstract partial class JpegColorConverterBase
             {
                 this.ConvertFromRgbVectorized(
                     values.Slice(0, simdCount),
-                    r.Slice(0, simdCount),
-                    g.Slice(0, simdCount),
-                    b.Slice(0, simdCount));
+                    rLane[..simdCount],
+                    gLane[..simdCount],
+                    bLane[..simdCount]);
             }
 
             // Jpeg images width is always divisible by 8 without a remainder
@@ -87,25 +87,25 @@ internal abstract partial class JpegColorConverterBase
             {
                 this.ConvertFromRgbScalarRemainder(
                     values.Slice(simdCount, remainder),
-                    r.Slice(simdCount, remainder),
-                    g.Slice(simdCount, remainder),
-                    b.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 inplace using <see cref="Vector"/> API.
+        /// to RGB color space in place using <see cref="Vector"/> API.
         /// </summary>
-        /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInplaceVectorized(in ComponentValues values);
+        /// <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)"/>.
+        /// conversion in <see cref="ConvertToRgbInPlaceVectorized(in ComponentValues)"/>.
         /// </summary>
-        /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInplaceScalarRemainder(in ComponentValues values);
+        /// <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.

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

@@ -1,8 +1,7 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
+
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
@@ -10,7 +9,7 @@ internal abstract partial class JpegColorConverterBase
 {
     /// <summary>
     /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Avx"/> instructions.
+    /// based on <see cref="Vector128{T}"/> instructions.
     /// </summary>
     /// <remarks>
     /// Converters of this family would expect input buffers lengths to be
@@ -19,14 +18,14 @@ internal abstract partial class JpegColorConverterBase
     /// 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 JpegColorConverterArm : JpegColorConverterBase
+    internal abstract class JpegColorConverterVector128 : JpegColorConverterBase
     {
-        protected JpegColorConverterArm(JpegColorSpace colorSpace, int precision)
+        protected JpegColorConverterVector128(JpegColorSpace colorSpace, int precision)
             : base(colorSpace, precision)
         {
         }
 
-        public static bool IsSupported => AdvSimd.IsSupported;
+        public static bool IsSupported => Vector128.IsHardwareAccelerated;
 
         public sealed override bool IsAvailable => IsSupported;
 

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

@@ -1,7 +1,7 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
+
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
@@ -9,7 +9,7 @@ internal abstract partial class JpegColorConverterBase
 {
     /// <summary>
     /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Avx"/> instructions.
+    /// based on <see cref="Vector256{T}"/> instructions.
     /// </summary>
     /// <remarks>
     /// Converters of this family would expect input buffers lengths to be
@@ -18,14 +18,14 @@ internal abstract partial class JpegColorConverterBase
     /// 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 JpegColorConverterAvx : JpegColorConverterBase
+    internal abstract class JpegColorConverterVector256 : JpegColorConverterBase
     {
-        protected JpegColorConverterAvx(JpegColorSpace colorSpace, int precision)
+        protected JpegColorConverterVector256(JpegColorSpace colorSpace, int precision)
             : base(colorSpace, precision)
         {
         }
 
-        public static bool IsSupported => Avx.IsSupported;
+        public static bool IsSupported => Vector256.IsHardwareAccelerated;
 
         public sealed override bool IsAvailable => IsSupported;
 

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

@@ -0,0 +1,111 @@
+// 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/Decoder/SpectralConverter{TPixel}.cs

@@ -141,7 +141,7 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
 
             JpegColorConverterBase.ComponentValues values = new(this.componentProcessors, y);
 
-            this.colorConverter.ConvertToRgbInplace(values);
+            this.colorConverter.ConvertToRgbInPlace(values);
             values = values.Slice(0, width); // slice away Jpeg padding
 
             Span<byte> r = this.rgbBuffer.Slice(0, width);

src/ImageSharp/Formats/SpecializedImageDecoder{T}.cs

@@ -24,6 +24,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             s => this.Decode<TPixel>(options, s, default));
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }
 
@@ -36,6 +37,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             s => this.Decode(options, s, default));
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }
 
@@ -50,6 +52,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }
 
@@ -63,6 +66,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }