Support for JPEG XL (JXL) images

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -1033,4 +1033,13 @@ public static nuint Vector512Count<TVector>(this ReadOnlySpan<float> span)
     public static nuint Vector512Count<TVector>(int length)
         where TVector : struct
         => (uint)length / (uint)Vector512<TVector>.Count;
+
+    /// <summary>
+    /// Computes the average of two integers.
+    /// </summary>
+    /// <param name="x">First integer</param>
+    /// <param name="y">Second integer</param>
+    /// <returns>The average of x, y.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Average(int x, int y) => (x + y + ((x > y) ? 1 : 0)) >> 1;
 }

src/ImageSharp/Common/Helpers/Vector128Utilities.cs

@@ -859,4 +859,44 @@ public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte>
         Vector128<sbyte> unpacked = Vector128.Create(left.GetLower(), right.GetLower());
         return Vector128.ShuffleNative(unpacked, Vector128.Create(0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15));
     }
+
+    /// <summary>
+    /// Interleaves the lower half of the vector.
+    /// </summary>
+    /// <param name="a">First vector</param>
+    /// <param name="b">Second vector</param>
+    /// <returns>
+    ///   <c>{ a[0], b[0], a[1], b[1] }</c>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<int> InterleaveLower(Vector128<int> a, Vector128<int> b)
+    {
+        Vector128<int> shuffledA = Vector128.Shuffle(a, Vector128.Create(0, 0, 1, 1));
+        Vector128<int> shuffledB = Vector128.Shuffle(b, Vector128.Create(0, 0, 1, 1));
+
+        Vector128<int> maskA = Vector128.Create(-1, 0, -1, 0);
+        Vector128<int> maskB = Vector128.Create(0, -1, 0, -1);
+
+        return (shuffledA & maskA) | (shuffledB & maskB);
+    }
+
+    /// <summary>
+    /// Interleaves the upper half of the vector.
+    /// </summary>
+    /// <param name="a">First vector</param>
+    /// <param name="b">Second vector</param>
+    /// <returns>
+    ///   <c>{ a[2], b[2], a[3], b[3] }</c>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<int> InterleaveUpper(Vector128<int> a, Vector128<int> b)
+    {
+        Vector128<int> shuffledA = Vector128.Shuffle(a, Vector128.Create(2, 2, 3, 3));
+        Vector128<int> shuffledB = Vector128.Shuffle(b, Vector128.Create(2, 2, 3, 3));
+
+        Vector128<int> maskA = Vector128.Create(-1, 0, -1, 0);
+        Vector128<int> maskB = Vector128.Create(0, -1, 0, -1);
+
+        return (shuffledA & maskA) | (shuffledB & maskB);
+    }
 }

src/ImageSharp/Common/Helpers/Vector256Utilities.cs

@@ -397,4 +397,170 @@ public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> ri
 
         return Vector256.Create(lo, hi);
     }
+
+    /// <summary>
+    /// Multiplies only the even indices of the two 256-bit vectors,
+    /// producing half as many elements of twice the element width.
+    /// </summary>
+    /// <param name="left">Left vector to multiply.</param>
+    /// <param name="right">Right vector to multiply</param>
+    /// <returns>
+    ///   <code>
+    ///     {
+    ///       A[0] * B[0],
+    ///       A[2] * B[2],
+    ///       A[4] * B[4],
+    ///       A[6] * B[6]
+    ///     }
+    ///   </code>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<long> MultiplyEven(Vector256<int> left, Vector256<int> right)
+        => Vector256.Create(
+            left[0] * right[0],
+            left[2] * right[2],
+            left[4] * right[4],
+            left[6] * right[6]);
+
+    /// <summary>
+    /// Multiplies only the odd indices of the two 256-bit vectors,
+    /// producing half as many elements of twice the element width.
+    /// </summary>
+    /// <param name="left">Left vector to multiply.</param>
+    /// <param name="right">Right vector to multiply</param>
+    /// <returns>
+    ///   <code>
+    ///     {
+    ///       A[1] * B[1],
+    ///       A[3] * B[3],
+    ///       A[5] * B[5],
+    ///       A[7] * B[7]
+    ///     }
+    ///   </code>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<long> MultiplyOdd(Vector256<int> left, Vector256<int> right)
+        => Vector256.Create(
+            left[1] * right[1],
+            left[3] * right[3],
+            left[5] * right[5],
+            left[7] * right[7]);
+
+    /// <summary>
+    /// Produces a vector by interleaving the even-indexed elements
+    /// of the left and right vectors.
+    /// </summary>
+    /// <param name="left">Left vector to interleave.</param>
+    /// <param name="right">Right vector to interleave.</param>
+    /// <returns>
+    ///  <code>
+    ///    {
+    ///      A[0], B[0],
+    ///      A[2], B[2],
+    ///      A[4], B[4],
+    ///      A[6], B[6]
+    ///    }
+    ///  </code>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<int> InterleaveEven(
+        Vector256<int> left,
+        Vector256<int> right)
+        => Vector256.Create(
+            left[0],
+            right[0],
+            left[2],
+            right[2],
+            left[4],
+            right[4],
+            left[6],
+            right[6]);
+
+    /// <summary>
+    /// Produces a vector by interleaving the odd-indexed elements
+    /// of the left and right vectors.
+    /// </summary>
+    /// <param name="left">Left vector to interleave.</param>
+    /// <param name="right">Right vector to interleave.</param>
+    /// <returns>
+    ///  <code>
+    ///    {
+    ///      A[1], B[1],
+    ///      A[3], B[3],
+    ///      A[5], B[5],
+    ///      A[7], B[7]
+    ///    }
+    ///  </code>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<int> InterleaveOdd(
+        Vector256<int> left,
+        Vector256<int> right)
+        => Vector256.Create(
+            left[1],
+            right[1],
+            left[3],
+            right[3],
+            left[5],
+            right[5],
+            left[7],
+            right[7]);
+
+    /// <summary>
+    /// Produces a vector with masks where 0xFFFFFFFF specifies
+    /// that the left value does not equal to the right value and
+    /// 0x00000000 specifies that the value equals to the
+    /// right value.
+    /// </summary>
+    /// <param name="left">Left vector to compare for inequality.</param>
+    /// <param name="right">Right vector to compare for inequality.</param>
+    /// <returns>
+    /// 0xFFFFFFFF for values that aren't equal, 0x00000000 for
+    /// values that are equal. This is essentially the inverse of
+    /// <see cref="Vector256.Equals{T}(Vector256{T}, Vector256{T})"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<int> NotEqual(
+        Vector256<int> left,
+        Vector256<int> right) => ~Vector256.Equals(left, right);
+
+    /// <summary>
+    /// Interleaves the lower half of the vector.
+    /// </summary>
+    /// <param name="a">First vector</param>
+    /// <param name="b">Second vector</param>
+    /// <returns>
+    ///   <c>{ a[0], b[0], a[1], b[1], a[2], b[2], a[3], b[3] }</c>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<int> InterleaveLower(Vector256<int> a, Vector256<int> b)
+    {
+        Vector256<int> shuffledA = Vector256.Shuffle(a, Vector256.Create(0, 0, 1, 1, 2, 2, 3, 3));
+        Vector256<int> shuffledB = Vector256.Shuffle(b, Vector256.Create(0, 0, 1, 1, 2, 2, 3, 3));
+
+        Vector256<int> maskA = Vector256.Create(-1, 0, -1, 0, -1, 0, -1, 0);
+        Vector256<int> maskB = Vector256.Create(0, -1, 0, -1, 0, -1, 0, -1);
+
+        return (shuffledA & maskA) | (shuffledB & maskB);
+    }
+
+    /// <summary>
+    /// Interleaves the upper half of the vector.
+    /// </summary>
+    /// <param name="a">First vector</param>
+    /// <param name="b">Second vector</param>
+    /// <returns>
+    ///   <c>{ a[4], b[4], a[5], b[5], a[6], b[6], a[7], b[7] }</c>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<int> InterleaveUpper(Vector256<int> a, Vector256<int> b)
+    {
+        Vector256<int> shuffledA = Vector256.Shuffle(a, Vector256.Create(4, 4, 5, 5, 6, 6, 7, 7));
+        Vector256<int> shuffledB = Vector256.Shuffle(b, Vector256.Create(4, 4, 5, 5, 6, 6, 7, 7));
+
+        Vector256<int> maskA = Vector256.Create(-1, 0, -1, 0, -1, 0, -1, 0);
+        Vector256<int> maskB = Vector256.Create(0, -1, 0, -1, 0, -1, 0, -1);
+
+        return (shuffledA & maskA) | (shuffledB & maskB);
+    }
 }

src/ImageSharp/Common/InlineArray.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // <auto-generated />
@@ -71,6 +71,24 @@ internal struct InlineArray26<T>
     private T t;
 }
 
+/// <summary>
+/// Represents a safe, fixed sized buffer of 32 elements.
+/// </summary>
+[InlineArray(32)]
+internal struct InlineArray32<T>
+{
+    private T t;
+}
+
+/// <summary>
+/// Represents a safe, fixed sized buffer of 33 elements.
+/// </summary>
+[InlineArray(33)]
+internal struct InlineArray33<T>
+{
+    private T t;
+}
+
 /// <summary>
 /// Represents a safe, fixed sized buffer of 36 elements.
 /// </summary>
@@ -88,3 +106,5 @@ internal struct InlineArray256<T>
 {
     private T t;
 }
+
+

src/ImageSharp/Common/InlineArray.tt

@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp;
 <#GenerateInlineArrays();#>
 
 <#+
-private static int[] Lengths = [4, 8, 14, 16, 18, 19, 26, 36, 256];
+private static int[] Lengths = [4, 8, 14, 16, 18, 19, 26, 32, 33, 36, 256];
 
 void GenerateInlineArrays()
 {

src/ImageSharp/Formats/Jxl/Cms/JxlCieXyPrimaries.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+/// <summary>
+/// RGB primaries for CIEXY
+/// </summary>
+internal struct JxlCieXyPrimaries
+{
+    /// <summary>
+    /// Gets or sets the R component
+    /// </summary>
+    public CieXyChromaticityCoordinates R { get; set; }
+
+    /// <summary>
+    /// Gets or sets the G component
+    /// </summary>
+    public CieXyChromaticityCoordinates G { get; set; }
+
+    /// <summary>
+    /// Gets or sets the B component
+    /// </summary>
+    public CieXyChromaticityCoordinates B { get; set; }
+}

src/ImageSharp/Formats/Jxl/Cms/JxlColorEncoding.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+internal sealed class JxlColorEncoding
+{
+    public JxlWhitePoint WhitePoint { get; set; } = JxlWhitePoint.D65;
+
+    public JxlPrimaries Primaries { get; set; } = JxlPrimaries.SRgb;
+
+    public JxlRenderingIntent RenderingIntent { get; set; } = JxlRenderingIntent.Relative;
+
+    public bool HaveFields { get; set; } = true;
+
+    public JxlIccBytes? Icc { get; set; }
+
+    public JxlColorSpace ColorSpace { get; set; } = JxlColorSpace.Rgb;
+
+    public bool Cmyk { get; set; }
+
+    public JxlCustomTransferFunction TransferFunction { get; set; }
+
+    public JxlCustomXy White { get; set; }
+
+    public JxlCustomXy Red { get; set; }
+
+    public JxlCustomXy Green { get; set; }
+
+    public JxlCustomXy Blue { get; set; }
+
+    public bool HasPrimaries => this.ColorSpace is not (JxlColorSpace.Gray or JxlColorSpace.Xyb);
+
+    public int Channels => (this.ColorSpace == JxlColorSpace.Gray) ? 1 : 3;
+
+    public bool TryGetPrimaries(out JxlCieXyPrimaries xy)
+    {
+        xy = default;
+
+        if (!this.HasPrimaries || !this.HasPrimaries)
+        {
+            return false;
+        }
+
+        switch (this.Primaries)
+        {
+            case JxlPrimaries.Custom:
+                xy.R = this.Red.GetValue();
+                xy.G = this.Green.GetValue();
+                xy.B = this.Blue.GetValue();
+                break;
+
+            case JxlPrimaries.SRgb:
+                xy.R = new(0.639998686f, 0.330010138f);
+                xy.G = new(0.300003784f, 0.600003357f);
+                xy.B = new(0.150002046f, 0.059997204f);
+                break;
+
+            case JxlPrimaries.Bt2020:
+                xy.R = new(0.708f, 0.292f);
+                xy.G = new(0.170f, 0.797f);
+                xy.B = new(0.131f, 0.046f);
+                break;
+
+            case JxlPrimaries.P3:
+                xy.R = new(0.680f, 0.320f);
+                xy.G = new(0.265f, 0.690f);
+                xy.B = new(0.150f, 0.060f);
+                break;
+
+            default:
+                throw new InvalidOperationException("Invalid primaries: " + this.Primaries);
+        }
+
+        return true;
+    }
+}