diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.cs b/src/ImageSharp/Common/Helpers/SimdUtils.cs
index 2b8f58b086..7e78581c33 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.cs
@@ -1,9 +1,10 @@
-// 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;
@@ -71,6 +72,107 @@ internal static partial class SimdUtils
         return val_2p23_f32 | sign;
     }
 
+    /// <summary>
+    /// Estimates the reciprocal of this vector.
+    /// </summary>
+    /// <param name="v">The vector to get reciprocal estimate of.</param>
+    /// <returns>An estimated reciprocal of each element in the vector.</returns>
+    internal static Vector<float> ReciprocalEstimate(this Vector<float> v)
+    {
+        // TODO: System.Runtime.Intrinsics.Arm has Sve and Sve2
+        // support but is for evaluation purposes only; add SVE/SVE2
+        // support when possible
+        if (Avx512F.IsSupported && Vector<float>.Count == 16)
+        {
+            // x86
+            return Avx512F.Reciprocal14(v.AsVector512()).AsVector();
+        }
+        else if (Avx.IsSupported && Vector<float>.Count == 8)
+        {
+            // x86
+            return Avx.Reciprocal(v.AsVector256()).AsVector();
+        }
+        else if (AdvSimd.IsSupported && Vector<float>.Count == 4)
+        {
+            // ARM
+            return AdvSimd.ReciprocalEstimate(v.AsVector128()).AsVector();
+        }
+        else if (Sse.IsSupported && Vector<float>.Count == 4)
+        {
+            // x86
+            return Sse.Reciprocal(v.AsVector128()).AsVector();
+        }
+        else
+        {
+            // Exact reciprocal fallback (slower)
+            return Vector<float>.One / v;
+        }
+    }
+
+    /// <summary>
+    /// Finds the leading zero count on each item of the vector.
+    /// </summary>
+    /// <param name="vector">The vector to compute leading zero count for.</param>
+    /// <returns>Input vector with leading zero count on each element.</returns>
+    internal static Vector<int> Lzcnt(Vector<int> vector)
+    {
+        if (Avx512CD.IsSupported && Vector<int>.Count == 16)
+        {
+            Vector512<int> v512 = vector.AsVector512();
+            Vector512<int> lzcnt = Avx512CD.LeadingZeroCount(v512);
+            return lzcnt.AsVector();
+        }
+        else if (AdvSimd.IsSupported && Vector<int>.Count == 4)
+        {
+            Vector128<int> v128 = vector.AsVector128();
+            Vector128<int> lzcnt = AdvSimd.LeadingZeroCount(v128);
+            return lzcnt.AsVector();
+        }
+        else
+        {
+            Span<int> data = stackalloc int[Vector<int>.Count];
+            ref int dataPtr = ref MemoryMarshal.GetReference(data);
+            vector.StoreUnsafe(ref dataPtr);
+
+            for (int i = 0; i < data.Length; i++)
+            {
+                Unsafe.Add(ref dataPtr, i) = BitOperations.LeadingZeroCount((nuint)Unsafe.Add(ref dataPtr, i));
+            }
+
+            return Vector.LoadUnsafe(ref dataPtr);
+        }
+    }
+
+    /// <summary>
+    /// Raises 2 to the power of each item in the vector.
+    /// </summary>
+    /// <param name="vector">Input vector.</param>
+    /// <returns>2^x for each item in the vector.</returns>
+    internal static Vector<int> Pow2(Vector<int> vector)
+    {
+        if (Avx512F.IsSupported && Vector<int>.Count == 16)
+        {
+            return Avx512F.ShiftLeftLogicalVariable(Vector512<int>.One, vector.AsVector512().AsUInt32()).AsVector();
+        }
+        else if (Avx2.IsSupported && Vector<int>.Count == 8)
+        {
+            return Avx2.ShiftLeftLogicalVariable(Vector256<int>.One, vector.AsVector256().AsUInt32()).AsVector();
+        }
+        else
+        {
+            Span<int> data = stackalloc int[Vector<int>.Count];
+            ref int dataPtr = ref MemoryMarshal.GetReference(data);
+            vector.StoreUnsafe(ref dataPtr);
+
+            for (int i = 0; i < data.Length; i++)
+            {
+                Unsafe.Add(ref dataPtr, i) = 1 << Unsafe.Add(ref dataPtr, i);
+            }
+
+            return Vector.LoadUnsafe(ref dataPtr);
+        }
+    }
+
     [Conditional("DEBUG")]
     private static void DebugVerifySpanInput(ReadOnlySpan<byte> source, ReadOnlySpan<float> dest, int shouldBeDivisibleBy)
     {
diff --git a/src/ImageSharp/Common/Helpers/Vector128Utilities.cs b/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
index 6bb1f59ef8..0e9a40dd1b 100644
--- a/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
+++ b/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
@@ -859,4 +859,84 @@ internal static class Vector128_
         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);
+    }
+
+    /// <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<float> InterleaveLower(Vector128<float> a, Vector128<float> b)
+    {
+        Vector128<float> shuffledA = Vector128.Shuffle(a, Vector128.Create(0, 0, 1, 1));
+        Vector128<float> shuffledB = Vector128.Shuffle(b, Vector128.Create(0, 0, 1, 1));
+
+        Vector128<float> maskA = Vector128.Create(-1, 0, -1, 0).AsSingle();
+        Vector128<float> maskB = Vector128.Create(0, -1, 0, -1).AsSingle();
+
+        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<float> InterleaveUpper(Vector128<float> a, Vector128<float> b)
+    {
+        Vector128<float> shuffledA = Vector128.Shuffle(a, Vector128.Create(2, 2, 3, 3));
+        Vector128<float> shuffledB = Vector128.Shuffle(b, Vector128.Create(2, 2, 3, 3));
+
+        Vector128<float> maskA = Vector128.Create(-1, 0, -1, 0).AsSingle();
+        Vector128<float> maskB = Vector128.Create(0, -1, 0, -1).AsSingle();
+
+        return (shuffledA & maskA) | (shuffledB & maskB);
+    }
 }
diff --git a/src/ImageSharp/Common/Helpers/Vector256Utilities.cs b/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
index 1dd7122713..bb11108869 100644
--- a/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
+++ b/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
@@ -397,4 +397,210 @@ internal static class Vector256_
 
         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);
+    }
+
+    /// <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<float> InterleaveLower(Vector256<float> a, Vector256<float> b)
+    {
+        Vector256<float> shuffledA = Vector256.Shuffle(a, Vector256.Create(0, 0, 1, 1, 2, 2, 3, 3));
+        Vector256<float> shuffledB = Vector256.Shuffle(b, Vector256.Create(0, 0, 1, 1, 2, 2, 3, 3));
+
+        Vector256<float> maskA = Vector256.Create(-1, 0, -1, 0, -1, 0, -1, 0).AsSingle();
+        Vector256<float> maskB = Vector256.Create(0, -1, 0, -1, 0, -1, 0, -1).AsSingle();
+
+        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<float> InterleaveUpper(Vector256<float> a, Vector256<float> b)
+    {
+        Vector256<float> shuffledA = Vector256.Shuffle(a, Vector256.Create(4, 4, 5, 5, 6, 6, 7, 7));
+        Vector256<float> shuffledB = Vector256.Shuffle(b, Vector256.Create(4, 4, 5, 5, 6, 6, 7, 7));
+
+        Vector256<float> maskA = Vector256.Create(-1, 0, -1, 0, -1, 0, -1, 0).AsSingle();
+        Vector256<float> maskB = Vector256.Create(0, -1, 0, -1, 0, -1, 0, -1).AsSingle();
+
+        return (shuffledA & maskA) | (shuffledB & maskB);
+    }
 }
diff --git a/src/ImageSharp/Common/InlineArray.cs b/src/ImageSharp/Common/InlineArray.cs
index 700551a8f3..a72e3f5394 100644
--- a/src/ImageSharp/Common/InlineArray.cs
+++ b/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 />
@@ -44,6 +44,15 @@ internal struct InlineArray16<T>
     private T t;
 }
 
+/// <summary>
+/// Represents a safe, fixed sized buffer of 17 elements.
+/// </summary>
+[InlineArray(17)]
+internal struct InlineArray17<T>
+{
+    private T t;
+}
+
 /// <summary>
 /// Represents a safe, fixed sized buffer of 18 elements.
 /// </summary>
@@ -71,6 +80,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 +115,5 @@ internal struct InlineArray256<T>
 {
     private T t;
 }
+
+
diff --git a/src/ImageSharp/Common/InlineArray.tt b/src/ImageSharp/Common/InlineArray.tt
index d689b0469a..d15650592a 100644
--- a/src/ImageSharp/Common/InlineArray.tt
+++ b/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, 17, 18, 19, 26, 32, 33, 36, 256];
 
 void GenerateInlineArrays()
 {
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlCieXyPrimaries.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlCieXyPrimaries.cs
new file mode 100644
index 0000000000..7e5a4367e1
--- /dev/null
+++ b/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; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlColorEncoding.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlColorEncoding.cs
new file mode 100644
index 0000000000..9a87dccc2d
--- /dev/null
+++ b/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;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlColorSpace.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlColorSpace.cs
new file mode 100644
index 0000000000..b65cbbef98
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlColorSpace.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+/// <summary>
+/// Supported, JPEG XL-specific color space types.
+/// </summary>
+internal enum JxlColorSpace : byte
+{
+    /// <summary>
+    /// Trichromatic color data. This also includes CMYK if Black
+    /// ExtraChannelInfo is present.
+    /// </summary>
+    Rgb,
+
+    /// <summary>
+    /// Single-channel data.
+    /// </summary>
+    Gray,
+
+    /// <summary>
+    /// Like Rgb but fixed values for primaries.
+    /// </summary>
+    Xyb,
+
+    /// <summary>
+    /// Unknown color space
+    /// </summary>
+    Unknown
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlCustomTransferFunction.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlCustomTransferFunction.cs
new file mode 100644
index 0000000000..acf049d4a7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlCustomTransferFunction.cs
@@ -0,0 +1,109 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+internal struct JxlCustomTransferFunction
+{
+    private const uint MaxGamma = 8192;
+    private const uint GammaMultiplier = 10000000;
+
+    public JxlCustomTransferFunction()
+    {
+    }
+
+    public bool HaveGamma { get; set; }
+
+    public uint Gamma { get; set; }
+
+    public JxlTransferFunction TransferFunction { get; set; } = JxlTransferFunction.SRgb;
+
+    public readonly bool IsUnknown => !this.HaveGamma && this.TransferFunction == JxlTransferFunction.Unknown;
+
+    public readonly bool IsSrgb => !this.HaveGamma && this.TransferFunction == JxlTransferFunction.SRgb;
+
+    public readonly bool IsLinear => !this.HaveGamma && this.TransferFunction == JxlTransferFunction.Linear;
+
+    public readonly bool IsPq => !this.HaveGamma && this.TransferFunction == JxlTransferFunction.Pq;
+
+    public readonly bool IsHlg => !this.HaveGamma && this.TransferFunction == JxlTransferFunction.Hlg;
+
+    public readonly bool Is709 => !this.HaveGamma && this.TransferFunction == JxlTransferFunction.Bt709;
+
+    public readonly bool IsDci => !this.HaveGamma && this.TransferFunction == JxlTransferFunction.Dci;
+
+    public readonly JxlTransferFunction GetTransferFunction()
+    {
+        if (this.HaveGamma)
+        {
+            return JxlTransferFunction.Unknown;
+        }
+
+        return this.TransferFunction;
+    }
+
+    public void SetTransferFunction(JxlTransferFunction tf)
+    {
+        this.HaveGamma = false;
+        this.TransferFunction = tf;
+    }
+
+    public readonly float GetGamma()
+    {
+        if (!this.HaveGamma)
+        {
+            return 0.0f;
+        }
+
+        return this.Gamma * (1.0f / GammaMultiplier);
+    }
+
+    public void SetGamma(float newGamma)
+    {
+        if (newGamma is < 1.0f / MaxGamma or > 1.0f)
+        {
+            throw new InvalidOperationException($"Invalid gamma {newGamma}");
+        }
+
+        this.HaveGamma = false;
+
+        if (IsAlmostEqual(newGamma, 1.0f))
+        {
+            this.TransferFunction = JxlTransferFunction.Linear;
+            return;
+        }
+
+        if (IsAlmostEqual(newGamma, 1.0f / 2.6f))
+        {
+            this.TransferFunction = JxlTransferFunction.Dci;
+            return;
+        }
+
+        // Don't translate 0.45.. to kSRGB nor k709 - that might change pixel
+        // values because those curves also have a linear part.
+        this.HaveGamma = true;
+        this.Gamma = (uint)MathF.Round((float)(newGamma * GammaMultiplier));
+        this.TransferFunction = JxlTransferFunction.Unknown;
+    }
+
+    public readonly bool IsSame(JxlCustomTransferFunction other)
+    {
+        if (this.HaveGamma != other.HaveGamma)
+        {
+            return false;
+        }
+
+        if (this.HaveGamma)
+        {
+            return this.Gamma == other.Gamma;
+        }
+
+        return this.TransferFunction == other.TransferFunction;
+    }
+
+    private static bool IsAlmostEqual(float a, float b)
+    {
+        const float dist = 1e-3f;
+        return MathF.Abs(a - b) < dist;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlCustomXy.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlCustomXy.cs
new file mode 100644
index 0000000000..95652cdaf4
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlCustomXy.cs
@@ -0,0 +1,53 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+/// <summary>
+/// A serializable form of CieXyChromaticityCoordinates
+/// </summary>
+internal struct JxlCustomXy
+{
+    private const uint Multiplier = 1000000;
+    private const float RoughLimit = 4.0f;
+    private const int Min = -0x200000;
+    private const int Max = 0x1FFFFF;
+
+    public int X { get; set; }
+
+    public int Y { get; set; }
+
+    public readonly CieXyChromaticityCoordinates GetValue() => new(
+        x: this.X * (1.0f / Multiplier),
+        y: this.Y * (1.0f / Multiplier));
+
+    public bool SetValue(CieXyChromaticityCoordinates xy)
+    {
+        bool ok = (Math.Abs(xy.X) < RoughLimit) && (Math.Abs(xy.Y) < RoughLimit);
+
+        if (!ok)
+        {
+            throw new InvalidOperationException("X or Y is out of bounds");
+        }
+
+        this.X = (int)MathF.Round((float)(xy.X * Multiplier));
+
+        if (this.X is < Min or > Max)
+        {
+            throw new InvalidOperationException("X is out of bounds");
+        }
+
+        this.Y = (int)MathF.Round((float)(xy.Y * Multiplier));
+
+        if (this.Y is < Min or > Max)
+        {
+            throw new InvalidOperationException("Y is out of bounds");
+        }
+
+        return true;
+    }
+
+    public readonly bool IsSame(CieXyChromaticityCoordinates other) => this.X == other.X && this.Y == other.Y;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlOpsinConstants.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlOpsinConstants.cs
new file mode 100644
index 0000000000..2b304885d1
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlOpsinConstants.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+/// <summary>
+/// Opsin constants used by the color management system
+/// </summary>
+internal static class JxlOpsinConstants
+{
+    public const float BScale = 1f;
+
+    // The following constants are used for XYB.
+    // They can be adjusted to change how Y<->B ratio
+    // works. For example, YToBRatio works better
+    // with 0.50017729543783418.
+    public const float YToBRatio = 1f;
+    public const float BToYRatio = 1f / YToBRatio;
+
+    // Adjusting these constants influences the opsin absorbance.
+    public const float OpsinAbsorbanceBias0 = 0.0037930732552754493f;
+    public const float OpsinAbsorbanceBias1 = OpsinAbsorbanceBias0;
+    public const float OpsinAbsorbanceBias2 = OpsinAbsorbanceBias0;
+
+    public static ReadOnlySpan<float> OpsinAbsorbanceBias => [OpsinAbsorbanceBias0, OpsinAbsorbanceBias1, OpsinAbsorbanceBias2];
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlPrimaries.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlPrimaries.cs
new file mode 100644
index 0000000000..48d4766fa6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlPrimaries.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+/// <summary>
+/// JPEG XL primaries
+/// </summary>
+internal enum JxlPrimaries : byte
+{
+    /// <summary>
+    /// Same as ITU-R BT.709
+    /// </summary>
+    SRgb = 1,
+
+    /// <summary>
+    /// Values encoded in separate fields
+    /// </summary>
+    Custom = 2,
+
+    /// <summary>
+    /// ITU-R BT.2020
+    /// </summary>
+    Bt2020 = 9,
+
+    P3 = 11,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlRenderingIntent.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlRenderingIntent.cs
new file mode 100644
index 0000000000..739dddcccd
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlRenderingIntent.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+internal enum JxlRenderingIntent : byte
+{
+    // Values match ICC sRGB encodings
+    Perceptual, // Good for photos, requires a profile with LUT
+    Relative,   // Good for logos
+    Saturation, // Perhaps useful for CG with fully saturated colors
+    Absolute,   // Leaves white point unchanged; good for proofing
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlTransferFunction.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlTransferFunction.cs
new file mode 100644
index 0000000000..cfee681765
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlTransferFunction.cs
@@ -0,0 +1,45 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+/// <summary>
+/// JPEG XL transfer function type
+/// </summary>
+internal enum JxlTransferFunction : byte
+{
+    /// <summary>
+    /// ITU-R BT.709
+    /// </summary>
+    Bt709 = 1,
+
+    /// <summary>
+    /// Unknown transfer function
+    /// </summary>
+    Unknown = 2,
+
+    /// <summary>
+    /// Linear transfer function
+    /// </summary>
+    Linear = 8,
+
+    /// <summary>
+    /// sRGB
+    /// </summary>
+    SRgb = 13,
+
+    /// <summary>
+    /// From ITU-R BT.2100
+    /// </summary>
+    Pq = 16,
+
+    /// <summary>
+    /// From SMPTE RP 431-2 reference projector
+    /// </summary>
+    Dci = 17,
+
+    /// <summary>
+    /// From ITU-R BT.2100
+    /// </summary>
+    Hlg = 18,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/JxlWhitePoint.cs b/src/ImageSharp/Formats/Jxl/Cms/JxlWhitePoint.cs
new file mode 100644
index 0000000000..c6c7e019f5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/JxlWhitePoint.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+/// <summary>
+/// White point from CICP Color Primaries.
+/// </summary>
+// Note that we define a separate enum instead of using the ColorPrimaries
+// enum from CICP code because JPEG XL doesn't support all color primaries defined
+// by CICP.
+internal enum JxlWhitePoint : byte
+{
+    /// <summary>
+    /// sRGB/ITU-R BT.709/Display P3/ITU-R BT.2020
+    /// </summary>
+    D65 = 1,
+
+    /// <summary>
+    /// Actual values encoded in separate fields
+    /// </summary>
+    Custom = 2,
+
+    /// <summary>
+    /// XYZ
+    /// </summary>
+    E = 10,
+
+    /// <summary>
+    /// DCI-P3
+    /// </summary>
+    Dci = 11,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/README.md b/src/ImageSharp/Formats/Jxl/Cms/README.md
new file mode 100644
index 0000000000..557a4c8b91
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/README.md
@@ -0,0 +1,4 @@
+# CMS
+This is the JPEG XL Color Management System component.
+
+Not to be confused with Content Management System.
diff --git a/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlBt709TransferFunction.cs b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlBt709TransferFunction.cs
new file mode 100644
index 0000000000..dfc9de66ea
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlBt709TransferFunction.cs
@@ -0,0 +1,57 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms.TransferFunctions;
+
+/// <summary>
+/// ITU-R BT.709 transfer function
+/// </summary>
+internal static class JxlBt709TransferFunction
+{
+    // Encoded From Display constants
+    private const float Threshold = 0.018f;
+    private const float MulLow = 4.5f;
+    private const float MulHi = 1.099f;
+    private const float PowHi = 0.45f;
+    private const float Sub = -0.099f;
+
+    // Display From Encoded constants
+    private const float InverseThreshold = 0.081f;
+    private const float InverseMulLow = 1f / 4.5f;
+    private const float InverseMulHi = 1f / 1.099f;
+    private const float InversePowHi = 1f / 0.45f;
+    private const float InverseAdd = 0.099f * InverseMulHi;
+
+    public static float EncodedFromDisplay(float d)
+    {
+        if (d < Threshold)
+        {
+            return MulLow * d;
+        }
+
+        return (MulHi * MathF.Pow(d, PowHi)) + Sub;
+    }
+
+    public static Vector<float> EncodedFromDisplay(Vector<float> x)
+    {
+        Vector<float> low = Vector.Create(MulLow) * x;
+        Vector<float> high = (Vector.Create(MulHi) * JxlSimdUtils.FastPowf(x, Vector.Create(PowHi))) + Vector.Create(Sub);
+        return Vector.ConditionalSelect(
+            Vector.LessThanOrEqual(x, Vector.Create(Threshold)),
+            low,
+            high);
+    }
+
+    public static Vector<float> DisplayFromEncoded(Vector<float> x)
+    {
+        Vector<float> low = Vector.Create(InverseMulLow) * x;
+        Vector<float> high = JxlSimdUtils.FastPowf((x * Vector.Create(InverseMulHi)) + Vector.Create(InverseAdd), Vector.Create(InversePowHi));
+        return Vector.ConditionalSelect(
+            Vector.LessThan(x, Vector.Create(InverseThreshold)),
+            low,
+            high);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlHlgTransferFunction.cs b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlHlgTransferFunction.cs
new file mode 100644
index 0000000000..053a2a5cfb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlHlgTransferFunction.cs
@@ -0,0 +1,159 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms.TransferFunctions;
+
+/// <summary>
+/// Hybrid Log Gamma transfer function.
+/// </summary>
+internal sealed class JxlHlgTransferFunction
+{
+    // Shared constants used by transfer functions
+    private const float A = 0.17883277f;
+    private const float RA = 1.0f / A;
+    private const float B = 1 - (4 * A);
+    private const float C = 0.5599107295f;
+    private const float Inverse12 = 1.0f / 12.0f;
+    private const float HiAdd = B * Inverse12;
+    private const float HiMul = 0.003639807079052639f; // MathF.Exp(-C * RA) * Inverse12
+    private const float HiPow = 8.067285659607931f; // RA * JxlMath.InverseLog2E
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlHlgTransferFunction"/> class.
+    /// </summary>
+    /// <remarks>
+    /// Use static methods. Don't instantiate this class.
+    /// </remarks>
+    private JxlHlgTransferFunction()
+    {
+    }
+
+    public static Vector<float> EncodedFromDisplay(Vector<float> x)
+    {
+        Vector<float> sign = Vector.Create(0x80000000u).As<uint, float>();
+        Vector<float> originalSign = x & sign;
+        x = Vector.AndNot(sign, x);
+        Vector<int> belowInverse12 = Vector.LessThan(x, Vector.Create(Inverse12));
+
+        Vector<float> lo = Vector.SquareRoot(Vector.Create(3.0f) * x);
+        Vector<float> hi = (Vector.Create(A * JxlMath.InverseLog2E) * Vector.Log2((Vector.Create(12f) * x) + Vector.Create(-B))) + Vector.Create(C);
+        Vector<float> magnitude = Vector.ConditionalSelect(belowInverse12, lo, hi);
+        return Vector.AndNot(sign, magnitude) | originalSign;
+    }
+
+    public static Vector<float> DisplayFromEncoded(Vector<float> x)
+    {
+        Vector<float> sign = Vector.Create(0x80000000u).As<uint, float>();
+        Vector<float> originalSign = x & sign;
+        x = Vector.AndNot(sign, x);
+        Vector<int> below05 = Vector.LessThan(x, Vector.Create(0.5f));
+
+        Vector<float> lo = x * (x * Vector.Create(1f / 3f));
+        Vector<float> hi = (Pow2(x * Vector.Create(HiPow)) * Vector.Create(HiMul)) + Vector.Create(HiAdd);
+        Vector<float> magnitude = Vector.ConditionalSelect(below05, lo, hi);
+
+        return Vector.AndNot(sign, magnitude) | originalSign;
+    }
+
+    private static Vector<float> Pow2(Vector<float> x) => JxlSimdUtils.FastPow2f(x);
+
+    /// <summary>
+    /// Converts encoded signal to display signal.
+    /// </summary>
+    /// <param name="encoded">The encoded signal</param>
+    /// <returns>The display signal</returns>
+    public static double DisplayFromEncoded(double encoded) => Ootf(InverseOotf(encoded));
+
+    /// <summary>
+    /// Converts display signal to encoded signal.
+    /// </summary>
+    /// <param name="display">The display signal</param>
+    /// <returns>The encoded signal</returns>
+    public static double EncodedFromDisplay(double display) => Oetf(InverseOetf(display));
+
+    /// <summary>
+    /// Opto-Electronic Transfer Function - converts
+    /// real-world scene light (s) into a digital video
+    /// signal inside a camera.
+    /// </summary>
+    /// <remarks>
+    /// <seealso href="https://en.wikipedia.org/wiki/Transfer_functions_in_imaging#Definition"/>
+    /// </remarks>
+    /// <param name="s">Scene light</param>
+    /// <returns>Digital video signal</returns>
+    public static double Oetf(double s)
+    {
+        if (s == 0)
+        {
+            return 0;
+        }
+
+        double originalSign = s;
+
+        s = Math.Abs(s);
+
+        if (s <= Inverse12)
+        {
+            return Math.CopySign(Math.Sqrt(3.0 * s), originalSign);
+        }
+
+        double e = (A * Math.Log((12 * s) - B)) + C;
+        DebugGuard.MustBeGreaterThan(e, 0.0, nameof(e));
+
+        return Math.CopySign(e, originalSign);
+    }
+
+    /// <summary>
+    /// Inverse Opto-Electronic Transfer Function - converts
+    /// digital video signal into a real-world scene light.
+    /// </summary>
+    /// <remarks>
+    /// <seealso href="https://en.wikipedia.org/wiki/Transfer_functions_in_imaging#Definition"/>
+    /// </remarks>
+    /// <param name="e">Digital video signal</param>
+    /// <returns>Scene light</returns>
+    public static double InverseOetf(double e)
+    {
+        if (e == 0)
+        {
+            return 0;
+        }
+
+        double originalSign = e;
+
+        e = Math.Abs(e);
+
+        if (e <= 0.5)
+        {
+            return Math.CopySign(e * e * (1.0 / 3), originalSign);
+        }
+
+        double s = (Math.Exp((e - C) * RA) + B) * Inverse12;
+        DebugGuard.MustBeGreaterThan(s, 0.0, nameof(s));
+
+        return Math.CopySign(s, originalSign);
+    }
+
+    /// <summary>
+    /// Opto-Optical Transfer Function - as-is.
+    /// </summary>
+    /// <remarks>
+    /// <seealso href="https://en.wikipedia.org/wiki/Transfer_functions_in_imaging#Definition"/>
+    /// </remarks>
+    /// <param name="s">Input signal</param>
+    /// <returns>Digital video signal</returns>
+    public static double Ootf(double s) => s;
+
+    /// <summary>
+    /// Inverse Opto-Optical Transfer Function - as-is.
+    /// </summary>
+    /// <remarks>
+    /// <seealso href="https://en.wikipedia.org/wiki/Transfer_functions_in_imaging#Definition"/>
+    /// </remarks>
+    /// <param name="s">Digital video signal</param>
+    /// <returns>Scene light</returns>
+    public static double InverseOotf(double s) => s;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlPqTransferFunction.cs b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlPqTransferFunction.cs
new file mode 100644
index 0000000000..f0df5c00c7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlPqTransferFunction.cs
@@ -0,0 +1,141 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms.TransferFunctions;
+
+/// <summary>
+/// Perceptual Quantization transfer function.
+/// </summary>
+internal struct JxlPqTransferFunction(float displayIntensityTarget = DefaultIntensityTarget)
+{
+    private const double M1 = 2610.0 / 16384;
+    private const double M2 = (2523.0 / 4096) * 128;
+    private const double C1 = 3424.0 / 4096;
+    private const double C2 = (2413.0 / 4096) * 32;
+    private const double C3 = (2392.0 / 4096) * 32;
+
+    private readonly float scaleFactorTo10000Nits = displayIntensityTarget * (1.0f / 10000.0f);
+    private readonly float scaleFactorFrom10000Nits = 10000.0f / displayIntensityTarget;
+
+    private static ReadOnlySpan<float> DisplayP =>
+    [
+        2.62975656e-04f, 2.62975656e-04f, 2.62975656e-04f, 2.62975656e-04f,
+        -6.23553089e-03f, -6.23553089e-03f, -6.23553089e-03f, -6.23553089e-03f,
+        7.38602301e-01f, 7.38602301e-01f, 7.38602301e-01f, 7.38602301e-01f,
+        2.64553172e+00f, 2.64553172e+00f, 2.64553172e+00f, 2.64553172e+00f,
+        5.50034862e-01f, 5.50034862e-01f, 5.50034862e-01f, 5.50034862e-01f
+    ];
+
+    private static ReadOnlySpan<float> DisplayQ =>
+    [
+        4.21350107e+02f, 4.21350107e+02f, 4.21350107e+02f, 4.21350107e+02f,
+        -4.28736818e+02f, -4.28736818e+02f, -4.28736818e+02f, -4.28736818e+02f,
+        1.74364667e+02f, 1.74364667e+02f, 1.74364667e+02f, 1.74364667e+02f,
+        -3.39078883e+01f, -3.39078883e+01f, -3.39078883e+01f, -3.39078883e+01f,
+        2.67718770e+00f, 2.67718770e+00f, 2.67718770e+00f, 2.67718770e+00f
+    ];
+
+    private static ReadOnlySpan<float> EncodedP =>
+    [
+        1.351392e-02f, 1.351392e-02f, 1.351392e-02f, 1.351392e-02f,
+        -1.095778e+00f, -1.095778e+00f, -1.095778e+00f, -1.095778e+00f,
+        5.522776e+01f, 5.522776e+01f, 5.522776e+01f, 5.522776e+01f,
+        1.492516e+02f, 1.492516e+02f, 1.492516e+02f, 1.492516e+02f,
+        4.838434e+01f, 4.838434e+01f, 4.838434e+01f, 4.838434e+01f
+    ];
+
+    private static ReadOnlySpan<float> EncodedQ =>
+    [
+        1.012416e+00f, 1.012416e+00f, 1.012416e+00f, 1.012416e+00f,
+        2.016708e+01f, 2.016708e+01f, 2.016708e+01f, 2.016708e+01f,
+        9.263710e+01f, 9.263710e+01f, 9.263710e+01f, 9.263710e+01f,
+        1.120607e+02f, 1.120607e+02f, 1.120607e+02f, 1.120607e+02f,
+        2.590418e+01f, 2.590418e+01f, 2.590418e+01f, 2.590418e+01f
+    ];
+
+    private static ReadOnlySpan<float> EncodedPLo =>
+    [
+        9.863406e-06f, 9.863406e-06f, 9.863406e-06f, 9.863406e-06f,
+        3.881234e-01f, 3.881234e-01f, 3.881234e-01f, 3.881234e-01f,
+        1.352821e+02f, 1.352821e+02f, 1.352821e+02f, 1.352821e+02f,
+        6.889862e+04f, 6.889862e+04f, 6.889862e+04f, 6.889862e+04f,
+        -2.864824e+05f, -2.864824e+05f, -2.864824e+05f, -2.864824e+05f
+    ];
+
+    private static ReadOnlySpan<float> EncodedQLo =>
+    [
+        3.371868e+01f, 3.371868e+01f, 3.371868e+01f, 3.371868e+01f,
+        1.477719e+03f, 1.477719e+03f, 1.477719e+03f, 1.477719e+03f,
+        1.608477e+04f, 1.608477e+04f, 1.608477e+04f, 1.608477e+04f,
+        -4.389884e+04f, -4.389884e+04f, -4.389884e+04f, -4.389884e+04f,
+        -2.072546e+05f, -2.072546e+05f, -2.072546e+05f, -2.072546e+05f
+    ];
+
+    public static double DisplayFromEncoded(float displayIntensityTarget, double e)
+    {
+        if (e == 0.0)
+        {
+            return 0.0;
+        }
+
+        double originalSign = e;
+
+        e = Math.Abs(e);
+
+        double xp = Math.Pow(e, 1.0 / M2);
+        double num = Math.Max(xp - C1, 0.0);
+        double den = C2 - (C3 * xp);
+        double d = Math.Pow(num / den, 1.0 / M1);
+
+        return Math.CopySign(d * (10000.0 / displayIntensityTarget), originalSign);
+    }
+
+    public static double EncodedFromDisplay(float displayIntensityTarget, double d)
+    {
+        if (d == 0.0)
+        {
+            return 0.0;
+        }
+
+        double originalSign = d;
+
+        d = Math.Abs(d);
+
+        double xp = Math.Pow(d * (displayIntensityTarget * (1 / 10000)), M1);
+        double num = C1 + (xp * C2);
+        double den = 1.0 + (xp * C3);
+        double e = Math.Pow(num / den, M2);
+
+        return Math.CopySign(e, originalSign);
+    }
+
+    public Vector<float> DisplayFromEncoded(Vector<float> x)
+    {
+        Vector<float> sign = Vector.Create(0x80000000u).As<uint, float>();
+        Vector<float> originalSign = x & sign;
+        x = Vector.AndNot(sign, x);
+
+        Vector<float> xpxx = (x * x) + x;
+        Vector<float> magnitude = EvaluateRationalPolynomial(xpxx, DisplayP, DisplayQ);
+
+        return Vector.AndNot(sign, magnitude * Vector.Create(this.scaleFactorFrom10000Nits)) | originalSign;
+    }
+
+    public Vector<float> EncodedFromDisplay(Vector<float> x)
+    {
+        Vector<float> sign = Vector.Create(0x80000000u).As<uint, float>();
+        Vector<float> originalSign = x & sign;
+        x = Vector.AndNot(sign, x);
+
+        Vector<float> xto025 = Vector.SquareRoot(Vector.SquareRoot(x * Vector.Create(this.scaleFactorTo10000Nits)));
+
+        Vector<float> magnitude = Vector.ConditionalSelect(
+            Vector.LessThan(x, Vector.Create(1e-4f)),
+            EvaluateRationalPolynomial(xto025, EncodedPLo, EncodedQLo),
+            EvaluateRationalPolynomial(xto025, EncodedP, EncodedQ));
+
+        return Vector.AndNot(sign, magnitude) | originalSign;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlSRgbTransferFunction.cs b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlSRgbTransferFunction.cs
new file mode 100644
index 0000000000..adc817ff78
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlSRgbTransferFunction.cs
@@ -0,0 +1,82 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms.TransferFunctions;
+
+internal static class JxlSRgbTransferFunction
+{
+    private const float ThresholdSRGBToLinear = 0.04045f;
+    private const float ThresholdLinearToSRGB = 0.0031308f;
+    private const float LowDiv = 12.92f;
+    private const float LowDivInverse = 1.0f / LowDiv;
+
+    private static ReadOnlySpan<float> DisplayP =>
+    [
+        2.200248328e-04f, 2.200248328e-04f, 2.200248328e-04f, 2.200248328e-04f,
+        1.043637593e-02f, 1.043637593e-02f, 1.043637593e-02f, 1.043637593e-02f,
+        1.624820318e-01f, 1.624820318e-01f, 1.624820318e-01f, 1.624820318e-01f,
+        7.961564959e-01f, 7.961564959e-01f, 7.961564959e-01f, 7.961564959e-01f,
+        8.210152774e-01f, 8.210152774e-01f, 8.210152774e-01f, 8.210152774e-01f
+    ];
+
+    private static ReadOnlySpan<float> DisplayQ =>
+    [
+        2.631846970e-01f, 2.631846970e-01f, 2.631846970e-01f, 2.631846970e-01f,
+        1.076976492e+00f, 1.076976492e+00f, 1.076976492e+00f, 1.076976492e+00f,
+        4.987528350e-01f, 4.987528350e-01f, 4.987528350e-01f, 4.987528350e-01f,
+        -5.512498495e-02f, -5.512498495e-02f, -5.512498495e-02f, -5.512498495e-02f,
+        6.521209011e-03f, 6.521209011e-03f, 6.521209011e-03f, 6.521209011e-03f
+    ];
+
+    private static ReadOnlySpan<float> EncodedP =>
+    [
+        -5.135152395e-04f, -5.135152395e-04f, -5.135152395e-04f, -5.135152395e-04f,
+        5.287254571e-03f, 5.287254571e-03f, 5.287254571e-03f, 5.287254571e-03f,
+        3.903842876e-01f, 3.903842876e-01f, 3.903842876e-01f, 3.903842876e-01f,
+        1.474205315e+00f, 1.474205315e+00f, 1.474205315e+00f, 1.474205315e+00f,
+        7.352629620e-01f, 7.352629620e-01f, 7.352629620e-01f, 7.352629620e-01f
+    ];
+
+    private static ReadOnlySpan<float> EncodedQ =>
+    [
+        1.004519624e-02f, 1.004519624e-02f, 1.004519624e-02f, 1.004519624e-02f,
+        3.036675394e-01f, 3.036675394e-01f, 3.036675394e-01f, 3.036675394e-01f,
+        1.340816930e+00f, 1.340816930e+00f, 1.340816930e+00f, 1.340816930e+00f,
+        9.258482155e-01f, 9.258482155e-01f, 9.258482155e-01f, 9.258482155e-01f,
+        2.424867759e-02f, 2.424867759e-02f, 2.424867759e-02f, 2.424867759e-02f
+    ];
+
+    public static Vector<float> DisplayFromEncoded(Vector<float> x)
+    {
+        Vector<float> sign = Vector.Create(0x80000000u).As<uint, float>();
+        Vector<float> originalSign = x & sign;
+        x = Vector.AndNot(sign, x);
+
+        Vector<float> linear = x * Vector.Create(LowDivInverse);
+        Vector<float> poly = EvaluateRationalPolynomial(x, DisplayP, DisplayQ);
+        Vector<float> magnitude = Vector.ConditionalSelect(
+            Vector.GreaterThan(x, Vector.Create(ThresholdSRGBToLinear)),
+            poly,
+            linear);
+
+        return Vector.AndNot(sign, magnitude) | originalSign;
+    }
+
+    public static Vector<float> EncodedFromDisplay(Vector<float> x)
+    {
+        Vector<float> sign = Vector.Create(0x80000000u).As<uint, float>();
+        Vector<float> originalSign = x & sign;
+        x = Vector.AndNot(sign, x);
+
+        Vector<float> linear = x * Vector.Create(LowDiv);
+        Vector<float> poly = EvaluateRationalPolynomial(Vector.SquareRoot(x), DisplayP, DisplayQ);
+        Vector<float> magnitude = Vector.ConditionalSelect(
+            Vector.GreaterThan(x, Vector.Create(ThresholdLinearToSRGB)),
+            poly,
+            linear);
+
+        return Vector.AndNot(sign, magnitude) | originalSign;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlTransferUtils.cs b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlTransferUtils.cs
new file mode 100644
index 0000000000..8b9760c73d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Cms/TransferFunctions/JxlTransferUtils.cs
@@ -0,0 +1,71 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Cms.TransferFunctions;
+
+internal static class JxlTransferUtils
+{
+    public static Vector<float> FastLinearToSrgb(Vector<float> v)
+    {
+        Vector<float> v025_05 = ((v.As<float, int>() & new Vector<int>(0x3effffff)) | new Vector<int>(0x3e800000)).As<int, float>();
+
+        Vector<float> d1 = (v025_05 * Vector.Create(0.059914046f)) - Vector.Create(0.108894556f);
+        Vector<float> d2 = (d1 * v025_05) + Vector.Create(0.107963754f);
+        Vector<float> pow = (d2 * v025_05) + Vector.Create(0.018092343f);
+
+        const uint baseBits = 0x40000000;
+
+        ReadOnlySpan<byte> powers25to18 =
+        [
+            0x00, 0x0a, 0x19, 0x26,
+            0x32, 0x41, 0x4d, 0x5c,
+            0x68, 0x75, 0x83, 0x8f,
+            0xa0, 0xaa, 0xb9, 0xc6
+        ];
+
+        ReadOnlySpan<byte> powers17to10 =
+        [
+            0x00, 0xb7, 0x04, 0x0d,
+            0xcb, 0xe7, 0x41, 0x68,
+            0x51, 0xd1, 0xeb, 0xf2,
+            0x00, 0xb7, 0x04, 0x0d
+        ];
+
+        Vector<int> bits = Vector.AsVectorInt32(v);
+        Vector<int> exp = (bits >> 23) - Vector.Create(118);
+
+        exp &= new Vector<int>(0xf);
+
+        Vector<int> p25to18 = GatherByteTable(exp, powers25to18);
+        Vector<int> p17to10 = GatherByteTable(exp, powers17to10);
+
+        Vector<int> mulBits =
+            (p25to18 << 18) |
+            (p17to10 << 10) |
+            new Vector<int>((int)baseBits);
+
+        Vector<float> mul = Vector.AsVectorSingle(mulBits);
+
+        Vector<float> cutoff = new(0.0031308f);
+
+        return Vector.ConditionalSelect(
+            Vector.LessThan(v, cutoff),
+            v * new Vector<float>(12.92f),
+            (pow * mul) - new Vector<float>(0.055f));
+    }
+
+    private static Vector<int> GatherByteTable(Vector<int> indices, ReadOnlySpan<byte> table)
+    {
+        int count = Vector<int>.Count;
+        Span<int> result = stackalloc int[count];
+
+        for (int i = 0; i < count; i++)
+        {
+            result[i] = table[indices[i]];
+        }
+
+        return new Vector<int>(result);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/IJxlFields.cs b/src/ImageSharp/Formats/Jxl/Fields/IJxlFields.cs
new file mode 100644
index 0000000000..bdc09f5f41
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/IJxlFields.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// Abstracts enumeration of all fields into a visitor.
+/// </summary>
+internal interface IJxlFields
+{
+    /// <summary>
+    /// Visits all fields into the specified JXL visitor.
+    /// </summary>
+    /// <param name="visitor">The visitor to use to visit all fields.</param>
+    /// <returns>Status of the visit operation.</returns>
+    public bool Visit(JxlVisitor visitor);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlAllDefaultVisitor.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlAllDefaultVisitor.cs
new file mode 100644
index 0000000000..cfe1430193
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlAllDefaultVisitor.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal sealed class JxlAllDefaultVisitor : JxlVisitorBase
+{
+    public bool IsAllDefault { get; private set; } = true;
+
+    public override bool Bits(int bits, uint defaultValue, ref uint value)
+    {
+        this.IsAllDefault = value == defaultValue;
+        return true;
+    }
+
+    public override bool U32(JxlU32Enc enc, uint defaultValue, ref uint value)
+    {
+        this.IsAllDefault = value == defaultValue;
+        return true;
+    }
+
+    public override bool U64(ulong defaultValue, ref ulong value)
+    {
+        this.IsAllDefault = value == defaultValue;
+        return true;
+    }
+
+    public override bool F16(float defaultValue, ref float value)
+    {
+        this.IsAllDefault = MathF.Abs(value - defaultValue) < 1E-6f;
+        return true;
+    }
+
+    public override bool AllDefault(IJxlFields fields, ref bool allDefault) => false;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlBitsCoder.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlBitsCoder.cs
new file mode 100644
index 0000000000..787d16d088
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlBitsCoder.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// Raw bits coder
+/// </summary>
+internal static class JxlBitsCoder
+{
+    /// <summary>
+    /// Maximum number of encodeable bits. Since this coder encodes
+    /// bits raw, this happens to be whatever is passed to it.
+    /// </summary>
+    // Looks like that's what the function does (fields.cc:406):
+    // it returns whatever is passed to it.
+    public static int MaxEncodedBits(int bits) => bits;
+
+    public static bool CanEncode(int bits, uint value, ref int encodedBits)
+    {
+        encodedBits = bits;
+        if (value >= (1 << bits))
+        {
+            DebugGuard.IsTrue(false, "Value is too large");
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public static void Write(int bits, uint value, JxlBitWriter writer)
+    {
+        if (value >= (1u << bits))
+        {
+            throw new InvalidOperationException("Value is too large to encode in " + bits + " bits");
+        }
+
+        writer.Write(bits, value);
+    }
+
+    // NOTE: BitsCoder::Read (fields.cc:418) returns a uint32_t,
+    // suggesting the input bit size does not exceed 32 bits.
+    public static uint Read(uint bits, JxlBitReader reader) => reader.ReadBits32(bits);
+
+    public static uint Read(int bits, JxlBitReader reader) => reader.ReadBits32((uint)bits);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlBundle.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlBundle.cs
new file mode 100644
index 0000000000..f7b8c921b1
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlBundle.cs
@@ -0,0 +1,174 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// An <see cref="IJxlFields"/> helper.
+/// </summary>
+internal static class JxlBundle
+{
+    /// <summary>
+    /// Initializes the specified JXL fields.
+    /// </summary>
+    /// <param name="fields">The JXL fields.</param>
+    public static void Init(IJxlFields fields)
+    {
+        JxlInitVisitor initVisitor = new();
+
+        if (!initVisitor.Visit(fields))
+        {
+            DebugGuard.IsTrue(false, "Init should never fail");
+        }
+    }
+
+    /// <summary>
+    /// Sets all JXL fields provided by the input value to their defaults.
+    /// </summary>
+    /// <param name="fields">The JXL fields.</param>
+    public static void SetDefault(IJxlFields fields)
+    {
+        JxlSetDefaultVisitor visitor = new();
+
+        if (!visitor.Visit(fields))
+        {
+            DebugGuard.IsTrue(false, "SetDefault should never fail");
+        }
+    }
+
+    /// <summary>
+    /// Returns a value indicating whether every value provided by this
+    /// field is a default value. If at least one field isn't a default
+    /// value, the method returns false.
+    /// </summary>
+    /// <param name="fields">The JXL fields.</param>
+    /// <returns>A boolean indicating whether or not are all values initialized to their default values.</returns>
+    public static bool AllDefault(IJxlFields fields)
+    {
+        JxlAllDefaultVisitor allDefaultVisitor = new();
+
+        if (!allDefaultVisitor.Visit(fields))
+        {
+            DebugGuard.IsTrue(false, "AllDefault should never fail");
+        }
+
+        return allDefaultVisitor.IsAllDefault;
+    }
+
+    /// <summary>
+    /// Reads the fields from a bit-reader.
+    /// </summary>
+    /// <param name="reader">The bit-reader.</param>
+    /// <param name="fields">The fields.</param>
+    /// <returns>Status of the read operation.</returns>
+    public static bool Read(JxlBitReader reader, IJxlFields fields)
+    {
+        JxlReadVisitor visitor = new(reader);
+        if (!visitor.Visit(fields))
+        {
+            return false;
+        }
+
+        return visitor.OK;
+    }
+
+    public static bool CanEncode(IJxlFields fields, ref int extensionBits, ref long totalBits)
+    {
+        JxlCanEncodeVisitor canEncodeVisitor = new();
+
+        if (!canEncodeVisitor.Visit(fields))
+        {
+            return false;
+        }
+
+        if (!canEncodeVisitor.GetSizes(ref extensionBits, ref totalBits))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Tries to read the fields from a bit-reader.
+    /// </summary>
+    /// <param name="reader">The bit-reader.</param>
+    /// <param name="fields">The fields.</param>
+    /// <returns>Status of the read operation.</returns>
+    public static bool CanRead(JxlBitReader reader, IJxlFields fields)
+    {
+        JxlReadVisitor visitor = new(reader);
+        _ = visitor.Visit(fields);
+        return visitor.OK;
+    }
+
+    public static bool Write(IJxlFields fields, JxlBitWriter writer, JxlLayerType layer, JxlAuxiliaryOutput auxOutput)
+    {
+        int extensionBits = 0;
+        long totalBits = 0;
+        if (!CanEncode(fields, ref extensionBits, ref totalBits))
+        {
+            return false;
+        }
+
+        return writer.WithMaxBits(totalBits, () =>
+        {
+            JxlWriteVisitor visitor = new(extensionBits, writer);
+
+            if (!visitor.Visit(fields))
+            {
+                return false;
+            }
+
+            return visitor.OK();
+        });
+    }
+
+    public static bool WriteCodestreamHeaders(JxlCodecMetadata metadata, JxlBitWriter writer, JxlAuxiliaryOutput auxOut)
+    {
+        // Marker/signature
+        if (!writer.WithMaxBits(16, () =>
+        {
+            writer.Write(8, 0xFF);
+            writer.Write(8, JxlShared.CodestreamMarker);
+            return true;
+        }))
+        {
+            return false;
+        }
+
+        if (!WriteSizeHeader(metadata.Size!, writer, JxlLayerType.Header, auxOut))
+        {
+            return false;
+        }
+
+        if (!WriteImageMetadata(metadata.ImageMetadata!, writer, JxlLayerType.Header, auxOut))
+        {
+            return false;
+        }
+
+        metadata.CustomTransformData!.NonserializedXybEncoded = metadata.ImageMetadata!.XybEncoded;
+
+        return Write(metadata.CustomTransformData!, writer, JxlLayerType.Header, auxOut);
+    }
+
+    public static bool WriteFrameHeader(JxlFrameHeader frame, JxlBitWriter writer, JxlAuxiliaryOutput auxOut)
+        => Write(frame, writer, JxlLayerType.Header, auxOut);
+
+    public static bool WriteImageMetadata(JxlImageMetadata metadata, JxlBitWriter writer, JxlLayerType layer, JxlAuxiliaryOutput auxOut)
+        => Write(metadata, writer, layer, auxOut);
+
+    public static bool WriteQuantizerParameters(JxlQuantizerParameters metadata, JxlBitWriter writer, JxlLayerType layer, JxlAuxiliaryOutput auxOut)
+        => Write(metadata, writer, layer, auxOut);
+
+    public static bool WriteSizeHeader(JxlSizeHeader header, JxlBitWriter writer, JxlLayerType layer, JxlAuxiliaryOutput auxOut)
+        => Write(header, writer, layer, auxOut);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlCanEncodeVisitor.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlCanEncodeVisitor.cs
new file mode 100644
index 0000000000..87192bfefc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlCanEncodeVisitor.cs
@@ -0,0 +1,118 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal sealed class JxlCanEncodeVisitor : JxlVisitorBase
+{
+    private long encodedBits;
+    private ulong extensions;
+    private long posAfterExt;
+
+    public bool OK { get; set; } = true;
+
+    public override bool Bits(int bits, uint defaultValue, ref uint value)
+    {
+        int enc = 0;
+        this.OK &= JxlBitsCoder.CanEncode(bits, value, ref enc);
+        this.encodedBits += enc;
+        return true;
+    }
+
+    public override bool U32(JxlU32Enc enc, uint defaultValue, ref uint value)
+    {
+        int encBits = 0;
+        this.OK &= JxlU32Coder.CanEncode(enc, value, ref encBits);
+        this.encodedBits += encBits;
+        return true;
+    }
+
+    public override bool U64(ulong defaultValue, ref ulong value)
+    {
+        int encBits = 0;
+        this.OK &= JxlU64Coder.CanEncode(value, ref encBits);
+        this.encodedBits += encBits;
+        return true;
+    }
+
+    public override bool F16(float defaultValue, ref float value)
+    {
+        int encBits = 0;
+        this.OK &= JxlF16Coder.CanEncode(value, ref encBits);
+        this.encodedBits += encBits;
+        return true;
+    }
+
+    public override bool AllDefault(IJxlFields fields, ref bool allDefault)
+    {
+        allDefault = JxlBundle.AllDefault(fields);
+        if (!this.Boolean(true, ref allDefault))
+        {
+            return false;
+        }
+
+        return allDefault;
+    }
+
+    public override bool BeginExtensions(ref ulong extensions)
+    {
+        if (!base.BeginExtensions(ref extensions))
+        {
+            return false;
+        }
+
+        this.extensions = extensions;
+
+        if (extensions != 0uL)
+        {
+            if (this.posAfterExt != 0)
+            {
+                return false;
+            }
+
+            this.posAfterExt = this.encodedBits;
+
+            if (this.posAfterExt == 0)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public bool GetSizes(ref int extensionBits, ref long totalBits)
+    {
+        if (!this.OK)
+        {
+            return false;
+        }
+
+        extensionBits = 0;
+        totalBits = this.encodedBits;
+
+        if (this.posAfterExt != 0)
+        {
+            if (this.encodedBits < this.posAfterExt)
+            {
+                return false;
+            }
+
+            extensionBits = (int)this.encodedBits - (int)this.posAfterExt;
+            int encodedBits = 0;
+            this.OK &= JxlU64Coder.CanEncode((ulong)extensionBits, ref encodedBits);
+            totalBits += encodedBits;
+
+            for (int i = 1; i < BitOperations.PopCount(this.extensions); i++)
+            {
+                encodedBits = 0;
+                this.OK &= JxlU64Coder.CanEncode(0, ref encodedBits);
+                totalBits += encodedBits;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlExtensionStates.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlExtensionStates.cs
new file mode 100644
index 0000000000..2cc3c82581
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlExtensionStates.cs
@@ -0,0 +1,42 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal sealed class JxlExtensionStates
+{
+    private ulong begun;
+    private ulong ended;
+
+    public bool IsBegun => (this.begun & 1) != 0;
+
+    public bool IsEnded => (this.ended & 1) != 0;
+
+    public void Push()
+    {
+        this.begun <<= 1;
+        this.ended <<= 1;
+    }
+
+    public void Pop()
+    {
+        this.begun >>= 1;
+        this.ended >>= 1;
+    }
+
+    public void Begin()
+    {
+        DebugGuard.IsFalse(this.IsBegun, nameof(this.IsBegun), "This must be false.");
+        DebugGuard.IsFalse(this.IsEnded, nameof(this.IsEnded), "This must be false.");
+
+        this.begun++;
+    }
+
+    public void End()
+    {
+        DebugGuard.IsTrue(this.IsBegun, nameof(this.IsBegun), "This must be true.");
+        DebugGuard.IsFalse(this.IsEnded, nameof(this.IsEnded), "This must be false.");
+
+        this.ended++;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlF16Coder.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlF16Coder.cs
new file mode 100644
index 0000000000..d5b0d30fd2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlF16Coder.cs
@@ -0,0 +1,136 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// Represents the Half-precision Floating-point number coder.
+/// </summary>
+internal static class JxlF16Coder
+{
+    /// <summary>
+    /// Always returns 16, which is the maximum possible encoded bits.
+    /// The F16 coder always reads 16 bits from the bitstream.
+    /// </summary>
+    public static int MaxEncodedBits() => 16;
+
+    /// <summary>
+    /// Returns a boolean indicating whether the input float
+    /// can be represented properly when encoded into a bit-stream.
+    /// Also stores the maximum encodeable bits into encodedBits (which is
+    /// always 16).
+    /// </summary>
+    public static bool CanEncode(float value, ref int encodedBits)
+    {
+        encodedBits = MaxEncodedBits();
+        if (float.IsNaN(value) || float.IsInfinity(value))
+        {
+            return false; // NaN and Infinity are not valid
+        }
+
+        return MathF.Abs(value) <= 65504.0f;
+    }
+
+    public static bool Read(JxlBitReader reader, ref float value)
+    {
+        uint bits16 = reader.ReadBits32(16u);
+        uint sign = bits16 >> 15;
+        uint biasedExponent = (bits16 >> 10) & 0x1Fu;
+        uint mantissa = bits16 & 0x3FFu;
+
+        if (biasedExponent == 31u)
+        {
+            // NaN and Infinity are not valid
+            return false;
+        }
+
+        if (biasedExponent == 0u)
+        {
+            // Subnormal or zero.
+            value = (1.0f / 16384) * (mantissa * (1.0f / 1024));
+            if (sign != 0u)
+            {
+                value = -value;
+            }
+
+            return true;
+        }
+
+        uint biasedExp32 = biasedExponent + (127u - 15u);
+        uint mantissa32 = mantissa << (23 - 10);
+        uint bits32 = (sign << 31) | (biasedExp32 << 23) | mantissa32;
+
+        value = BitConverter.UInt32BitsToSingle(bits32);
+
+        return true;
+    }
+
+    public static bool Write(float value, JxlBitWriter writer)
+    {
+        uint bits32 = BitConverter.SingleToUInt32Bits(value);
+
+        uint sign = bits32 >> 31;
+        uint biasedExp32 = (bits32 >> 23) & 0xFF;
+        uint mantissa32 = bits32 & 0x7FFFFF;
+
+        int exp = (int)biasedExp32 - 127;
+        if (exp > 15)
+        {
+            throw new InvalidOperationException("Too big to encode, CanEncode should return false");
+        }
+
+        // Tiny or zero => zero.
+        if (exp < -24)
+        {
+            writer.Write(16, 0);
+            return true;
+        }
+
+        uint biasedExp16 = 0;
+        uint mantissa16 = 0;
+
+        if (exp < -14)
+        {
+            biasedExp16 = 0;
+
+            uint subExp = unchecked((uint)(-14 - exp));
+
+            if (subExp is not (>= 1 and < 11))
+            {
+                return false;
+            }
+
+            mantissa16 = (1u << (int)(10 - subExp)) + (mantissa32 >> (int)(13 + subExp));
+        }
+        else
+        {
+            // exp = [-14, 15]
+            biasedExp16 = unchecked((uint)(exp + 15));
+
+            if (biasedExp16 is not (>= 1 and < 31))
+            {
+                return false;
+            }
+
+            mantissa16 = mantissa32 >> 13;
+        }
+
+        if (mantissa16 >= 1024)
+        {
+            return false;
+        }
+
+        uint bits16 = (sign << 15) | (biasedExp16 << 10) | mantissa16;
+
+        if (bits16 >= 0x10000)
+        {
+            return false;
+        }
+
+        writer.Write(16, bits16);
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlFieldExpressions.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlFieldExpressions.cs
new file mode 100644
index 0000000000..8d74c81bb8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlFieldExpressions.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal static class JxlFieldExpressions
+{
+    public static JxlU32Distribution Value(uint value)
+    {
+        const uint directConstant = JxlU32Distribution.DirectConstant;
+
+        return new(value | directConstant);
+    }
+
+    public static JxlU32Distribution BitsOffset(uint bits, uint offset)
+        => new(((bits - 1u) & 0x1Fu) + ((offset & 0x3FFFFFFu) << 5));
+
+    public static JxlU32Distribution Bits(uint value) => BitsOffset(value, 0u);
+
+    public static int MakeBit(int index) => 1 << index;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlInitVisitor.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlInitVisitor.cs
new file mode 100644
index 0000000000..28c16c4e46
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlInitVisitor.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// This variant of <see cref="JxlVisitorBase"/> sets values
+/// to be the default value.
+/// </summary>
+internal sealed class JxlInitVisitor : JxlVisitorBase
+{
+    public override bool Bits(int bits, uint defaultValue, ref uint value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool U32(JxlU32Distribution d0, JxlU32Distribution d1, JxlU32Distribution d2, JxlU32Distribution d3, uint defaultValue, ref uint value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool U64(ulong defaultValue, ref ulong value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool Boolean(bool defaultValue, ref bool value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool F16(float defaultValue, ref float value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool Conditional(bool condition) => true;
+
+    public override bool AllDefault(IJxlFields fields, ref bool allDefault)
+    {
+        _ = this.Boolean(true, ref allDefault);
+        return false;
+    }
+
+    public override bool VisitNested(IJxlFields fields) => true;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlReadVisitor.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlReadVisitor.cs
new file mode 100644
index 0000000000..d54dba6706
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlReadVisitor.cs
@@ -0,0 +1,121 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal sealed class JxlReadVisitor(JxlBitReader reader) : JxlVisitorBase
+{
+    private ulong totalExtensionBits;
+    private bool notEnoughBytes;
+    private long posAfterExtSize;
+    private readonly ulong[] extensionBits = new ulong[JxlBundle.MaxExtensions];
+
+    public bool OK { get; private set; }
+
+    public override bool IsReading => true;
+
+    public override bool Bits(int bits, uint defaultValue, ref uint value)
+    {
+        value = JxlBitsCoder.Read(bits, reader);
+        return this.ThrowIfEndOfStreamOrReturnTrue();
+    }
+
+    public override bool U32(JxlU32Enc enc, uint defaultValue, ref uint value)
+    {
+        value = JxlU32Coder.Read(enc, reader);
+        return this.ThrowIfEndOfStreamOrReturnTrue();
+    }
+
+    public override bool U64(ulong defaultValue, ref ulong value)
+    {
+        value = JxlU64Coder.Read(reader);
+        return this.ThrowIfEndOfStreamOrReturnTrue();
+    }
+
+    public override bool F16(float defaultValue, ref float value)
+    {
+        this.OK &= JxlF16Coder.Read(reader, ref value);
+        return this.ThrowIfEndOfStreamOrReturnTrue();
+    }
+
+    public override void SetDefault(IJxlFields fields) => JxlBundle.SetDefault(fields);
+
+    public override bool BeginExtensions(ref ulong extensions)
+    {
+        if (!base.BeginExtensions(ref extensions))
+        {
+            return false;
+        }
+
+        if (extensions == 0)
+        {
+            return true;
+        }
+
+        for (ulong remainingExtensions = extensions; remainingExtensions != 0; remainingExtensions &= remainingExtensions - 1)
+        {
+            ulong idxExtension = JxlMath.Num0BitsBelowLS1Bit_Nonzero(remainingExtensions);
+            if (!this.U64(0, ref this.extensionBits[idxExtension]))
+            {
+                return false;
+            }
+
+            if (!JxlMath.SafeAdd(this.totalExtensionBits, this.extensionBits[idxExtension], ref this.totalExtensionBits))
+            {
+                DebugGuard.IsTrue(false, "Extension bits overflow; the codestream is not valid");
+
+                return false;
+            }
+        }
+
+        this.posAfterExtSize = reader.TotalBitsConsumed;
+        return this.posAfterExtSize != 0;
+    }
+
+    public override bool EndExtensions()
+    {
+        if (!base.EndExtensions())
+        {
+            return false;
+        }
+
+        if (this.posAfterExtSize == 0)
+        {
+            return true;
+        }
+
+        if (this.notEnoughBytes)
+        {
+            return true;
+        }
+
+        long bitsRead = reader.TotalBitsConsumed;
+
+        long end = 0;
+        if (!JxlMath.SafeAdd(this.posAfterExtSize, this.totalExtensionBits, ref end))
+        {
+            DebugGuard.IsTrue(false, "Invalid extension size.");
+
+            return false;
+        }
+
+        if (bitsRead > end)
+        {
+            DebugGuard.IsTrue(false, "Read more extension bits than budgeted");
+
+            return false;
+        }
+
+        long remainingBits = end - bitsRead;
+
+        if (remainingBits != 0)
+        {
+            reader.SkipBits64((uint)remainingBits);
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlSetDefaultVisitor.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlSetDefaultVisitor.cs
new file mode 100644
index 0000000000..aab1bc90ba
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlSetDefaultVisitor.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// This is similar to InitVisitor but also initializes
+/// nested fields.
+/// </summary>
+internal sealed class JxlSetDefaultVisitor : JxlVisitorBase
+{
+    public override bool Bits(int bits, uint defaultValue, ref uint value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool U32(JxlU32Distribution d0, JxlU32Distribution d1, JxlU32Distribution d2, JxlU32Distribution d3, uint defaultValue, ref uint value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool U64(ulong defaultValue, ref ulong value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool Boolean(bool defaultValue, ref bool value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool F16(float defaultValue, ref float value)
+    {
+        value = defaultValue;
+        return true;
+    }
+
+    public override bool Conditional(bool condition) => true;
+
+    public override bool AllDefault(IJxlFields fields, ref bool allDefault)
+    {
+        _ = this.Boolean(true, ref allDefault);
+        return false;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlU32Coder.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlU32Coder.cs
new file mode 100644
index 0000000000..3fa3a3ab79
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlU32Coder.cs
@@ -0,0 +1,154 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// Unsigned 32-bit variable-length integer coder.
+/// </summary>
+internal static class JxlU32Coder
+{
+    /// <summary>
+    /// Maximum number of writeable and/or readable bits in a variable-length integer.
+    /// </summary>
+    public static int MaxEncodedBits(in JxlU32Enc enc)
+    {
+        int extraBits = 0;
+
+        for (int selector = 0; selector < 4; selector++)
+        {
+            JxlU32Distribution distr = enc.GetDistribution(selector);
+
+            if (distr.IsDirect)
+            {
+                continue;
+            }
+            else
+            {
+                extraBits = Math.Max(extraBits, (int)distr.ExtraBits);
+            }
+        }
+
+        return 2 + extraBits;
+    }
+
+    /// <summary>
+    /// Verifies that the value can be encoded.
+    /// </summary>
+    public static bool CanEncode(in JxlU32Enc enc, uint value, ref int encodedBits)
+    {
+        uint selector = 0;
+        int totalBits = 0;
+
+        bool isOk = ChooseSelector(in enc, value, ref selector, ref totalBits);
+
+        encodedBits = isOk ? totalBits : 0;
+
+        return isOk;
+    }
+
+    /// <summary>
+    /// Reads the U32 coded value.
+    /// </summary>
+    public static uint Read(in JxlU32Enc enc, JxlBitReader reader)
+    {
+        uint selector = reader.ReadBits32(2u);
+        JxlU32Distribution dist = enc.GetDistribution((int)selector);
+
+        if (dist.IsDirect)
+        {
+            return dist.Direct;
+        }
+        else
+        {
+            return reader.ReadBits32(dist.ExtraBits) + dist.Offset;
+        }
+    }
+
+    /// <summary>
+    /// Tries to find the best one of the four selectors based on the value.
+    /// </summary>
+    public static bool ChooseSelector(in JxlU32Enc enc, uint value, ref uint selector, ref int totalBits)
+    {
+        uint bitsRequired = 32 - JxlMath.Num0BitsAboveMS1Bit(value);
+
+        if (bitsRequired > 32)
+        {
+            return false;
+        }
+
+        selector = 0;
+        totalBits = 64;
+
+        for (int s = 0; s < 4; s++)
+        {
+            JxlU32Distribution dist = enc.GetDistribution(s);
+
+            if (dist.IsDirect)
+            {
+                if (dist.Direct == value)
+                {
+                    selector = (uint)s;
+                    totalBits = 2;
+                    return true;
+                }
+
+                continue;
+            }
+
+            uint extraBits = dist.ExtraBits;
+            uint offset = dist.Offset;
+
+            if (value < offset || value >= offset + (1u << (int)extraBits))
+            {
+                continue;
+            }
+
+            if (2 + extraBits < totalBits)
+            {
+                selector = (uint)s;
+                totalBits = 2 + (int)extraBits;
+            }
+        }
+
+        if (totalBits == 64)
+        {
+            throw new InvalidOperationException("No matching selector");
+        }
+
+        return true;
+    }
+
+    public static bool Write(in JxlU32Enc enc, uint value, JxlBitWriter writer)
+    {
+        uint selector = 0;
+        int totalBits = 0;
+
+        if (!ChooseSelector(in enc, value, ref selector, ref totalBits))
+        {
+            return false;
+        }
+
+        writer.Write(2, selector);
+
+        JxlU32Distribution d = enc.GetDistribution((int)selector);
+
+        if (!d.IsDirect)
+        {
+            uint offset = d.Offset;
+
+            if (value < offset)
+            {
+                return false;
+            }
+
+            writer.WriteBits(totalBits - 2, value - offset);
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlU32Distribution.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlU32Distribution.cs
new file mode 100644
index 0000000000..355b6f533f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlU32Distribution.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal struct JxlU32Distribution(uint d)
+{
+    public const uint DirectConstant = 0x80000000u;
+
+    public readonly bool IsDirect => (d & DirectConstant) != 0;
+
+    public readonly uint Direct => d & (DirectConstant - 1u);
+
+    public readonly uint ExtraBits => (d & 0x1Fu) + 1u;
+
+    public readonly uint Offset => (d >> 5) & 0x3FFFFFF;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlU32Enc.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlU32Enc.cs
new file mode 100644
index 0000000000..5b6e10b847
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlU32Enc.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal readonly struct JxlU32Enc
+{
+    private readonly InlineArray4<JxlU32Distribution> d = default;
+
+    public JxlU32Enc(JxlU32Distribution d0, JxlU32Distribution d1, JxlU32Distribution d2, JxlU32Distribution d3)
+    {
+        this.d[0] = d0;
+        this.d[1] = d1;
+        this.d[2] = d2;
+        this.d[3] = d3;
+    }
+
+    public JxlU32Distribution GetDistribution(int selector)
+    {
+        // This stuff is internal, so if argument check
+        // fails it's not a user error.
+        DebugGuard.MustBeLessThan(selector, 4, nameof(selector));
+
+        return this.d[selector];
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlU64Coder.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlU64Coder.cs
new file mode 100644
index 0000000000..3336ecf0f2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlU64Coder.cs
@@ -0,0 +1,160 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// Unsigned 64-bit variable-length coding.
+/// </summary>
+internal static class JxlU64Coder
+{
+    /// <summary>
+    /// Reads the variable-length, unsigned 64-bit integer.
+    /// </summary>
+    public static ulong Read(JxlBitReader reader)
+    {
+        uint selector = reader.ReadBits32(2u);
+
+        if (selector == 0u)
+        {
+            return 0u;
+        }
+        else if (selector == 1u)
+        {
+            return 1u + reader.ReadBits32(4u);
+        }
+        else if (selector == 2u)
+        {
+            return 17u + reader.ReadBits32(8u);
+        }
+
+        // Selector 3...
+        ulong result = reader.ReadBits32(12u);
+        int shift = 12;
+
+        while (reader.ReadBoolean())
+        {
+            if (shift == 60)
+            {
+                result |= (ulong)reader.ReadBits32(4u) << shift;
+                break;
+            }
+
+            result |= (ulong)reader.ReadBits32(8u) << shift;
+            shift += 8;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Returns a value indicating whether can the value be encoded,
+    /// as well as the number of encoded bits.
+    /// </summary>
+    public static bool CanEncode(ulong value, ref int encodedBits)
+    {
+        if (value == 0)
+        {
+            // 2 selector bits
+            encodedBits = 2;
+        }
+        else if (value <= 16)
+        {
+            // 2 selector bits + 4 payload bits
+            encodedBits = 2 + 4;
+        }
+        else if (value <= 272)
+        {
+            // 2 selector bits + 8 payload bits
+            encodedBits = 2 + 8;
+        }
+        else
+        {
+            // 2 selector bits + 12 payload bits
+            encodedBits = 2 + 12;
+            value >>= 12;
+            int shift = 12;
+            while (value > 0 && shift < 60)
+            {
+                // 1 continuation bit + 8 payload bits
+                encodedBits += 1 + 8;
+                value >>= 8;
+                shift += 8;
+            }
+
+            if (value > 0)
+            {
+                // 1 continuation bit + 4 payload bits
+                encodedBits += 1 + 4;
+            }
+            else
+            {
+                // 1 stop bit
+                encodedBits += 1;
+            }
+        }
+
+        return true;
+    }
+
+    public static bool Write(ulong value, JxlBitWriter writer)
+    {
+        if (value == 0)
+        {
+            // Selector: use 0 bits, value 0
+            writer.Write(2, 0);
+        }
+        else if (value <= 16)
+        {
+            // Selector: use 4 bits, value 1..16
+            writer.Write(2, 1);
+            writer.Write(4, value - 1);
+        }
+        else if (value <= 272)
+        {
+            // Selector: use 8 bits, value 17..272
+            writer.Write(2, 2);
+            writer.Write(8, value - 17);
+        }
+        else
+        {
+            // Selector: varint, first a 12-bit group, after that per 8-bit group.
+            writer.Write(2, 3);
+            writer.Write(12, value & 4095);
+            value >>= 12;
+            int shift = 12;
+            while (value > 0 && shift < 60)
+            {
+                // Indicate varint not done
+                writer.Write(1, 1);
+                writer.Write(8, value & 255);
+                value >>= 8;
+                shift += 8;
+            }
+
+            if (value > 0)
+            {
+                // This only could happen if shift == N - 4.
+                writer.Write(1, 1);
+                writer.Write(4, value & 15);
+
+                // Implicitly closed sequence, no extra stop bit is required.
+            }
+            else
+            {
+                // Indicate end of varint
+                writer.Write(1, 0);
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Always returns 73.
+    /// </summary>
+    public static int MaxEncodedBits() => 73;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlVisitor.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlVisitor.cs
new file mode 100644
index 0000000000..7fa79f75d2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlVisitor.cs
@@ -0,0 +1,92 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+/// <summary>
+/// Base JPEG XL visitor that can visit all fields of a class.
+/// This is highly similar to the following Reflection code, but with
+/// lower overhead:
+/// <code>
+/// // Pseudocode
+/// void Visit(Type type)
+/// {
+///     foreach (PropertyInfo property in type.GetProperties())
+///     {
+///         /* visitor implementation */(property);
+///     }
+/// }
+/// </code>
+/// </summary>
+internal class JxlVisitor
+{
+    public virtual bool IsReading => false;
+
+    public virtual bool Visit(IJxlFields fields) => false;
+
+    public virtual bool Boolean(bool defaultValue, ref bool value) => false;
+
+    public virtual bool U32(JxlU32Enc enc, uint defaultValue, ref uint value) => false;
+
+    public virtual bool U32(
+        JxlU32Distribution d0,
+        JxlU32Distribution d1,
+        JxlU32Distribution d2,
+        JxlU32Distribution d3,
+        uint defaultValue,
+        ref uint value)
+        => this.U32(new JxlU32Enc(d0, d1, d2, d3), value, ref defaultValue);
+
+    public virtual unsafe bool Enum<T>(T defaultValue, ref T value)
+        where T : unmanaged
+    {
+        DebugGuard.IsTrue(sizeof(T) == 4, "We use unsafe bit casting so anything beside 4 bytes will break memory layout");
+
+        ref uint u32 = ref Unsafe.As<T, uint>(ref value);
+        if (!this.U32(
+            JxlFieldExpressions.Value(0),
+            JxlFieldExpressions.Value(1),
+            JxlFieldExpressions.BitsOffset(4, 2),
+            JxlFieldExpressions.BitsOffset(6, 18),
+            Unsafe.BitCast<T, uint>(defaultValue),
+            ref u32))
+        {
+            return false;
+        }
+
+        return System.Enum.IsDefined(typeof(T), value);
+    }
+
+    public virtual bool Bits(int bits, uint defaultValue, ref uint value) => false;
+
+    public virtual bool U64(ulong defaultValue, ref ulong value) => false;
+
+    public virtual bool F16(float defaultValue, ref float value) => false;
+
+    public virtual bool Conditional(bool condition) => condition;
+
+    public virtual bool AllDefault(IJxlFields fields, ref bool allDefault)
+    {
+        // Do not remove the fields parameter, derived classes
+        // use it.
+        if (!this.Boolean(true, ref allDefault))
+        {
+            return false;
+        }
+
+        return allDefault;
+    }
+
+    public virtual void SetDefault(IJxlFields fields)
+    {
+        // Used by derived methods.
+    }
+
+    public virtual bool VisitNested(IJxlFields fields) => this.Visit(fields);
+
+    public virtual bool BeginExtensions(ref ulong extensions) => false;
+
+    public virtual bool EndExtensions() => false;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Fields/JxlVisitorBase.cs b/src/ImageSharp/Formats/Jxl/Fields/JxlVisitorBase.cs
new file mode 100644
index 0000000000..ff3ee5a3d5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Fields/JxlVisitorBase.cs
@@ -0,0 +1,76 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+internal class JxlVisitorBase : JxlVisitor
+{
+    private readonly JxlExtensionStates extensionStates = new();
+    private int depth;
+
+    public override bool Visit(IJxlFields fields)
+    {
+        if (this.depth >= JxlBundle.MaxExtensions)
+        {
+            return false;
+        }
+
+        this.depth++;
+        this.extensionStates.Push();
+
+        bool visited = fields.Visit(this);
+
+        if (visited)
+        {
+            if (!(!this.extensionStates.IsBegun || this.extensionStates.IsEnded))
+            {
+                throw new InvalidOperationException("Invalid extension state");
+            }
+        }
+
+        this.extensionStates.Pop();
+
+        if (this.depth == 0)
+        {
+            throw new InvalidOperationException("Depth must not be 0");
+        }
+        this.depth--;
+
+        return visited;
+    }
+
+    public override bool Boolean(bool defaultValue, ref bool value)
+    {
+        uint bits = value ? 1u : 0u;
+        if (!this.Bits(1, defaultValue ? 1u : 0u, ref bits))
+        {
+            return false;
+        }
+
+        if (bits > 1u)
+        {
+            throw new InvalidOperationException("Invalid bits");
+        }
+
+        value = bits == 1u;
+
+        return true;
+    }
+
+    public override bool BeginExtensions(ref ulong extensions)
+    {
+        if (!this.U64(0uL, ref extensions))
+        {
+            return false;
+        }
+
+        this.extensionStates.Begin();
+        return true;
+    }
+
+    public override bool EndExtensions()
+    {
+        this.extensionStates.End();
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/BinaryUtils.Generated.cs b/src/ImageSharp/Formats/Jxl/IO/BinaryUtils.Generated.cs
new file mode 100644
index 0000000000..a5b07c45f6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/BinaryUtils.Generated.cs
@@ -0,0 +1,320 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO;
+
+/// <summary>
+/// Reads primitives from streams with correct endianness.
+/// </summary>
+// TODO: move this class into the IO or Common folder?
+internal static class BinaryUtils
+{
+    /// <summary>
+    /// Reads a <see cref="Int16" />
+    /// from the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int16" /> will be read from.</param>
+    /// <returns><see cref="Int16" /></returns>
+    public static Int16 ReadInt16LittleEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int16)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadInt16LittleEndian(data);
+    }
+
+    /// <summary>
+    /// Reads a <see cref="Int16" />
+    /// from the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int16" /> will be read from.</param>
+    /// <returns><see cref="Int16" /></returns>
+    public static Int16 ReadInt16BigEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int16)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadInt16BigEndian(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="Int16" />
+    /// into the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int16" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteInt16LittleEndian(Stream stream, Int16 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int16)];
+        BinaryPrimitives.WriteInt16LittleEndian(data, value);
+        stream.Write(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="Int16" />
+    /// into the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int16" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteInt16BigEndian(Stream stream, Int16 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int16)];
+        BinaryPrimitives.WriteInt16BigEndian(data, value);
+        stream.Write(data);
+    }
+    /// <summary>
+    /// Reads a <see cref="UInt16" />
+    /// from the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt16" /> will be read from.</param>
+    /// <returns><see cref="UInt16" /></returns>
+    public static UInt16 ReadUInt16LittleEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt16)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadUInt16LittleEndian(data);
+    }
+
+    /// <summary>
+    /// Reads a <see cref="UInt16" />
+    /// from the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt16" /> will be read from.</param>
+    /// <returns><see cref="UInt16" /></returns>
+    public static UInt16 ReadUInt16BigEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt16)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadUInt16BigEndian(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="UInt16" />
+    /// into the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt16" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteUInt16LittleEndian(Stream stream, UInt16 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt16)];
+        BinaryPrimitives.WriteUInt16LittleEndian(data, value);
+        stream.Write(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="UInt16" />
+    /// into the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt16" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteUInt16BigEndian(Stream stream, UInt16 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt16)];
+        BinaryPrimitives.WriteUInt16BigEndian(data, value);
+        stream.Write(data);
+    }
+    /// <summary>
+    /// Reads a <see cref="Int32" />
+    /// from the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int32" /> will be read from.</param>
+    /// <returns><see cref="Int32" /></returns>
+    public static Int32 ReadInt32LittleEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int32)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadInt32LittleEndian(data);
+    }
+
+    /// <summary>
+    /// Reads a <see cref="Int32" />
+    /// from the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int32" /> will be read from.</param>
+    /// <returns><see cref="Int32" /></returns>
+    public static Int32 ReadInt32BigEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int32)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadInt32BigEndian(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="Int32" />
+    /// into the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int32" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteInt32LittleEndian(Stream stream, Int32 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int32)];
+        BinaryPrimitives.WriteInt32LittleEndian(data, value);
+        stream.Write(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="Int32" />
+    /// into the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int32" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteInt32BigEndian(Stream stream, Int32 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int32)];
+        BinaryPrimitives.WriteInt32BigEndian(data, value);
+        stream.Write(data);
+    }
+    /// <summary>
+    /// Reads a <see cref="UInt32" />
+    /// from the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt32" /> will be read from.</param>
+    /// <returns><see cref="UInt32" /></returns>
+    public static UInt32 ReadUInt32LittleEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt32)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadUInt32LittleEndian(data);
+    }
+
+    /// <summary>
+    /// Reads a <see cref="UInt32" />
+    /// from the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt32" /> will be read from.</param>
+    /// <returns><see cref="UInt32" /></returns>
+    public static UInt32 ReadUInt32BigEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt32)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadUInt32BigEndian(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="UInt32" />
+    /// into the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt32" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteUInt32LittleEndian(Stream stream, UInt32 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt32)];
+        BinaryPrimitives.WriteUInt32LittleEndian(data, value);
+        stream.Write(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="UInt32" />
+    /// into the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt32" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteUInt32BigEndian(Stream stream, UInt32 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt32)];
+        BinaryPrimitives.WriteUInt32BigEndian(data, value);
+        stream.Write(data);
+    }
+    /// <summary>
+    /// Reads a <see cref="Int64" />
+    /// from the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int64" /> will be read from.</param>
+    /// <returns><see cref="Int64" /></returns>
+    public static Int64 ReadInt64LittleEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int64)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadInt64LittleEndian(data);
+    }
+
+    /// <summary>
+    /// Reads a <see cref="Int64" />
+    /// from the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int64" /> will be read from.</param>
+    /// <returns><see cref="Int64" /></returns>
+    public static Int64 ReadInt64BigEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int64)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadInt64BigEndian(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="Int64" />
+    /// into the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int64" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteInt64LittleEndian(Stream stream, Int64 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int64)];
+        BinaryPrimitives.WriteInt64LittleEndian(data, value);
+        stream.Write(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="Int64" />
+    /// into the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="Int64" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteInt64BigEndian(Stream stream, Int64 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(Int64)];
+        BinaryPrimitives.WriteInt64BigEndian(data, value);
+        stream.Write(data);
+    }
+    /// <summary>
+    /// Reads a <see cref="UInt64" />
+    /// from the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt64" /> will be read from.</param>
+    /// <returns><see cref="UInt64" /></returns>
+    public static UInt64 ReadUInt64LittleEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt64)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadUInt64LittleEndian(data);
+    }
+
+    /// <summary>
+    /// Reads a <see cref="UInt64" />
+    /// from the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt64" /> will be read from.</param>
+    /// <returns><see cref="UInt64" /></returns>
+    public static UInt64 ReadUInt64BigEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt64)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.ReadUInt64BigEndian(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="UInt64" />
+    /// into the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt64" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteUInt64LittleEndian(Stream stream, UInt64 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt64)];
+        BinaryPrimitives.WriteUInt64LittleEndian(data, value);
+        stream.Write(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="UInt64" />
+    /// into the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="UInt64" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void WriteUInt64BigEndian(Stream stream, UInt64 value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(UInt64)];
+        BinaryPrimitives.WriteUInt64BigEndian(data, value);
+        stream.Write(data);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/BinaryUtils.tt b/src/ImageSharp/Formats/Jxl/IO/BinaryUtils.tt
new file mode 100644
index 0000000000..ba98aca4ad
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/BinaryUtils.tt
@@ -0,0 +1,85 @@
+<#@ template language="C#" #>
+<#@ import namespace="System" #>
+<#@ import namespace="System.IO" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".Generated.cs" #>
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO;
+
+<#
+    List<Type> types = [
+        typeof(short),
+        typeof(ushort),
+        typeof(int),
+        typeof(uint),
+        typeof(long),
+        typeof(ulong)
+    ];
+#>
+/// <summary>
+/// Reads primitives from streams with correct endianness.
+/// </summary>
+// TODO: move this class into the IO or Common folder?
+internal static class BinaryUtils
+{
+<#
+    foreach (Type type in types)
+    {
+#>
+    /// <summary>
+    /// Reads a <see cref="<#= type.Name #>" />
+    /// from the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="<#= type.Name #>" /> will be read from.</param>
+    /// <returns><see cref="<#= type.Name #>" /></returns>
+    public static <#= type.Name #> Read<#= type.Name#>LittleEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(<#= type.Name #>)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.Read<#= type.Name #>LittleEndian(data);
+    }
+
+    /// <summary>
+    /// Reads a <see cref="<#= type.Name #>" />
+    /// from the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="<#= type.Name #>" /> will be read from.</param>
+    /// <returns><see cref="<#= type.Name #>" /></returns>
+    public static <#= type.Name #> Read<#= type.Name#>BigEndian(Stream stream)
+    {
+        Span<byte> data = stackalloc byte[sizeof(<#= type.Name #>)];
+        stream.ReadExactly(data);
+        return BinaryPrimitives.Read<#= type.Name #>BigEndian(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="<#= type.Name #>" />
+    /// into the specified stream in little-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="<#= type.Name #>" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void Write<#= type.Name #>LittleEndian(Stream stream, <#= type.Name #> value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(<#= type.Name #>)];
+        BinaryPrimitives.Write<#= type.Name #>LittleEndian(data, value);
+        stream.Write(data);
+    }
+
+    /// <summary>
+    /// Writes a <see cref="<#= type.Name #>" />
+    /// into the specified stream in big-endian order.
+    /// </summary>
+    /// <param name="stream">The stream where the <see cref="<#= type.Name #>" /> will be written to.</param>
+    /// <param name="value">Value which will be written to the stream.</param>
+    public static void Write<#= type.Name #>BigEndian(Stream stream, <#= type.Name #> value)
+    {
+        Span<byte> data = stackalloc byte[sizeof(<#= type.Name #>)];
+        BinaryPrimitives.Write<#= type.Name #>BigEndian(data, value);
+        stream.Write(data);
+    }
+<# } #>
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Container/JxlBoxHeader.cs b/src/ImageSharp/Formats/Jxl/IO/Container/JxlBoxHeader.cs
new file mode 100644
index 0000000000..8e3600bb5e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Container/JxlBoxHeader.cs
@@ -0,0 +1,158 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Container;
+
+/// <summary>
+/// Header for JPEG XL container format.
+/// </summary>
+[StructLayout(LayoutKind.Sequential, Size = 16)]
+internal struct JxlBoxHeader
+{
+    /// <summary>
+    /// Box size in bytes.
+    /// </summary>
+    public ulong Size;
+
+    /// <summary>
+    /// Type of the box.
+    /// </summary>
+    public uint Type;
+
+    /// <summary>
+    /// True if the size field extends until the end of the file.
+    /// </summary>
+    public bool SizeExtendsTillEnd;
+
+    /// <summary>
+    /// True if the size is 64-bit.
+    /// </summary>
+    public bool ContainsLargeSize;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlBoxHeader"/> struct.
+    /// </summary>
+    /// <param name="size">The size of the box.</param>
+    /// <param name="type">The type of the box.</param>
+    /// <param name="sizeExtendsTillEnd">Does the box size extend till the end of the file?</param>
+    /// <param name="containsLargeSize">Is there a 64-bit size field?</param>
+    public JxlBoxHeader(ulong size, uint type, bool sizeExtendsTillEnd, bool containsLargeSize)
+    {
+        this.Size = size;
+        this.Type = type;
+        this.SizeExtendsTillEnd = sizeExtendsTillEnd;
+        this.ContainsLargeSize = containsLargeSize;
+    }
+
+    /// <summary>
+    /// Converts a 4-character ASCII string (e.g. "jxlc") into a uint type code.
+    /// </summary>
+    /// <param name="typeString">Input type string to convert</param>
+    /// <returns>Unsigned integer representation of the type string</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint TypeFromString(string typeString)
+    {
+        if (typeString.Length != 4)
+        {
+            throw new ArgumentException("Box type must be exactly 4 characters", nameof(typeString));
+        }
+
+        return ((uint)typeString[0] << 24) |
+           ((uint)typeString[1] << 16) |
+           ((uint)typeString[2] << 8) |
+           typeString[3];
+    }
+
+    /// <summary>
+    /// Converts a uint type code back into a 4-character ASCII string.
+    /// </summary>
+    /// <param name="typeCode">Unsigned integer representation of the type string</param>
+    /// <returns>The string representing the type code.</returns>
+    public static string TypeToString(uint typeCode)
+    {
+        return typeCode switch
+        {
+            0x6A786C20 => "jxl ",
+            0x6A786C70 => "jxlp",
+            0x6A786C63 => "jxlc",
+            0x66747970 => "ftyp",
+            0x6A627264 => "jbrd",
+            0x45786966 => "Exif",
+            0x786D6C20 => "xml ",
+            0x6A756D62 => "jumb",
+            _ => Fallback(typeCode)
+        };
+
+        static string Fallback(uint typeCode)
+        {
+            // The box type is not known
+            Span<byte> buffer = stackalloc byte[4];
+            BinaryPrimitives.WriteUInt32BigEndian(buffer, typeCode);
+
+            return Encoding.ASCII.GetString(buffer);
+        }
+    }
+
+    /// <summary>
+    /// Parses the JPEG XL box header.
+    /// </summary>
+    /// <param name="stream">A stream to parse the header from.</param>
+    /// <returns>The box header.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the header is invalid.</exception>
+    public static JxlBoxHeader ReadHeader(Stream stream)
+    {
+        ulong size = BinaryUtils.ReadUInt32BigEndian(stream);
+        bool haveSize64 = false;
+
+        if (size == 1)
+        {
+            // When the size value is equal to 1, a new 64-bit
+            // size field follows.
+            haveSize64 = true;
+            size = BinaryUtils.ReadUInt64BigEndian(stream);
+        }
+
+        // Read the 4-byte type field.
+        uint type = BinaryUtils.ReadUInt32BigEndian(stream);
+
+        if (haveSize64)
+        {
+            // When the 64-bit largesize was read,
+            // the size cannot proceed till the end of the file.
+            if (size is 0 or 1)
+            {
+                throw new InvalidOperationException("Large size cannot have another large size or extend till the end of the file");
+            }
+
+            return new JxlBoxHeader(size, type, sizeExtendsTillEnd: false, containsLargeSize: true);
+        }
+        else
+        {
+            return new JxlBoxHeader(size, type, sizeExtendsTillEnd: size == 0, containsLargeSize: false);
+        }
+    }
+
+    /// <summary>
+    /// Writes the box header to the specified stream.
+    /// </summary>
+    /// <param name="writer">The stream to write the box header to.</param>
+    public readonly void WriteHeader(Stream writer)
+    {
+        if (this.Size is > uint.MaxValue or 1)
+        {
+            BinaryUtils.WriteUInt32BigEndian(writer, 1); // Indicates a large size is present
+            BinaryUtils.WriteUInt64BigEndian(writer, this.Size);
+        }
+        else
+        {
+            BinaryUtils.WriteUInt32BigEndian(writer, (uint)this.Size);
+        }
+
+        BinaryUtils.WriteUInt32BigEndian(writer, this.Type);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Container/JxlFileTypeBox.cs b/src/ImageSharp/Formats/Jxl/IO/Container/JxlFileTypeBox.cs
new file mode 100644
index 0000000000..ca2adb1ca4
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Container/JxlFileTypeBox.cs
@@ -0,0 +1,58 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Container;
+
+/// <summary>
+/// A ftyp box payload.
+/// </summary>
+internal sealed class JxlFileTypeBox(string majorBrand, uint minorVersion)
+{
+    /// <summary>
+    /// Gets or sets the primary format. Has to be "jxl " for JPEG XL.
+    /// </summary>
+    public string MajorBrand { get; set; } = majorBrand;
+
+    /// <summary>
+    /// Gets or sets the revision of the major brand.
+    /// </summary>
+    public uint MinorVersion { get; set; } = minorVersion;
+
+    /// <summary>
+    /// Gets or sets the list of other brands the file is compatible with.
+    /// </summary>
+    public List<string> CompatibleBrands { get; set; } = [];
+
+    public int GetPayloadSize() => 8 + (this.CompatibleBrands.Count * 4);
+
+    public static JxlFileTypeBox Parse(Stream stream, ulong boxSize)
+    {
+        string majorBrand = JxlBoxHeader.TypeToString(BinaryUtils.ReadUInt32BigEndian(stream));
+        uint minorVersion = BinaryUtils.ReadUInt32BigEndian(stream);
+        boxSize -= 8;
+
+        List<string> compatibleBrands = [];
+        for (ulong i = 0; i < boxSize; i += 4)
+        {
+            compatibleBrands.Add(JxlBoxHeader.TypeToString(BinaryUtils.ReadUInt32BigEndian(stream)));
+        }
+
+        JxlFileTypeBox ftyp = new(majorBrand, minorVersion)
+        {
+            CompatibleBrands = compatibleBrands
+        };
+
+        return ftyp;
+    }
+
+    public void WritePayload(Stream stream)
+    {
+        BinaryUtils.WriteUInt32BigEndian(stream, JxlBoxHeader.TypeFromString(this.MajorBrand));
+        BinaryUtils.WriteUInt32BigEndian(stream, this.MinorVersion);
+
+        foreach (string compatibleBrand in this.CompatibleBrands)
+        {
+            BinaryUtils.WriteUInt32BigEndian(stream, JxlBoxHeader.TypeFromString(compatibleBrand));
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsConstants.cs b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsConstants.cs
new file mode 100644
index 0000000000..d9b6d1150d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsConstants.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+internal static class JxlAnsConstants
+{
+    public const int AnsLogTableSize = 12;
+    public const int AnsTableSize = 1 << AnsLogTableSize;
+    public const int AnsTabMask = AnsTableSize - 1;
+    public const int PrefixMaxAlphabetSize = 4096;
+    public const int AnsMaxAlphabetSize = 256;
+    public const int PrefixMaxBits = 15;
+    public const int AnsSignature = 0x13;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsEntry.cs b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsEntry.cs
new file mode 100644
index 0000000000..7ec8c7cd4c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsEntry.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct JxlAnsEntry
+{
+    public byte Cutoff;
+    public byte RightValue;
+    public ushort Frequency0;
+    public ushort Offsets1;
+    public ushort Frequency1XorFrequency0;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsHelper.cs b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsHelper.cs
new file mode 100644
index 0000000000..7feda2848d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsHelper.cs
@@ -0,0 +1,239 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+internal static class JxlAnsHelper
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int GetPopulationCountPrecision(int logCount, int shift)
+        => Math.Max(0, Math.Min(logCount, shift - ((JxlAnsConstants.AnsLogTableSize - logCount) >> 1)));
+
+    // NOTE: The result may potentially be large, so prefer using a memory allocator
+    public static IMemoryOwner<uint> CreateFlatHistogram(Configuration configuration, int length, int totalCount)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(length, 0, nameof(length));
+        DebugGuard.MustBeGreaterThan(length, totalCount, nameof(length));
+
+        int count = totalCount / length;
+        IMemoryOwner<uint> result = configuration.MemoryAllocator.Allocate<uint>(length);
+        Span<uint> resultSpan = result.Memory.Span;
+        uint unsignedCount = (uint)count;
+
+        for (int i = 0; i < length; i++)
+        {
+            resultSpan[i] = unsignedCount;
+        }
+
+        int remCounts = totalCount % length;
+        for (int i = 0; i < remCounts; i++)
+        {
+            resultSpan[i]++;
+        }
+
+        return result;
+    }
+
+    public static JxlAnsSymbol Lookup(ReadOnlySpan<JxlAnsEntry> table, int value, int logEntrySize, int entrySizeMinus1)
+    {
+        int i = value >> logEntrySize;
+        int pos = value & entrySizeMinus1;
+
+        JxlAnsEntry entry = table[i];
+
+        int cutoff = entry.Cutoff;
+        int rightValue = entry.RightValue;
+        int freq0 = entry.Frequency0;
+
+        bool greater = pos >= cutoff;
+
+        int offsets1or0 = greater ? entry.Offsets1 : 0;
+        int freq1xorfreq0or0 = greater ? entry.Frequency1XorFrequency0 : 0;
+
+        JxlAnsSymbol symbol = new()
+        {
+            Value = greater ? rightValue : i,
+            Offset = offsets1or0 + pos,
+            Frequency = freq0 ^ freq1xorfreq0or0
+        };
+
+        return symbol;
+    }
+
+    public static bool InitAliasTable(Span<int> preDistribution, uint logRange, int logAlphaSize, Span<JxlAnsEntry> entries)
+    {
+        DebugGuard.MustBeLessThan(logAlphaSize, (int)logRange, nameof(logAlphaSize));
+
+        int range = 1 << (int)logRange;
+        int tableSize = 1 << logAlphaSize;
+
+        int distributionPointer = preDistribution.Length - 1;
+
+        while (distributionPointer >= 0 && preDistribution[distributionPointer] == 0)
+        {
+            distributionPointer--;
+        }
+
+        if (distributionPointer < 0)
+        {
+            preDistribution[0] = range;
+            distributionPointer = 0;
+        }
+
+        Span<int> distribution = preDistribution[..(distributionPointer + 1)];
+
+        if (distribution.Length > tableSize)
+        {
+            throw new InvalidOperationException("Too many items in the distribution");
+        }
+
+        int entrySize = range >> logAlphaSize;
+        int singleSymbol = -1;
+        int sum = 0;
+
+        for (int sym = 0; sym < distribution.Length; sym++)
+        {
+            int value = distribution[sym];
+            sum += value;
+
+            if (value == JxlAnsConstants.AnsTableSize)
+            {
+                if (singleSymbol != -1)
+                {
+                    return false;
+                }
+
+                singleSymbol = sym;
+            }
+        }
+
+        if (sum != range)
+        {
+            return false;
+        }
+
+        if (singleSymbol != -1)
+        {
+            byte sym = (byte)singleSymbol;
+            if (singleSymbol != sym)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < tableSize; i++)
+            {
+                ref JxlAnsEntry jxlEntry = ref entries[i];
+
+                jxlEntry.RightValue = sym;
+                jxlEntry.Cutoff = 0;
+                jxlEntry.Offsets1 = (ushort)(entrySize * i);
+                jxlEntry.Frequency0 = 0;
+                jxlEntry.Frequency1XorFrequency0 = JxlAnsConstants.AnsTableSize;
+            }
+
+            return true;
+        }
+
+        Span<uint> underfullPosn = stackalloc uint[distribution.Length];
+        Span<uint> overfullPosn = stackalloc uint[distribution.Length];
+        Span<uint> cutoffs = stackalloc uint[1 << logAlphaSize];
+
+        int underfullPointer = 0;
+        int overfullPointer = 0;
+
+        for (int i = 0; i < distribution.Length; i++)
+        {
+            uint currentCutoff = (uint)distribution[i];
+
+            cutoffs[i] = currentCutoff;
+
+            if (currentCutoff > entrySize)
+            {
+                overfullPosn[overfullPointer] = (uint)i;
+                overfullPointer++;
+            }
+            else if (currentCutoff < entrySize)
+            {
+                underfullPosn[underfullPointer] = (uint)i;
+                underfullPointer++;
+            }
+        }
+
+        for (int i = distribution.Length; i < tableSize; i++)
+        {
+            cutoffs[i] = 0;
+            underfullPosn[underfullPointer] = (uint)i;
+            underfullPointer++;
+        }
+
+        uint unsignedEntrySize = (uint)entrySize;
+
+        while (overfullPointer >= 0)
+        {
+            uint overfullIndex = overfullPosn[overfullPointer];
+            overfullPointer--;
+
+            if (underfullPointer <= -1)
+            {
+                return false;
+            }
+
+            uint underfullIndex = underfullPosn[underfullPointer];
+            underfullPointer--;
+
+            int signedOverfullIndex = (int)overfullIndex;
+            int signedUnderfullIndex = (int)underfullIndex;
+
+            uint underfullBy = unsignedEntrySize - cutoffs[signedUnderfullIndex];
+            cutoffs[signedOverfullIndex] -= underfullBy;
+
+            ref JxlAnsEntry currentEntry = ref entries[signedUnderfullIndex];
+
+            currentEntry.RightValue = unchecked((byte)overfullIndex);
+            currentEntry.Offsets1 = unchecked((ushort)cutoffs[signedOverfullIndex]);
+
+            uint currentCutoff = cutoffs[signedOverfullIndex];
+
+            if (currentCutoff < entrySize)
+            {
+                underfullPosn[underfullPointer] = overfullIndex;
+                underfullPointer++;
+            }
+            else if (currentCutoff > entrySize)
+            {
+                overfullPosn[overfullPointer] = overfullIndex;
+                overfullPointer++;
+            }
+        }
+
+        for (uint i = 0; i < tableSize; i++)
+        {
+            uint currentCutoff = cutoffs[(int)i];
+            ref JxlAnsEntry entry = ref entries[(int)i];
+
+            if (currentCutoff == entrySize)
+            {
+                entry.RightValue = (byte)i;
+                entry.Offsets1 = 0;
+                entry.Cutoff = 0;
+            }
+            else
+            {
+                entry.Offsets1 -= (ushort)currentCutoff;
+                entry.Cutoff = (byte)currentCutoff;
+            }
+
+            int freq0 = i < distribution.Length ? distribution[(int)i] : 0;
+            int i1 = entry.RightValue;
+            int freq1 = i1 < distribution.Length ? distribution[i1] : 0;
+
+            entry.Frequency0 = (ushort)freq0;
+            entry.Frequency1XorFrequency0 = (ushort)(freq1 ^ freq0);
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsHybridUIntConfiguration.cs b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsHybridUIntConfiguration.cs
new file mode 100644
index 0000000000..9ff4306522
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsHybridUIntConfiguration.cs
@@ -0,0 +1,63 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+internal sealed class JxlAnsHybridUIntConfiguration : IJxlFields
+{
+    public JxlAnsHybridUIntConfiguration(uint splitExponent = 4, uint msbInToken = 2, uint lsbInToken = 0)
+    {
+        this.SplitExponent = splitExponent;
+        this.SplitToken = 1u << (int)splitExponent;
+        this.MsbInToken = msbInToken;
+        this.LsbInToken = lsbInToken;
+
+        if (splitExponent < msbInToken + lsbInToken)
+        {
+            throw new InvalidOperationException("Split exponent should be < msbInToken + lsbInToken");
+        }
+    }
+
+    public uint SplitExponent { get; set; }
+
+    public uint SplitToken { get; set; }
+
+    public uint MsbInToken { get; set; } // Most significant bit
+
+    public uint LsbInToken { get; set; } // Least significant bit
+
+    public uint LsbMask => (1u << (int)this.LsbInToken) - 1;
+
+    public void Encode(uint value, out uint token, out uint bitCount, out uint bits)
+    {
+        if (value < this.SplitToken)
+        {
+            token = value;
+            bitCount = 0;
+            bits = 0;
+        }
+        else
+        {
+            uint n = JxlMath.FloorLog2Nonzero(value);
+            uint m = value - (1u << (int)n);
+
+            unchecked
+            {
+                // The following expression is quite complex.
+                // See https://github.com/libjxl/libjxl/blob/main/lib/jxl/dec_ans.h#L83C16-L86C47.
+                token = this.SplitToken +
+                (uint)(((n - this.SplitExponent) << (int)(this.MsbInToken + this.LsbInToken)) +
+                        ((m >> (int)(n - this.MsbInToken)) << (int)this.LsbInToken) +
+                        (m & ((1 << (int)this.LsbInToken) - 1)));
+
+                bitCount = n - this.MsbInToken - this.LsbInToken;
+                bits = (value >> (int)this.LsbInToken) & ((1u << (int)bitCount) - 1);
+            }
+        }
+    }
+
+    public bool Visit(JxlVisitor visitor) => throw new NotImplementedException();
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsLz77Parameters.cs b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsLz77Parameters.cs
new file mode 100644
index 0000000000..01016f4dd6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsLz77Parameters.cs
@@ -0,0 +1,81 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+internal sealed class JxlAnsLz77Parameters : IJxlFields
+{
+    private bool enabled;
+    private uint minimumSymbol;
+    private uint minimumLength;
+    private JxlAnsHybridUIntConfiguration lengthUintConfig = new(0, 0, 0);
+
+    public JxlAnsLz77Parameters() => JxlBundle.Init(this);
+
+    public bool Enabled
+    {
+        get => this.enabled;
+        set => this.enabled = value;
+    }
+
+    public uint MinimumSymbol
+    {
+        get => this.minimumSymbol;
+        set => this.minimumSymbol = value;
+    }
+
+    public uint MinimumLength
+    {
+        get => this.minimumLength;
+        set => this.minimumLength = value;
+    }
+
+    public JxlAnsHybridUIntConfiguration LengthUintConfig
+    {
+        get => this.lengthUintConfig;
+        set => this.lengthUintConfig = value;
+    }
+
+    public int NonserializedDistanceContext { get; set; }
+
+    public ref JxlAnsHybridUIntConfiguration GetLengthUIntConfigReference() => ref this.lengthUintConfig;
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (!visitor.Boolean(false, ref this.enabled))
+        {
+            return false;
+        }
+
+        if (!visitor.Conditional(this.enabled))
+        {
+            return true;
+        }
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value(224u),
+            JxlFieldExpressions.Value(512u),
+            JxlFieldExpressions.Value(4096u),
+            JxlFieldExpressions.BitsOffset(15u, 8u),
+            224u,
+            ref this.minimumSymbol))
+        {
+            return false;
+        }
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value(3u),
+            JxlFieldExpressions.Value(4u),
+            JxlFieldExpressions.BitsOffset(2u, 5u),
+            JxlFieldExpressions.BitsOffset(8u, 9u),
+            3u,
+            ref this.minimumLength))
+        {
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsSymbol.cs b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsSymbol.cs
new file mode 100644
index 0000000000..240b2463eb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Entropy/JxlAnsSymbol.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct JxlAnsSymbol(int value, int offset, int frequency)
+{
+    public int Value = value;
+    public int Offset = offset;
+    public int Frequency = frequency;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlAnimationFrame.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlAnimationFrame.cs
new file mode 100644
index 0000000000..1854b4ab67
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlAnimationFrame.cs
@@ -0,0 +1,74 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Metadata;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Describes duration of frames that make up an animation.
+/// </summary>
+internal sealed class JxlAnimationFrame : IJxlFields
+{
+    /// <summary>
+    /// See <see cref="Duration"/>.
+    /// </summary>
+    private uint duration;
+
+    /// <summary>
+    /// See <see cref="Timecode"/>.
+    /// </summary>
+    private uint timecode;
+
+    /// <summary>
+    /// Gets or sets the duration of the animation.
+    /// </summary>
+    public uint Duration
+    {
+        get => this.duration;
+        set => this.duration = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the timecode of the animation. The
+    /// format is 0xHHMMSSFF.
+    /// </summary>
+    public uint Timecode
+    {
+        get => this.timecode;
+        set => this.timecode = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the optional codec metadata.
+    /// </summary>
+    public JxlCodecMetadata? CodecMetadata { get; set; }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (visitor.Conditional(this.CodecMetadata?.ImageMetadata?.HaveAnimation == true))
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Bits(8),
+                JxlFieldExpressions.Bits(32),
+                0,
+                ref this.duration))
+            {
+                return false;
+            }
+        }
+
+        if (visitor.Conditional(this.CodecMetadata?.ImageMetadata?.Animation?.ContainsTimecodes == true))
+        {
+            if (!visitor.Bits(32, 0u, ref this.timecode))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlBlendMode.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlBlendMode.cs
new file mode 100644
index 0000000000..035a48edd5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlBlendMode.cs
@@ -0,0 +1,64 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Represents the blending mode describing how to combine
+/// current frame with previously saved frame.
+/// </summary>
+internal enum JxlBlendMode : byte
+{
+    /// <summary>
+    /// New values replace old ones.
+    /// <code>
+    /// sample = new
+    /// </code>
+    /// </summary>
+    Replace,
+
+    /// <summary>
+    /// New values add to the old ones.
+    /// <code>
+    /// sample = old + new
+    /// </code>
+    /// </summary>
+    Add,
+
+    /// <summary>
+    /// New values replace old ones if alpha&gt;0:
+    /// <code>
+    /// alpha = old + new * (1 - old)
+    /// </code>
+    /// For other channels if !alpha_associated:
+    /// <code>
+    /// sample = ((1 - newAlpha) * old * oldAlpha + newAlpha * new) / alpha
+    /// </code>
+    /// For other channels if alpha_associated:
+    /// <code>
+    /// sample = (1 - newAlpha) * old + new
+    /// </code>
+    /// </summary>
+    Blend,
+
+    /// <summary>
+    /// New values are added to the old ones if alpha&gt;0:
+    /// For the alpha channel that is used as source:
+    /// <code>
+    /// sample = old + new * (1 - old)
+    /// </code>
+    /// Otherwise:
+    /// <code>
+    /// sample = old + alpha * new
+    /// </code>
+    /// </summary>
+    AlphaWeightedBlend,
+
+    /// <summary>
+    /// New values are multiplied by old ones:
+    /// <code>
+    /// sample = old * new
+    /// </code>
+    /// </summary>
+    Multiply
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlBlendingInfo.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlBlendingInfo.cs
new file mode 100644
index 0000000000..58c79d22db
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlBlendingInfo.cs
@@ -0,0 +1,146 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Provides options and instructions that tell the decoder the proper
+/// way to blend the current and previous frame together.
+/// </summary>
+internal sealed class JxlBlendingInfo : IJxlFields
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlBlendingInfo"/> class.
+    /// </summary>
+    public JxlBlendingInfo() => JxlBundle.Init(this);
+
+    /// <summary>
+    /// Gets or sets the blending mode. See <see cref="JxlBlendMode"/>.
+    /// </summary>
+    public JxlBlendMode BlendMode { get; set; }
+
+    /// <summary>
+    /// Gets or sets the value that indicates which extra channel
+    /// to use as alpha channel for blending.
+    /// </summary>
+    public uint AlphaChannel { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the alpha or channel values
+    /// must be clamped* to the 0 through 1 range.
+    /// </summary>
+    /// <remarks>
+    /// Clamped - must be limited to the specified range.
+    /// </remarks>
+    public bool Clamp { get; set; }
+
+    /// <summary>
+    /// Gets or sets the frame ID to copy from (0 through 3).
+    /// </summary>
+    /// <remarks>
+    /// If <see cref="BlendMode"/> is equal to <see cref="JxlBlendMode.Replace"/>,
+    /// the value of this property is ignored.
+    /// </remarks>
+    public uint Source { get; set; }
+
+    /// <summary>
+    /// Gets or sets the total number of extra channels.
+    /// </summary>
+    public int ExtraChannelCount { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the frame is partial.
+    /// </summary>
+    public bool IsPartialFrame { get; set; }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        JxlBlendMode mode = this.BlendMode;
+        if (!VisitBlendMode(visitor, JxlBlendMode.Replace, ref mode))
+        {
+            return false;
+        }
+
+        this.BlendMode = mode;
+
+        if (visitor.Conditional(this.ExtraChannelCount > 0 && mode is JxlBlendMode.Blend or JxlBlendMode.AlphaWeightedBlend))
+        {
+            uint alphaChannel = this.AlphaChannel;
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0u),
+                JxlFieldExpressions.Value(1u),
+                JxlFieldExpressions.Value(2u),
+                JxlFieldExpressions.BitsOffset(3u, 3u),
+                0,
+                ref alphaChannel))
+            {
+                return false;
+            }
+
+            this.AlphaChannel = alphaChannel;
+
+            if (visitor.IsReading && alphaChannel >= this.ExtraChannelCount)
+            {
+                throw new InvalidOperationException("Invalid alpha channel for blending");
+            }
+        }
+
+        if (visitor.Conditional((this.ExtraChannelCount > 0 && mode is JxlBlendMode.Blend or JxlBlendMode.AlphaWeightedBlend) || mode == JxlBlendMode.Multiply))
+        {
+            bool clamp = this.Clamp;
+
+            if (!visitor.Boolean(false, ref clamp))
+            {
+                return false;
+            }
+
+            this.Clamp = clamp;
+        }
+
+        if (visitor.Conditional(mode != JxlBlendMode.Replace || this.IsPartialFrame))
+        {
+            uint source = this.Source;
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.Value(3),
+                0,
+                ref source))
+            {
+                return false;
+            }
+
+            this.Source = source;
+        }
+
+        return true;
+    }
+
+    private static bool VisitBlendMode(JxlVisitor visitor, JxlBlendMode defaultValue, ref JxlBlendMode valueToEncode)
+    {
+        uint unsignedBackingValue = (uint)valueToEncode;
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value((uint)JxlBlendMode.Replace),
+            JxlFieldExpressions.Value((uint)JxlBlendMode.Add),
+            JxlFieldExpressions.Value((uint)JxlBlendMode.Blend),
+            JxlFieldExpressions.BitsOffset(2u, 3u),
+            (uint)defaultValue,
+            ref unsignedBackingValue))
+        {
+            return false;
+        }
+
+        if (unsignedBackingValue > (uint)JxlBlendMode.Multiply)
+        {
+            throw new InvalidOperationException("Invalid blend mode");
+        }
+
+        valueToEncode = (JxlBlendMode)unsignedBackingValue;
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlColorTransform.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlColorTransform.cs
new file mode 100644
index 0000000000..f874983486
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlColorTransform.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Represents the type of JPEG XL color transform.
+/// </summary>
+internal enum JxlColorTransform : byte
+{
+    /// <summary>
+    /// Use XYB encoding
+    /// </summary>
+    Xyb,
+
+    /// <summary>
+    /// Encode according to the attached color profile.
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Encode according to the attached color profile but
+    /// transformed into Y'Cb'Cr.
+    /// </summary>
+    YCbCr,
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlColorTransformHelpers.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlColorTransformHelpers.cs
new file mode 100644
index 0000000000..81bc941870
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlColorTransformHelpers.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Helper methods associated with JxlColorTransform.
+/// </summary>
+internal static class JxlColorTransformHelpers
+{
+    private static ReadOnlySpan<int> Grayscale => [0, 0, 0];
+
+    private static ReadOnlySpan<int> YCbCr => [1, 0, 2];
+
+    private static ReadOnlySpan<int> None => [0, 1, 2];
+
+    public static ReadOnlySpan<int> GetJpegOrder(JxlColorTransform transform, bool isGraysacle)
+    {
+        if (isGraysacle)
+        {
+            return Grayscale;
+        }
+
+        if (transform == JxlColorTransform.YCbCr)
+        {
+            return YCbCr;
+        }
+
+        return None;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameEncoding.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameEncoding.cs
new file mode 100644
index 0000000000..77ae964ac9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameEncoding.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Represents the kind of frame encoding.
+/// </summary>
+internal enum JxlFrameEncoding : byte
+{
+    /// <summary>
+    /// Use VarDCT
+    /// </summary>
+    VarDct,
+
+    /// <summary>
+    /// Use Modular encoding
+    /// </summary>
+    Modular
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameHeader.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameHeader.cs
new file mode 100644
index 0000000000..c1cf766b0e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameHeader.cs
@@ -0,0 +1,744 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+// Disable IDE0032 for consistency with other fields.
+// We have to avoid auto properties for most fields
+// so we can use the ref keyword on them directly.
+#pragma warning disable IDE0032 // Use auto property
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Control information for a JPEG XL frame.
+/// </summary>
+internal sealed class JxlFrameHeader : IJxlFields
+{
+    // The following are backing fields for properties.
+    private JxlFrameEncoding encoding = JxlFrameEncoding.Modular;
+    private JxlFrameType frameType = JxlFrameType.RegularFrame;
+    private ulong flags;
+    private JxlColorTransform colorTransform = JxlColorTransform.Xyb;
+    private JxlYCbCrChromaSubsampling? chromaSubsampling;
+    private uint groupSizeShift;
+    private uint xQmScale;
+    private uint bQmScale;
+    private string? name;
+    private bool customSizeOrOrigin;
+    private Size frameSize;
+    private uint upsampling;
+    private List<uint> extraChannelUpsampling = [];
+    private Point frameOrigin;
+    private JxlBlendingInfo? blendingInfo;
+    private List<JxlBlendingInfo> extraChannelBlendingInfo = [];
+    private readonly JxlAnimationFrame? animationFrame;
+    private bool isLast;
+    private uint saveAsReference;
+    private bool saveBeforeColorTransform;
+    private uint dcLevel;
+    private JxlCodecMetadata? metadata;
+    private JxlLoopFilter? loopFilter;
+    private ulong extensions;
+
+    private bool isPreviewFrame;    // Non-serialized
+
+    /// <summary>
+    /// Gets or sets the frame encoding method (e.g., Modular or VarDCT).
+    /// </summary>
+    public JxlFrameEncoding Encoding
+    {
+        get => this.encoding;
+        set => this.encoding = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the type of frame (e.g., RegularFrame).
+    /// </summary>
+    public JxlFrameType FrameType
+    {
+        get => this.frameType;
+        set => this.frameType = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the frame flags.
+    /// </summary>
+    public ulong Flags
+    {
+        get => this.flags;
+        set => this.flags = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the color transform used (e.g., XYB).
+    /// </summary>
+    public JxlColorTransform ColorTransform
+    {
+        get => this.colorTransform;
+        set => this.colorTransform = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the chroma subsampling information.
+    /// </summary>
+    public JxlYCbCrChromaSubsampling? ChromaSubsampling
+    {
+        get => this.chromaSubsampling;
+        set => this.chromaSubsampling = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the group size shift value.
+    /// </summary>
+    public uint GroupSizeShift
+    {
+        get => this.groupSizeShift;
+        set => this.groupSizeShift = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the X quantization matrix scale.
+    /// </summary>
+    public uint XQmScale
+    {
+        get => this.xQmScale;
+        set => this.xQmScale = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the B quantization matrix scale.
+    /// </summary>
+    public uint BQmScale
+    {
+        get => this.bQmScale;
+        set => this.bQmScale = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the frame name.
+    /// </summary>
+    public string? Name
+    {
+        get => this.name;
+        set => this.name = value;
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the frame has a custom size or origin.
+    /// </summary>
+    public bool CustomSizeOrOrigin
+    {
+        get => this.customSizeOrOrigin;
+        set => this.customSizeOrOrigin = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the frame size.
+    /// </summary>
+    public Size FrameSize
+    {
+        get => this.frameSize;
+        set => this.frameSize = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the upsampling factor.
+    /// </summary>
+    public uint Upsampling
+    {
+        get => this.upsampling;
+        set => this.upsampling = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the upsampling factors for extra channels.
+    /// </summary>
+    public List<uint> ExtraChannelUpsampling
+    {
+        get => this.extraChannelUpsampling;
+        set => this.extraChannelUpsampling = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the frame origin point.
+    /// </summary>
+    public Point FrameOrigin
+    {
+        get => this.frameOrigin;
+        set => this.frameOrigin = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the blending information for the frame.
+    /// </summary>
+    public JxlBlendingInfo? BlendingInfo
+    {
+        get => this.blendingInfo;
+        set => this.blendingInfo = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the blending information for extra channels.
+    /// </summary>
+    public List<JxlBlendingInfo> ExtraChannelBlendingInfo
+    {
+        get => this.extraChannelBlendingInfo;
+        set => this.extraChannelBlendingInfo = value;
+    }
+
+    /// <summary>
+    /// Gets the associated animation frame, if any.
+    /// </summary>
+    public JxlAnimationFrame? AnimationFrame => this.animationFrame;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether this is the last frame.
+    /// </summary>
+    public bool IsLast
+    {
+        get => this.isLast;
+        set => this.isLast = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the reference frame index to save.
+    /// </summary>
+    public uint SaveAsReference
+    {
+        get => this.saveAsReference;
+        set => this.saveAsReference = value;
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to save before color transform.
+    /// </summary>
+    public bool SaveBeforeColorTransform
+    {
+        get => this.saveBeforeColorTransform;
+        set => this.saveBeforeColorTransform = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the DC level of the frame.
+    /// </summary>
+    public uint DcLevel
+    {
+        get => this.dcLevel;
+        set => this.dcLevel = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the codec metadata.
+    /// </summary>
+    public JxlCodecMetadata? Metadata
+    {
+        get => this.metadata;
+        set => this.metadata = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the loop filter applied to the frame.
+    /// </summary>
+    public JxlLoopFilter? LoopFilter
+    {
+        get => this.loopFilter;
+        set => this.loopFilter = value;
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether this is a preview frame. Non-serialized.
+    /// </summary>
+    public bool IsPreviewFrame
+    {
+        get => this.isPreviewFrame;
+        set => this.isPreviewFrame = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the number of extensions.
+    /// </summary>
+    public ulong Extensions
+    {
+        get => this.extensions;
+        set => this.extensions = value;
+    }
+
+    public int DefaultXSize
+    {
+        get
+        {
+            if (this.metadata == null)
+            {
+                return 0;
+            }
+
+            if (this.isPreviewFrame)
+            {
+                return this.metadata.ImageMetadata?.PreviewSize?.XSize ?? 0;
+            }
+
+            return this.metadata.XSize;
+        }
+    }
+
+    public int DefaultYSize
+    {
+        get
+        {
+            if (this.metadata == null)
+            {
+                return 0;
+            }
+
+            if (this.isPreviewFrame)
+            {
+                return this.metadata.ImageMetadata?.PreviewSize?.YSize ?? 0;
+            }
+
+            return this.metadata.YSize;
+        }
+    }
+
+    public JxlFrameDimensions FrameDimensions
+    {
+        get
+        {
+            int xsize = this.DefaultXSize;
+            int ysize = this.DefaultYSize;
+
+            xsize = this.frameSize.Width != 0 ? this.frameSize.Width : xsize;
+            ysize = this.frameSize.Height != 0 ? this.frameSize.Height : ysize;
+
+            if (this.dcLevel != 0)
+            {
+                xsize = JxlMath.DivCeil(xsize, 1 << (3 * (int)this.dcLevel));
+                ysize = JxlMath.DivCeil(ysize, 1 << (3 * (int)this.dcLevel));
+            }
+
+            JxlFrameDimensions frameDim = new(
+                xsize,
+                ysize,
+                (int)this.groupSizeShift,
+                this.chromaSubsampling?.MaxHShift ?? 0,
+                this.chromaSubsampling?.MaxVShift ?? 0,
+                this.encoding == JxlFrameEncoding.Modular,
+                (int)this.upsampling);
+
+            return frameDim;
+        }
+    }
+
+    public bool NeedsColorTransform => !this.saveBeforeColorTransform ||
+                this.frameType == JxlFrameType.RegularFrame ||
+                this.frameType == JxlFrameType.SkipProgressive;
+
+    /// <summary>
+    /// Gets a value indicating whether this frame is supposed to be saved for future usage by other frames.
+    /// </summary>
+    public bool CanBeReferenced => // DC frames cannot be referenced. The last frame cannot be referenced.
+                                   // A duration 0 frame makes little sense if it is not referenced.
+                                   // A non-duration 0 frame may or may not be referenced.
+                                   !this.isLast &&
+                                       this.frameType != JxlFrameType.DcFrame &&
+                                       (this.animationFrame?.Duration == 0 || this.saveAsReference != 0);
+
+    private void UpdateFlag(bool condition, ulong flag)
+    {
+        if (condition)
+        {
+            this.flags |= flag;
+        }
+        else
+        {
+            this.flags &= ~flag;
+        }
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        bool allDefault = false;
+        if (visitor.AllDefault(this, ref allDefault))
+        {
+            visitor.SetDefault(this);
+            return true;
+        }
+
+        if (!VisitFrameType(visitor, JxlFrameType.RegularFrame, ref this.frameType))
+        {
+            return false;
+        }
+
+        if (visitor.IsReading && this.isPreviewFrame && this.frameType != JxlFrameType.RegularFrame)
+        {
+            throw new InvalidOperationException("Only regular frame could be a preview");
+        }
+
+        // FrameEncoding
+        bool isModular = this.encoding == JxlFrameEncoding.Modular;
+        if (!visitor.Boolean(false, ref isModular))
+        {
+            return false;
+        }
+
+        this.encoding = isModular
+            ? JxlFrameEncoding.Modular
+            : JxlFrameEncoding.VarDct;
+
+        // Flags
+        if (!visitor.U64(0, ref this.flags))
+        {
+            return false;
+        }
+
+        // Color transform
+        bool xybEncoded = this.metadata?.ImageMetadata?.XybEncoded == true;
+        if (xybEncoded)
+        {
+            this.colorTransform = JxlColorTransform.Xyb;
+        }
+        else
+        {
+            bool alternate = this.colorTransform == JxlColorTransform.YCbCr;
+            if (!visitor.Boolean(false, ref alternate))
+            {
+                return false;
+            }
+
+            this.colorTransform = alternate
+                ? JxlColorTransform.YCbCr
+                : JxlColorTransform.None;
+        }
+
+        // Chroma subsampling
+        if (visitor.Conditional(this.colorTransform == JxlColorTransform.YCbCr &&
+                                ((this.flags & (ulong)JxlFrameHeaderFlags.Dc) == 0)))
+        {
+            if (!visitor.VisitNested(this.chromaSubsampling!))
+            {
+                return false;
+            }
+        }
+
+        int numExtraChannels = this.metadata?.ImageMetadata?.ExtraChannelCount ?? 0;
+
+        // Upsampling
+        if (visitor.Conditional((this.flags & (ulong)JxlFrameHeaderFlags.Dc) == 0))
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.Value(4),
+                JxlFieldExpressions.Value(8),
+                1,
+                ref this.upsampling))
+            {
+                return false;
+            }
+
+            if (this.metadata != null && visitor.Conditional(numExtraChannels != 0))
+            {
+                List<JxlExtraChannelInfo> extraChannels = this.metadata!.ImageMetadata?.ExtraChannels ?? [];
+                this.extraChannelUpsampling = new List<uint>(extraChannels.Count);
+
+                for (int i = 0; i < extraChannels.Count; i++)
+                {
+                    uint dimShift = (uint)extraChannels[i].DimensionShift;
+                    uint ecUpsampling = 1;
+                    ecUpsampling >>= (int)dimShift;
+
+                    if (!visitor.U32(
+                        JxlFieldExpressions.Value(1),
+                        JxlFieldExpressions.Value(2),
+                        JxlFieldExpressions.Value(4),
+                        JxlFieldExpressions.Value(8),
+                        1,
+                        ref ecUpsampling))
+                    {
+                        return false;
+                    }
+
+                    ecUpsampling <<= (int)dimShift;
+
+                    if (ecUpsampling < this.upsampling)
+                    {
+                        throw new InvalidOperationException("EC upsampling < color upsampling, invalid");
+                    }
+
+                    if (ecUpsampling > 8)
+                    {
+                        throw new InvalidOperationException("EC upsampling too large");
+                    }
+
+                    this.extraChannelUpsampling.Add(ecUpsampling);
+                }
+            }
+            else
+            {
+                this.extraChannelUpsampling.Clear();
+            }
+        }
+
+        // Modular / VarDCT specifics
+        if (visitor.Conditional(this.encoding == JxlFrameEncoding.Modular))
+        {
+            if (!visitor.Bits(2, 1, ref this.groupSizeShift))
+            {
+                return false;
+            }
+        }
+
+        if (visitor.Conditional(this.encoding == JxlFrameEncoding.VarDct &&
+                                this.colorTransform == JxlColorTransform.Xyb))
+        {
+            if (!visitor.Bits(3, 3, ref this.xQmScale))
+            {
+                return false;
+            }
+
+            if (!visitor.Bits(3, 2, ref this.bQmScale))
+            {
+                return false;
+            }
+        }
+        else
+        {
+            this.xQmScale = this.bQmScale = 2;
+        }
+
+        // Passes
+        if (visitor.Conditional(this.frameType != JxlFrameType.ReferenceOnly))
+        {
+            if (!visitor.VisitNested(this.passes))
+            {
+                return false;
+            }
+        }
+
+        // DC frame
+        if (visitor.Conditional(this.frameType == JxlFrameType.DcFrame))
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.Value(3),
+                JxlFieldExpressions.Value(4),
+                1,
+                ref this.dcLevel))
+            {
+                return false;
+            }
+        }
+        else
+        {
+            this.dcLevel = 0;
+        }
+
+        // Custom size/origin
+        bool isPartialFrame = false;
+
+        if (visitor.Conditional(this.frameType != JxlFrameType.DcFrame))
+        {
+            if (!visitor.Boolean(false, ref this.customSizeOrOrigin))
+            {
+                return false;
+            }
+
+            if (visitor.Conditional(this.customSizeOrOrigin))
+            {
+                JxlU32Enc enc = new(
+                    JxlFieldExpressions.Bits(8),
+                    JxlFieldExpressions.BitsOffset(11, 256),
+                    JxlFieldExpressions.BitsOffset(14, 2304),
+                    JxlFieldExpressions.BitsOffset(30, 18688));
+
+                if (visitor.Conditional(this.frameType is JxlFrameType.RegularFrame or JxlFrameType.SkipProgressive))
+                {
+                    uint ux0 = JxlPackSigned.PackUnsigned(this.frameOrigin.X);
+                    uint uy0 = JxlPackSigned.PackUnsigned(this.frameOrigin.Y);
+
+                    if (!visitor.U32(enc, 0, ref ux0))
+                    {
+                        return false;
+                    }
+
+                    if (!visitor.U32(enc, 0, ref uy0))
+                    {
+                        return false;
+                    }
+
+                    this.frameOrigin = new Point(JxlPackSigned.UnpackSigned(ux0), JxlPackSigned.UnpackSigned(uy0));
+                }
+
+                uint frameSizeWidth = (uint)this.frameSize.Width;
+                uint frameSizeHeight = (uint)this.frameSize.Height;
+
+                if (!visitor.U32(enc, 0, ref frameSizeWidth))
+                {
+                    return false;
+                }
+
+                if (!visitor.U32(enc, 0, ref frameSizeHeight))
+                {
+                    return false;
+                }
+
+                if (this.customSizeOrOrigin && (this.frameSize.Width == 0 || this.frameSize.Height == 0))
+                {
+                    throw new InvalidOperationException("Invalid crop dimensions for frame");
+                }
+
+                int imageXSize = this.DefaultXSize;
+                int imageYSize = this.DefaultYSize;
+
+                if (this.frameType is JxlFrameType.RegularFrame or JxlFrameType.SkipProgressive)
+                {
+                    isPartialFrame |= this.frameOrigin.X > 0;
+                    isPartialFrame |= this.frameOrigin.Y > 0;
+                    isPartialFrame |= (this.frameSize.Width + this.frameOrigin.X) < imageXSize;
+                    isPartialFrame |= (this.frameSize.Height + this.frameOrigin.Y) < imageYSize;
+                }
+            }
+        }
+
+        // Blending, animation, last frame
+        if (visitor.Conditional(this.frameType is JxlFrameType.RegularFrame or JxlFrameType.SkipProgressive))
+        {
+            this.blendingInfo!.ExtraChannelCount = numExtraChannels;
+            this.blendingInfo.IsPartialFrame = isPartialFrame;
+
+            if (!visitor.VisitNested(this.blendingInfo))
+            {
+                return false;
+            }
+
+            bool replaceAll = this.blendingInfo.BlendMode == JxlBlendMode.Replace;
+
+            this.extraChannelBlendingInfo = new List<JxlBlendingInfo>(numExtraChannels);
+            for (int i = 0; i < numExtraChannels; i++)
+            {
+                JxlBlendingInfo ecBlendingInfo = new()
+                {
+                    IsPartialFrame = isPartialFrame,
+                    ExtraChannelCount = numExtraChannels
+                };
+
+                if (!visitor.VisitNested(ecBlendingInfo))
+                {
+                    return false;
+                }
+
+                this.extraChannelBlendingInfo.Add(ecBlendingInfo);
+                replaceAll &= ecBlendingInfo.BlendMode == JxlBlendMode.Replace;
+            }
+
+            if (visitor.IsReading && this.isPreviewFrame)
+            {
+                if (!replaceAll || this.customSizeOrOrigin)
+                {
+                    throw new InvalidOperationException("Preview is not compatible with blending");
+                }
+            }
+
+            if (visitor.Conditional(this.metadata?.ImageMetadata?.HaveAnimation == true))
+            {
+                this.animationFrame!.CodecMetadata = this.metadata;
+
+                if (!visitor.VisitNested(this.animationFrame!))
+                {
+                    return false;
+                }
+            }
+
+            if (!visitor.Boolean(true, ref this.isLast))
+            {
+                return false;
+            }
+        }
+        else
+        {
+            this.isLast = false;
+        }
+
+        // SaveAsReference
+        if (visitor.Conditional(this.frameType != JxlFrameType.DcFrame && !this.isLast))
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.Value(3),
+                0,
+                ref this.saveAsReference))
+            {
+                return false;
+            }
+        }
+
+        // SaveBeforeColorTransform logic
+        if (this.frameType != JxlFrameType.DcFrame)
+        {
+            if (visitor.Conditional(
+                this.CanBeReferenced &&
+                this.blendingInfo?.BlendMode == JxlBlendMode.Replace &&
+                !isPartialFrame &&
+                (this.frameType == JxlFrameType.RegularFrame ||
+                this.frameType == JxlFrameType.SkipProgressive)))
+            {
+                if (!visitor.Boolean(false, ref this.saveBeforeColorTransform))
+                {
+                    return false;
+                }
+            }
+            else if (visitor.Conditional(this.frameType == JxlFrameType.ReferenceOnly))
+            {
+                if (!visitor.Boolean(true, ref this.saveBeforeColorTransform))
+                {
+                    return false;
+                }
+
+                int xsize = this.customSizeOrOrigin
+                    ? this.frameSize.Width
+                    : this.metadata!.XSize;
+
+                int ysize = this.customSizeOrOrigin
+                    ? this.frameSize.Height
+                    : this.metadata!.YSize;
+
+                if (!this.saveBeforeColorTransform &&
+                    (xsize < this.metadata!.XSize ||
+                    ysize < this.metadata!.YSize ||
+                    this.frameOrigin.X != 0 ||
+                    this.frameOrigin.Y != 0))
+                {
+                    throw new InvalidOperationException("Non-patch reference frame with invalid crop");
+                }
+            }
+        }
+        else
+        {
+            this.saveBeforeColorTransform = true;
+        }
+
+        if (!VisitNameString(visitor, ref this.name))
+        {
+            return false;
+        }
+
+        this.loopFilter!.IsModular = isModular;
+        if (!visitor.VisitNested(this.loopFilter!))
+        {
+            return false;
+        }
+
+        if (!visitor.BeginExtensions(ref this.extensions))
+        {
+            return false;
+        }
+
+        return visitor.EndExtensions();
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameHeaderFlags.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameHeaderFlags.cs
new file mode 100644
index 0000000000..098bcb57fc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameHeaderFlags.cs
@@ -0,0 +1,36 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Optional steps for postprocessing. These flags are the
+/// source of truth. Override must set/clear them rather than
+/// change their meaning. Values chosen such that typical flags
+/// are 0, encoded in only two bits.
+/// </summary>
+[Flags]
+internal enum JxlFrameHeaderFlags : byte
+{
+    /// <summary>
+    /// Noise is injected into decoded output.
+    /// </summary>
+    Noise = 1,
+
+    /// <summary>
+    /// Overlay patches.
+    /// </summary>
+    Patches = 2,
+
+    /// <summary>
+    /// Overlay splines.
+    /// </summary>
+    Splines = 16,
+
+    /// <summary>
+    /// Implies skip adaptive DC smoothing.
+    /// </summary>
+    Dc = 32,
+
+    SkipAdaptiveDcSmoothing = 128,
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameType.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameType.cs
new file mode 100644
index 0000000000..6aa73eab26
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlFrameType.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Defines the type of a JPEG XL frame.
+/// </summary>
+internal enum JxlFrameType : byte
+{
+    /// <summary>
+    /// A regular frame. It might be a crop, and it will be blended
+    /// on a previous frame (if any) and likely displayed or blended in
+    /// future frames.
+    /// </summary>
+    RegularFrame,
+
+    /// <summary>
+    /// A DC frame. It is downsampled and only used as the DC
+    /// of a future and, possibly, preview frame. This cannot be cropped,
+    /// blended, or referenced by patches or blending modes. Frames using
+    /// DC cannot have non-default sizes.
+    /// </summary>
+    DcFrame,
+
+    /// <summary>
+    /// A PatchesSource frame. Can only be used as source frame for
+    /// taking patches. It can be cropped but can't have a non-(0, 0) x0/y0.
+    /// </summary>
+    ReferenceOnly = 2,
+
+    /// <summary>
+    /// Same as regular frame but not used for progressive rendering.
+    /// Implies no early display of DC.
+    /// </summary>
+    SkipProgressive,
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlPasses.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlPasses.cs
new file mode 100644
index 0000000000..87277414ac
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlPasses.cs
@@ -0,0 +1,220 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Used for decoding to lower resolutions.
+/// </summary>
+internal sealed class JxlPasses : IJxlFields
+{
+    /// <summary>
+    /// Defines the maximum amount of passes, which is 11.
+    /// </summary>
+    private const int MaxPasses = 11;
+
+    private uint numPasses;
+    private uint numDownsample;
+
+    /// <summary>
+    /// Gets or sets the number of passes.
+    /// </summary>
+    public uint NumberOfPasses
+    {
+        get => this.numPasses;
+        set => this.numPasses = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the number of downsamples.
+    /// </summary>
+    public uint NumberOfDownsamples
+    {
+        get => this.numDownsample;
+        set => this.numDownsample = value;
+    }
+
+    /// <summary>
+    /// Gets the downsample values.
+    /// </summary>
+    public uint[] Downsample { get; } = new uint[MaxPasses];
+
+    /// <summary>
+    /// Gets the last pass values.
+    /// </summary>
+    public uint[] LastPass { get; } = new uint[MaxPasses];
+
+    /// <summary>
+    /// Gets the shift values.
+    /// </summary>
+    public uint[] Shift { get; } = new uint[MaxPasses];
+
+    public void GetDownsamplingBracket(int pass, out int minShift, out int maxShift)
+    {
+        maxShift = 2;
+        minShift = 3;
+
+        for (int i = 0; ; i++)
+        {
+            for (int j = 0; j < this.numDownsample; ++j)
+            {
+                if (i == this.LastPass[j])
+                {
+                    uint ds = this.Downsample[j];
+
+                    if (ds == 8)
+                    {
+                        minShift = 3;
+                    }
+
+                    if (ds == 4)
+                    {
+                        minShift = 2;
+                    }
+
+                    if (ds == 2)
+                    {
+                        minShift = 1;
+                    }
+
+                    if (ds == 1)
+                    {
+                        minShift = 0;
+                    }
+                }
+            }
+
+            if (i == this.numPasses - 1)
+            {
+                minShift = 0;
+            }
+
+            if (i == pass)
+            {
+                return;
+            }
+
+            maxShift = minShift - 1;
+        }
+    }
+
+    public uint GetDownsamplingTargetForCompletedPasses(int num)
+    {
+        if (num >= this.numPasses)
+        {
+            return 1;
+        }
+
+        uint result = 0;
+
+        for (int i = 0; i < this.numDownsample; i++)
+        {
+            if (num > this.LastPass[i])
+            {
+                result = Math.Min(result, this.Downsample[i]);
+            }
+        }
+
+        return result;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (visitor.U32(
+            JxlFieldExpressions.Value(1),
+            JxlFieldExpressions.Value(2),
+            JxlFieldExpressions.Value(2),
+            JxlFieldExpressions.BitsOffset(1, 3),
+            0,
+            ref this.numPasses))
+        {
+            return false;
+        }
+
+        if (this.numPasses > MaxPasses)
+        {
+            return false;
+        }
+
+        if (visitor.Conditional(this.numPasses != 1))
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.BitsOffset(1, 3),
+                0,
+                ref this.numDownsample))
+            {
+                return false;
+            }
+
+            if (this.numDownsample > 4)
+            {
+                return false;
+            }
+
+            if (this.numDownsample > this.numPasses)
+            {
+                throw new InvalidOperationException("Number of downsaples is greater than number of passes");
+            }
+
+            for (int i = 0; i < this.numPasses - 1; i++)
+            {
+                if (!visitor.Bits(2, 0u, ref this.Shift[i]))
+                {
+                    return false;
+                }
+            }
+
+            this.Shift[this.numPasses - 1] = 0;
+
+            for (int i = 0; i < this.numDownsample; i++)
+            {
+                if (!visitor.U32(
+                    JxlFieldExpressions.Value(1),
+                    JxlFieldExpressions.Value(2),
+                    JxlFieldExpressions.Value(4),
+                    JxlFieldExpressions.Value(8),
+                    1,
+                    ref this.Downsample[i]))
+                {
+                    return false;
+                }
+
+                if (i > 0 && this.Downsample[i] >= this.Downsample[i - 1])
+                {
+                    throw new InvalidOperationException("Downsample sequence should decrease");
+                }
+            }
+
+            for (int i = 0; i < this.numDownsample; i++)
+            {
+                if (!visitor.U32(
+                    JxlFieldExpressions.Value(0),
+                    JxlFieldExpressions.Value(1),
+                    JxlFieldExpressions.Value(2),
+                    JxlFieldExpressions.Value(3),
+                    0,
+                    ref this.LastPass[i]))
+                {
+                    return false;
+                }
+
+                if (i > 0 && this.LastPass[i] <= this.LastPass[i - 1])
+                {
+                    throw new InvalidOperationException("Last pass sequence should increase");
+                }
+
+                if (this.LastPass[i] >= this.numPasses)
+                {
+                    throw new InvalidOperationException("Last pass is greater than number of passes");
+                }
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlYCbCrChromaSubsampling.cs b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlYCbCrChromaSubsampling.cs
new file mode 100644
index 0000000000..b10d8818aa
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/FrameHeader/JxlYCbCrChromaSubsampling.cs
@@ -0,0 +1,147 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+
+/// <summary>
+/// Gets the Y'Cb'Cr chroma subsampling information as part
+/// of the JPEG XL Frame Header.
+/// </summary>
+internal sealed class JxlYCbCrChromaSubsampling : IJxlFields
+{
+    private readonly int[] channelMode = new int[3];
+
+    private static ReadOnlySpan<byte> HShiftData => [0, 1, 1, 0];
+
+    private static ReadOnlySpan<byte> VShiftData => [0, 1, 0, 1];
+
+    public byte MaxHShift { get; private set; }
+
+    public byte MaxVShift { get; private set; }
+
+    /// <summary>
+    /// Gets a value indicating whether this 4:4:4 chroma subsampling.
+    /// </summary>
+    public bool Is444 =>
+            this.HShift(0) == 0 && this.VShift(0) == 0 && // Cb
+            this.HShift(2) == 0 && this.VShift(2) == 0 && // Cr
+            this.HShift(1) == 0 && this.VShift(1) == 0;   // Y;
+
+    /// <summary>
+    /// Gets a value indicating whether this 4:2:0 chroma subsampling.
+    /// </summary>
+    public bool Is420 =>
+            this.HShift(0) == 1 && this.VShift(0) == 1 && // Cb
+            this.HShift(2) == 1 && this.VShift(2) == 1 && // Cr
+            this.HShift(1) == 0 && this.VShift(1) == 0;   // Y
+
+    /// <summary>
+    /// Gets a value indicating whether this 4:2:2 chroma subsampling.
+    /// </summary>
+    public bool Is422 =>
+            this.HShift(0) == 1 && this.VShift(0) == 0 && // Cb
+            this.HShift(2) == 1 && this.VShift(2) == 0 && // Cr
+            this.HShift(1) == 0 && this.VShift(1) == 0;   // Y
+
+    /// <summary>
+    /// Gets a value indicating whether this 4:4:0 chroma subsampling.
+    /// </summary>
+    public bool Is440 =>
+            this.HShift(0) == 0 && this.VShift(0) == 1 && // Cb
+            this.HShift(2) == 0 && this.VShift(2) == 1 && // Cr
+            this.HShift(1) == 0 && this.VShift(1) == 0;    // Y
+
+    public byte RawHShift(int c) => HShiftData[this.channelMode[c]];
+
+    public byte RawVShift(int c) => VShiftData[this.channelMode[c]];
+
+    public byte HShift(int c) => (byte)(this.MaxHShift - HShiftData[this.channelMode[c]]);
+
+    public byte VShift(int c) => (byte)(this.MaxVShift - VShiftData[this.channelMode[c]]);
+
+    private void Recompute()
+    {
+        this.MaxHShift = 0;
+        this.MaxVShift = 0;
+
+        for (int i = 0; i < 3; i++)
+        {
+            int ch = this.channelMode[i];
+
+            this.MaxHShift = Math.Max(this.MaxHShift, HShiftData[ch]);
+            this.MaxVShift = Math.Max(this.MaxVShift, VShiftData[ch]);
+        }
+    }
+
+    public bool Set(ReadOnlySpan<byte> hsample, ReadOnlySpan<byte> vsample)
+    {
+        for (int c = 0; c < 3; c++)
+        {
+            int cjpeg = c < 2 ? (c ^ 1) : c;
+            int i = 0;
+
+            for (; i < 4; i++)
+            {
+                if (1 << HShiftData[i] == hsample[cjpeg] && 1 << VShiftData[i] == vsample[cjpeg])
+                {
+                    this.channelMode[c] = i;
+                    break;
+                }
+            }
+
+            if (i == 4)
+            {
+                return false;
+            }
+        }
+
+        this.Recompute();
+        return true;
+    }
+
+    public override string ToString()
+    {
+        if (this.Is444)
+        {
+            return "4:4:4";
+        }
+        else if (this.Is420)
+        {
+            return "4:2:0";
+        }
+        else if (this.Is422)
+        {
+            return "4:2:2";
+        }
+        else if (this.Is440)
+        {
+            return "4:4:0";
+        }
+        else
+        {
+            return $"[Custom] {this.channelMode[0]}:{this.channelMode[1]}:{this.channelMode[2]}";
+        }
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        for (int i = 0; i < 3; i++)
+        {
+            int channel = this.channelMode[i];
+
+            uint unsignedChannel = (uint)channel;
+            bool wroteSuccessfully = visitor.Bits(2, 0, ref unsignedChannel);
+
+            if (!wroteSuccessfully)
+            {
+                return false;
+            }
+
+            this.channelMode[i] = (int)unsignedChannel;
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegAppMarkerType.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegAppMarkerType.cs
new file mode 100644
index 0000000000..15438464ee
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegAppMarkerType.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+/// <summary>
+/// Identifies the kind of APP marker in a JPEG file.
+/// </summary>
+internal enum JpegAppMarkerType : byte
+{
+    /// <summary>
+    /// Unknown APP marker
+    /// </summary>
+    Unknown,
+
+    /// <summary>
+    /// Contains ICC profile metadata
+    /// </summary>
+    Icc,
+
+    /// <summary>
+    /// Contains EXIF profile metadata
+    /// </summary>
+    Exif,
+
+    /// <summary>
+    /// Contains XMP profile metadata
+    /// </summary>
+    Xmp
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponent.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponent.cs
new file mode 100644
index 0000000000..297acacc0a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponent.cs
@@ -0,0 +1,53 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+// We may need to get a ref to fields, so don't
+// make these properties.
+#pragma warning disable SA1401 // Fields should be private
+
+/// <summary>
+/// Represents one component of a jpeg file.
+/// </summary>
+internal sealed class JpegComponent
+{
+    /// <summary>
+    /// One-byte id of the component
+    /// </summary>
+    public int Id;
+
+    /// <summary>
+    /// In interleaved mode, each minimal coded unit (MCU)
+    /// has horizontal x vertical sample factor DCT blocks
+    /// from this component. This is the horizontal factor.
+    /// </summary>
+    public int HorizontalSampleFactor = 1;
+
+    /// <summary>
+    /// In interleaved mode, each minimal coded unit (MCU)
+    /// has horizontal x vertical sample factor DCT blocks
+    /// from this component. This is the vertical factor.
+    /// </summary>
+    public int VerticalSampleFactor = 1;
+
+    /// <summary>
+    /// Index of quantization table used for this component.
+    /// </summary>
+    public int QuantIndex;
+
+    /// <summary>
+    /// Width measured in 8x8 blocks
+    /// </summary>
+    public int WidthInBlocks;
+
+    /// <summary>
+    /// Width measured in 8x8 blocks
+    /// </summary>
+    public int HeightInBlocks;
+
+    /// <summary>
+    /// Gets or sets DCT coefficients.
+    /// </summary>
+    public List<int> Coefficients { get; set; } = [];
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponentScanInfo.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponentScanInfo.cs
new file mode 100644
index 0000000000..1a3ba3707b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponentScanInfo.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+/// <summary>
+/// Huffman table indexes used for one component of one scan.
+/// </summary>
+// We may need to get a ref to fields, so don't
+// make these properties.
+internal struct JpegComponentScanInfo
+{
+    public int ComponentIndex;
+    public int DcTableIndex;
+    public int AcTableIndex;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponentType.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponentType.cs
new file mode 100644
index 0000000000..adf5940c6e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegComponentType.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+internal enum JpegComponentType : byte
+{
+    Gray,
+
+    YCbCr,
+
+    Rgb,
+
+    Custom
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegData.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegData.cs
new file mode 100644
index 0000000000..4555442bcb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegData.cs
@@ -0,0 +1,1004 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+internal sealed class JpegData : IJxlFields
+{
+    private int restartInterval;
+    private bool hasZeroPaddingBit;
+
+    public int Width { get; set; }
+
+    public int Height { get; set; }
+
+    public int RestartInterval
+    {
+        get => this.restartInterval;
+        set => this.restartInterval = value;
+    }
+
+    public bool HasZeroPaddingBit
+    {
+        get => this.hasZeroPaddingBit;
+        set => this.hasZeroPaddingBit = value;
+    }
+
+    /// <summary>
+    /// Gets or sets raw bytes of APP markers. Types
+    /// of APP markers are specified by <see cref="AppMarkerTypes"/>.
+    /// </summary>
+    public List<List<byte>> AppData { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets kinds of APP markers for each marker data
+    /// within <see cref="AppData"/>.
+    /// </summary>
+    public List<JpegAppMarkerType> AppMarkerTypes { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets raw bytes of COM markers.
+    /// </summary>
+    public List<List<byte>> ComData { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets quantization tables.
+    /// </summary>
+    public List<JpegQuantizationTable> Quant { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets definitions of Huffman codes.
+    /// </summary>
+    public List<JpegHuffmanCode> HuffmanCodes { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets JPEG components.
+    /// </summary>
+    public List<JpegComponent> Components { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets scan infos.
+    /// </summary>
+    public List<JpegScanInfo> ScanInfos { get; set; } = [];
+
+    public List<byte> MarkerOrder { get; set; } = [];
+
+    public List<List<byte>> InterMarkerData { get; set; } = [];
+
+    public List<byte> TailData { get; set; } = [];
+
+    public List<byte> PaddingBits { get; set; } = [];
+
+    public void CalculateMcuSize(JpegScanInfo scan, out int mcusPerRow, out int mcuRows)
+    {
+        bool isInterleaved = scan.NumComponents > 1;
+        JpegComponent baseComponent = this.Components[scan.Components[0].ComponentIndex];
+
+        int horizontalGroup = isInterleaved ? 1 : baseComponent.HorizontalSampleFactor;
+        int verticalGroup = isInterleaved ? 1 : baseComponent.VerticalSampleFactor;
+
+        int maxHSampFactor = 1;
+        int maxVSampFactor = 1;
+
+        foreach (JpegComponent component in this.Components)
+        {
+            maxHSampFactor = Math.Max(component.HorizontalSampleFactor, maxHSampFactor);
+            maxVSampFactor = Math.Max(component.VerticalSampleFactor, maxVSampFactor);
+        }
+
+        mcusPerRow = JxlMath.DivCeil(this.Width * horizontalGroup, 8 * maxHSampFactor);
+        mcuRows = JxlMath.DivCeil(this.Height * verticalGroup, 8 * maxVSampFactor);
+    }
+
+    public static void SetJpegDataFromIcc(Span<byte> icc, JpegData jpegData)
+    {
+        int iccPos = 0;
+
+        for (int i = 0; i < jpegData.AppData.Count; i++)
+        {
+            if (jpegData.AppMarkerTypes[i] != JpegAppMarkerType.Icc)
+            {
+                continue;
+            }
+
+            if (jpegData.AppData[i].Count < 17)
+            {
+                throw new InvalidOperationException("ICC APP marker too small: " + jpegData.AppData[i].Count);
+            }
+
+            int len = jpegData.AppData[i].Count - 17;
+            if (iccPos > icc.Length - len)
+            {
+                throw new InvalidOperationException("ICC length is less than APP markers: requested " + len + " more bytes, " + (icc.Length - iccPos) + " available");
+            }
+
+            icc.Slice(iccPos, len).CopyTo(CollectionsMarshal.AsSpan(jpegData.AppData[i])[17..]);
+            iccPos += len;
+        }
+
+        if (iccPos != icc.Length && iccPos != 0)
+        {
+            throw new InvalidOperationException("ICC length > APP markers");
+        }
+    }
+
+    private static bool VisitMarker(ref byte marker, JxlVisitor visitor, ref JpegInfo info)
+    {
+        uint marker32 = marker - 0xC0u;
+
+        if (!visitor.Bits(6, 0x00, ref marker32))
+        {
+            return false;
+        }
+
+        marker = (byte)(marker32 + 0xC0u);
+
+        if ((marker & 0xf0) == 0xe0)
+        {
+            info.NumberOfAppMarkers++;
+        }
+
+        switch (marker)
+        {
+            case 0xFE:
+                info.NumberOfComMarkers++;
+                break;
+
+            case 0xDA:
+                info.NumberOfScans++;
+                break;
+
+            case 0xFF:
+                info.NumberOfIntermarkers++;
+                break;
+
+            case 0xDD:
+                info.HasDri = true;
+                break;
+        }
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public bool Visit(JxlVisitor visitor)
+    {
+        // The following is just JPEG parsing/writing code.
+        // Nothing different.
+        bool isGray = this.Components.Count == 1;
+
+        if (!visitor.Boolean(false, ref isGray))
+        {
+            return false;
+        }
+
+        if (visitor.IsReading)
+        {
+            this.Components = new List<JpegComponent>(isGray ? 1 : 3);
+        }
+
+        JpegInfo info = default;
+
+        if (visitor.IsReading)
+        {
+            byte marker = 0xC0;
+
+            do
+            {
+                if (!VisitMarker(ref marker, visitor, ref info))
+                {
+                    return false;
+                }
+
+                this.MarkerOrder.Add(marker);
+
+                if (this.MarkerOrder.Count > 16384)
+                {
+                    throw new InvalidOperationException("Too many markers: " + this.MarkerOrder.Count);
+                }
+            }
+            while (marker != 0xD9);
+        }
+        else
+        {
+            if (this.MarkerOrder.Count > 16384)
+            {
+                throw new InvalidOperationException("Too many markers: " + this.MarkerOrder.Count);
+            }
+
+            Span<byte> markerData = CollectionsMarshal.AsSpan(this.MarkerOrder);
+
+            for (int i = 0; i < markerData.Length; i++)
+            {
+                ref byte marker = ref markerData[i];
+
+                if (!VisitMarker(ref marker, visitor, ref info))
+                {
+                    return false;
+                }
+            }
+
+            if (this.MarkerOrder.Count > 0)
+            {
+                if (this.MarkerOrder[^1] != 0xD9)
+                {
+                    throw new InvalidOperationException("Last marker should always be EOI (0xD9) marker");
+                }
+            }
+        }
+
+        if (info.NumberOfScans == 0)
+        {
+            throw new InvalidOperationException("No JPEG scans");
+        }
+
+        if (visitor.IsReading)
+        {
+            this.AppData = new List<List<byte>>(info.NumberOfAppMarkers);
+            this.AppMarkerTypes = new List<JpegAppMarkerType>(info.NumberOfAppMarkers);
+            this.ComData = new List<List<byte>>(info.NumberOfAppMarkers);
+            this.ScanInfos = new List<JpegScanInfo>(info.NumberOfAppMarkers);
+        }
+
+        if (this.AppData.Count != info.NumberOfAppMarkers ||
+            this.AppMarkerTypes.Count != info.NumberOfAppMarkers ||
+            this.ComData.Count != info.NumberOfComMarkers ||
+            this.ScanInfos.Count != info.NumberOfScans)
+        {
+            throw new InvalidOperationException("Mismatch between number of APP markers and the actual APP marker count");
+        }
+
+        for (int i = 0; i < this.AppData.Count; i++)
+        {
+            uint uMarkerType = (uint)this.AppMarkerTypes[i];
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.BitsOffset(1, 2),
+                JxlFieldExpressions.BitsOffset(2, 4),
+                0,
+                ref uMarkerType))
+            {
+                return false;
+            }
+
+            this.AppMarkerTypes[i] = (JpegAppMarkerType)uMarkerType;
+
+            if (this.AppMarkerTypes[i] is not JpegAppMarkerType.Unknown and
+                not JpegAppMarkerType.Icc and
+                not JpegAppMarkerType.Exif and
+                not JpegAppMarkerType.Xmp)
+            {
+                throw new InvalidOperationException("Unknown APP marker type: " + (uint)this.AppMarkerTypes[i]);
+            }
+
+            uint len = (uint)this.AppMarkerTypes.Count - 1;
+            if (!visitor.Bits(16, 0, ref len))
+            {
+                return false;
+            }
+
+            if (visitor.IsReading)
+            {
+                this.AppData[i] = new List<byte>((int)len + 1);
+                if (len + 1 < 3)
+                {
+                    throw new InvalidOperationException("Marker size is invalid");
+                }
+            }
+
+            if (len + 1 < 3)
+            {
+                throw new InvalidOperationException("Marker size is invalid");
+            }
+        }
+
+        for (int i = 0; i < this.ComData.Count; i++)
+        {
+            List<byte> com = this.ComData[i];
+
+            uint len = (uint)com.Count - 1;
+
+            if (!visitor.Bits(16, 0, ref len))
+            {
+                return false;
+            }
+
+            if (len + 1 < 3)
+            {
+                throw new InvalidOperationException("Marker size is invalid");
+            }
+
+            if (visitor.IsReading)
+            {
+                this.ComData[i] = new List<byte>((int)len + 1);
+
+                if (len + 1 < 3)
+                {
+                    throw new InvalidOperationException("Marker size is invalid");
+                }
+            }
+
+            if (len + 1 < 3)
+            {
+                throw new InvalidOperationException("Marker size is invalid");
+            }
+        }
+
+        uint numQuantTables = (uint)this.Quant.Count;
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value(1),
+            JxlFieldExpressions.Value(2),
+            JxlFieldExpressions.Value(3),
+            JxlFieldExpressions.Value(4),
+            2,
+            ref numQuantTables))
+        {
+            return false;
+        }
+
+        if (numQuantTables == 4)
+        {
+            throw new InvalidOperationException("Invalid number of quant tables");
+        }
+
+        if (visitor.IsReading)
+        {
+            this.Quant = new List<JpegQuantizationTable>((int)numQuantTables);
+        }
+
+        Span<JpegQuantizationTable> quantSpan = CollectionsMarshal.AsSpan(this.Quant);
+
+        for (int i = 0; i < numQuantTables; i++)
+        {
+            ref JpegQuantizationTable quant = ref quantSpan[i];
+
+            if (quant.Precision > 1)
+            {
+                throw new InvalidOperationException("Quant tables with more than 16 bits are not supported");
+            }
+
+            if (!visitor.Bits(1, 0, ref Unsafe.As<int, uint>(ref quant.Precision)))
+            {
+                return false;
+            }
+
+            if (!visitor.Bits(2, (uint)i, ref Unsafe.As<int, uint>(ref quant.Index)))
+            {
+                return false;
+            }
+
+            if (!visitor.Boolean(true, ref quant.IsLast))
+            {
+                return false;
+            }
+        }
+
+        Span<JpegComponent> components = CollectionsMarshal.AsSpan(this.Components);
+
+        JpegComponentType componentType =
+          components.Length == 1 && components[0].Id == 1 ? JpegComponentType.Gray
+          : components.Length == 3 && components[0].Id == 1 &&
+                  components[1].Id == 2 && components[2].Id == 3
+              ? JpegComponentType.YCbCr
+          : components.Length == 3 && components[0].Id == 'R' &&
+                  components[1].Id == 'G' && components[2].Id == 'B'
+              ? JpegComponentType.Rgb
+              : JpegComponentType.Custom;
+
+        if (visitor.Bits(2, (uint)JpegComponentType.YCbCr, ref Unsafe.As<JpegComponentType, uint>(ref componentType)))
+        {
+            return false;
+        }
+
+        uint numberOfComponents;
+
+        if (componentType == JpegComponentType.Gray)
+        {
+            numberOfComponents = 1;
+        }
+        else if (componentType != JpegComponentType.Custom)
+        {
+            numberOfComponents = 3;
+        }
+        else
+        {
+            numberOfComponents = (uint)components.Length;
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.Value(3),
+                JxlFieldExpressions.Value(4),
+                3,
+                ref numberOfComponents))
+            {
+                return false;
+            }
+
+            if (numberOfComponents is not 1 and not 3)
+            {
+                throw new InvalidOperationException("Invalid number of components: " + numberOfComponents);
+            }
+        }
+
+        if (visitor.IsReading)
+        {
+            this.Components = new List<JpegComponent>((int)numberOfComponents);
+
+            // It's unsafe to assign a new List (or add/remove items to it)
+            // while keeping a Span to it.
+            components = CollectionsMarshal.AsSpan(this.Components);
+        }
+
+        if (componentType == JpegComponentType.Custom)
+        {
+            foreach (JpegComponent component in components)
+            {
+                if (!visitor.Bits(8, 0, ref Unsafe.As<int, uint>(ref component.Id)))
+                {
+                    return false;
+                }
+            }
+        }
+        else if (componentType == JpegComponentType.Gray)
+        {
+            components[0].Id = 1;
+        }
+        else if (componentType == JpegComponentType.Rgb)
+        {
+            components[0].Id = 'R';
+            components[1].Id = 'G';
+            components[2].Id = 'B';
+        }
+        else
+        {
+            components[0].Id = 1;
+            components[1].Id = 2;
+            components[2].Id = 3;
+        }
+
+        uint usedTables = 0;
+
+        for (int i = 0; i < components.Length; i++)
+        {
+            if (!visitor.Bits(2, 0, ref Unsafe.As<int, uint>(ref components[i].QuantIndex)))
+            {
+                return false;
+            }
+
+            if (components[i].QuantIndex >= this.Quant.Count)
+            {
+                throw new InvalidOperationException("Invalid quant table for component " + components[i].QuantIndex);
+            }
+
+            usedTables |= 1u << components[i].QuantIndex;
+        }
+
+        for (int i = 0; i < this.Quant.Count; i++)
+        {
+            if ((usedTables & (1 << i)) != 0)
+            {
+                continue;
+            }
+
+            if (i == 0)
+            {
+                throw new InvalidOperationException("First quant table unused");
+            }
+
+            for (int j = 0; j < 64; j++)
+            {
+                if (this.Quant[i].Values[j] != this.Quant[i - 1].Values[j])
+                {
+                    throw new InvalidOperationException("Non-trivial unused quant table");
+                }
+            }
+        }
+
+        uint numHuff = (uint)this.HuffmanCodes.Count;
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value(4),
+            JxlFieldExpressions.BitsOffset(3, 2),
+            JxlFieldExpressions.BitsOffset(4, 10),
+            JxlFieldExpressions.BitsOffset(6, 26),
+            4,
+            ref numHuff))
+        {
+            return false;
+        }
+
+        if (visitor.IsReading)
+        {
+            this.HuffmanCodes = new List<JpegHuffmanCode>((int)numHuff);
+        }
+
+        Span<JpegHuffmanCode> huffs = CollectionsMarshal.AsSpan(this.HuffmanCodes);
+
+        for (int i = 0; i < huffs.Length; i++)
+        {
+            ref JpegHuffmanCode hc = ref huffs[i];
+
+            bool isAc = (hc.SlotId >> 4) != 0;
+            uint id = (uint)hc.SlotId & 0x0Fu;
+
+            if (!visitor.Boolean(false, ref isAc))
+            {
+                return false;
+            }
+
+            if (!visitor.Bits(2, 0, ref id))
+            {
+                return false;
+            }
+
+            hc.SlotId = ((isAc ? 1 : 0) << 4) | (int)id;
+
+            if (!visitor.Boolean(true, ref hc.IsLast))
+            {
+                return false;
+            }
+
+            int numSymbols = 0;
+
+            for (int j = 0; j <= 16; j++)
+            {
+                if (!visitor.U32(
+                    JxlFieldExpressions.Value(0),
+                    JxlFieldExpressions.Value(1),
+                    JxlFieldExpressions.BitsOffset(3, 2),
+                    JxlFieldExpressions.Bits(8),
+                    0,
+                    ref Unsafe.As<int, uint>(ref hc.Counts[j])))
+                {
+                    return false;
+                }
+
+                numSymbols += hc.Counts[j];
+            }
+
+            if (numSymbols == 0)
+            {
+                // At least 2 symbols are required, since one of them is EOI.
+                // This case is used to represent an empty DHT marker.
+                continue;
+            }
+
+            if (numSymbols > 17)
+            {
+                throw new InvalidOperationException("Huffman code too large (" + numSymbols + ")");
+            }
+
+            InlineArray5<long> valueSlots = default;
+
+            for (int j = 0; j < numSymbols; j++)
+            {
+                // Goes up to 256, included. Might have the same symbol appear twice.
+                if (!visitor.U32(
+                    JxlFieldExpressions.Bits(2),
+                    JxlFieldExpressions.BitsOffset(2, 4),
+                    JxlFieldExpressions.BitsOffset(4, 8),
+                    JxlFieldExpressions.BitsOffset(8, 1),
+                    0,
+                    ref Unsafe.As<int, uint>(ref hc.Values[j])))
+                {
+                    return false;
+                }
+
+                valueSlots[hc.Values[j] >> 6] |= 1L << (hc.Values[j] & 0x3F);
+            }
+
+            if (hc.Values[numSymbols - 1] != JpegDataConstants.JpegHuffmanAlphabetSize)
+            {
+                throw new InvalidOperationException("Missing EOI symbol");
+            }
+
+            if (valueSlots[4] != 1)
+            {
+                return false;
+            }
+
+            int numValues = 1;
+
+            for (int j = 0; j < 4; j++)
+            {
+                numValues += BitOperations.PopCount((uint)valueSlots[i]);
+            }
+
+            if (numValues != numSymbols)
+            {
+                throw new InvalidOperationException("Duplicate Huffman symbols");
+            }
+
+            if (!isAc)
+            {
+                bool onlyDC = ((valueSlots[0] >> JpegDataConstants.JpegDcAlphabetSize) | valueSlots[1] | valueSlots[2] | valueSlots[3]) == 0;
+
+                if (!onlyDC)
+                {
+                    throw new InvalidOperationException("Huffman symbols out of DC range");
+                }
+            }
+        }
+
+        foreach (JpegScanInfo scan in this.ScanInfos)
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.Value(3),
+                JxlFieldExpressions.Value(4),
+                1,
+                ref Unsafe.As<int, uint>(ref scan.NumComponents)))
+            {
+                return false;
+            }
+
+            if (scan.NumComponents >= 4)
+            {
+                throw new InvalidOperationException("Invalid number of components in SOS marker");
+            }
+
+            if (!visitor.Bits(6, 0, ref Unsafe.As<int, uint>(ref scan.Ss)))
+            {
+                return false;
+            }
+
+            if (!visitor.Bits(6, 63, ref Unsafe.As<int, uint>(ref scan.Se)))
+            {
+                return false;
+            }
+
+            if (!visitor.Bits(4, 0, ref Unsafe.As<int, uint>(ref scan.Al)))
+            {
+                return false;
+            }
+
+            if (!visitor.Bits(4, 0, ref Unsafe.As<int, uint>(ref scan.Ah)))
+            {
+                return false;
+            }
+
+            for (int i = 0; i < scan.NumComponents; i++)
+            {
+                if (!visitor.Bits(2, 0, ref Unsafe.As<int, uint>(ref scan.Components[i].ComponentIndex)))
+                {
+                    return false;
+                }
+
+                if (scan.Components[i].ComponentIndex >= components.Length)
+                {
+                    throw new InvalidOperationException("Invalid component idx in SOS marker");
+                }
+
+                if (!visitor.Bits(2, 0, ref Unsafe.As<int, uint>(ref scan.Components[i].AcTableIndex)))
+                {
+                    return false;
+                }
+
+                if (!visitor.Bits(2, 0, ref Unsafe.As<int, uint>(ref scan.Components[i].DcTableIndex)))
+                {
+                    return false;
+                }
+            }
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.BitsOffset(3, 3),
+                JxlShared.MaximumNumberOfPasses - 1,
+                ref Unsafe.As<int, uint>(ref scan.LastNeededPass)))
+            {
+                return false;
+            }
+        }
+
+        if (info.HasDri)
+        {
+            if (!visitor.Bits(16, 0, ref Unsafe.As<int, uint>(ref this.restartInterval)))
+            {
+                return false;
+            }
+        }
+
+        foreach (JpegScanInfo scan in this.ScanInfos)
+        {
+            int numResetPoints = scan.ResetPoints.Count;
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.BitsOffset(2, 1),
+                JxlFieldExpressions.BitsOffset(4, 4),
+                JxlFieldExpressions.BitsOffset(16, 20),
+                0,
+                ref Unsafe.As<int, uint>(ref numResetPoints)))
+            {
+                return false;
+            }
+
+            if (visitor.IsReading)
+            {
+                scan.ResetPoints = new List<int>(numResetPoints);
+            }
+
+            int lastBlockIdx = -1;
+            foreach (int blk in scan.ResetPoints)
+            {
+                int blockIdx = blk - (lastBlockIdx + 1);
+
+                if (!visitor.U32(
+                    JxlFieldExpressions.Value(0),
+                    JxlFieldExpressions.BitsOffset(3, 1),
+                    JxlFieldExpressions.BitsOffset(5, 9),
+                    JxlFieldExpressions.BitsOffset(28, 41),
+                    0,
+                    ref Unsafe.As<int, uint>(ref blockIdx)))
+                {
+                    return false;
+                }
+
+                blockIdx += lastBlockIdx + 1;
+                if (blockIdx >= (3u << 26))
+                {
+                    // At most 8K x 8K x num_channels blocks are possible in a JPEG.
+                    // So valid block indices are below 3 * 2^26.
+                    throw new InvalidOperationException("Invalid block ID: " + blockIdx);
+                }
+
+                lastBlockIdx = blockIdx;
+            }
+
+            int numExtraZeroRuns = scan.ExtraZeroRuns.Count;
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(0),
+                JxlFieldExpressions.BitsOffset(2, 1),
+                JxlFieldExpressions.BitsOffset(4, 4),
+                JxlFieldExpressions.BitsOffset(16, 20),
+                0,
+                ref Unsafe.As<int, uint>(ref numExtraZeroRuns)))
+            {
+                return false;
+            }
+
+            if (visitor.IsReading)
+            {
+                scan.ExtraZeroRuns = new List<JpegExtraZeroRunInfo>(numExtraZeroRuns);
+            }
+
+            lastBlockIdx = -1;
+
+            Span<JpegExtraZeroRunInfo> extraZeroes = CollectionsMarshal.AsSpan(scan.ExtraZeroRuns);
+
+            for (int i = 0; i < extraZeroes.Length; i++)
+            {
+                ref JpegExtraZeroRunInfo extraZeroRun = ref extraZeroes[i];
+
+                ref int block_idx = ref extraZeroRun.BlockIndex;
+                ref int extra_zero_runs = ref extraZeroRun.NumExtraZeroRuns;
+
+                if (!visitor.U32(
+                    JxlFieldExpressions.Value(1),
+                    JxlFieldExpressions.BitsOffset(2, 2),
+                    JxlFieldExpressions.BitsOffset(4, 5),
+                    JxlFieldExpressions.BitsOffset(8, 20),
+                    1,
+                    ref Unsafe.As<int, uint>(ref extra_zero_runs)))
+                {
+                    return false;
+                }
+
+                block_idx -= lastBlockIdx + 1;
+
+                if (!visitor.U32(
+                    JxlFieldExpressions.Value(0),
+                    JxlFieldExpressions.BitsOffset(3, 1),
+                    JxlFieldExpressions.BitsOffset(5, 9),
+                    JxlFieldExpressions.BitsOffset(28, 41),
+                    0,
+                    ref Unsafe.As<int, uint>(ref block_idx)))
+                {
+                    return false;
+                }
+
+                block_idx += lastBlockIdx + 1;
+
+                if (extra_zero_runs > 4)
+                {
+                    throw new InvalidOperationException("Invalid number of extra zero runs: " + extra_zero_runs);
+                }
+
+                if (block_idx > (3u << 26))
+                {
+                    throw new InvalidOperationException("Invalid block ID: " + block_idx);
+                }
+
+                lastBlockIdx = block_idx;
+            }
+        }
+
+        List<int> interMarkerDataSizes = new(info.NumberOfIntermarkers);
+
+        for (int i = 0; i < info.NumberOfIntermarkers; ++i)
+        {
+            int len = visitor.IsReading ? 0 : this.InterMarkerData[i].Count;
+
+            if (!visitor.Bits(16, 0, ref Unsafe.As<int, uint>(ref len)))
+            {
+                return false;
+            }
+
+            if (visitor.IsReading)
+            {
+                interMarkerDataSizes.Add(len);
+            }
+        }
+
+        int tail_data_len = this.TailData.Count;
+
+        if (visitor.IsReading && tail_data_len > 4260096)
+        {
+            throw new InvalidOperationException("Tail data too large (max size = 4260096, size = " + tail_data_len + ")");
+        }
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value(0),
+            JxlFieldExpressions.BitsOffset(8, 1),
+            JxlFieldExpressions.BitsOffset(16, 257),
+            JxlFieldExpressions.BitsOffset(22, 65793),
+            0,
+            ref Unsafe.As<int, uint>(ref tail_data_len)))
+        {
+            return false;
+        }
+
+        if (!visitor.Boolean(false, ref this.hasZeroPaddingBit))
+        {
+            return false;
+        }
+
+        if (this.hasZeroPaddingBit)
+        {
+            uint nbit = (uint)this.PaddingBits.Count;
+
+            if (!visitor.Bits(24, 0, ref nbit))
+            {
+                return false;
+            }
+
+            if (visitor.IsReading)
+            {
+                this.PaddingBits = new List<byte>((int)Math.Min(1024u, nbit));
+
+                for (int i = 0; i < nbit; i++)
+                {
+                    bool bbit = false;
+
+                    if (!visitor.Boolean(false, ref bbit))
+                    {
+                        return false;
+                    }
+
+                    this.PaddingBits.Add(bbit ? (byte)1 : (byte)0);
+                }
+            }
+            else
+            {
+                Span<byte> bits = CollectionsMarshal.AsSpan(this.PaddingBits);
+
+                for (int i = 0; i < bits.Length; i++)
+                {
+                    ref byte bit = ref bits[i];
+                    bool bbit = bit != 0;
+
+                    if (!visitor.Boolean(false, ref bbit))
+                    {
+                        return false;
+                    }
+
+                    bit = bbit ? (byte)1 : (byte)0;
+                }
+            }
+        }
+
+        int dhtIndex = 0; // index of the Define Huffman Table
+        int scanIndex = 0;
+        bool isProgressive = false;
+
+        InlineArray4<bool> acOk = default;
+        InlineArray4<bool> dcOk = default;
+
+        Span<byte> markerOrderSpan = CollectionsMarshal.AsSpan(this.MarkerOrder);
+
+        for (int i = 0; i < markerOrderSpan.Length; i++)
+        {
+            byte marker = markerOrderSpan[i];
+
+            if (marker == 0xC2)
+            {
+                isProgressive = true;
+            }
+            else if (marker == 0xC4)
+            {
+                Span<JpegHuffmanCode> huffmanCode = CollectionsMarshal.AsSpan(this.HuffmanCodes);
+
+                for (; dhtIndex < huffmanCode.Length;)
+                {
+                    ref JpegHuffmanCode huff = ref huffmanCode[dhtIndex++];
+                    int index = huff.SlotId;
+                    if ((index & 0x10) != 0)
+                    {
+                        index -= 0x10;
+                        acOk[index] = true;
+                    }
+                    else
+                    {
+                        dcOk[index] = true;
+                    }
+
+                    if (huff.IsLast)
+                    {
+                        break;
+                    }
+                }
+            }
+            else if (marker == 0xDA)
+            {
+                Span<JpegScanInfo> scanInfo = CollectionsMarshal.AsSpan(this.ScanInfos);
+                JpegScanInfo si = scanInfo[scanIndex++];
+
+                for (int j = 0; j < si.NumComponents; ++j)
+                {
+                    ref JpegComponentScanInfo csi = ref si.Components[j];
+
+                    int dcTableIndex = csi.DcTableIndex;
+                    int acTableIndex = csi.AcTableIndex;
+
+                    bool wantDc = !isProgressive || (si.Ss == 0);
+
+                    if (wantDc && !dcOk[dcTableIndex])
+                    {
+                        throw new InvalidOperationException("DC Huffman table used before defined");
+                    }
+
+                    bool wantAc = !isProgressive || (si.Ss != 0) || (si.Se != 0);
+
+                    if (wantAc && !acOk[acTableIndex])
+                    {
+                        throw new InvalidOperationException("AC Huffman table used before defined");
+                    }
+                }
+            }
+        }
+
+        // Apply postponed actions
+        if (visitor.IsReading)
+        {
+            this.TailData = new List<byte>(tail_data_len);
+
+            if (interMarkerDataSizes.Count != info.NumberOfIntermarkers)
+            {
+                return false;
+            }
+
+            this.InterMarkerData = new List<List<byte>>(info.NumberOfIntermarkers);
+
+            for (int i = 0; i < info.NumberOfIntermarkers; ++i)
+            {
+                this.InterMarkerData.Add(new List<byte>(interMarkerDataSizes[i]));
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegDataConstants.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegDataConstants.cs
new file mode 100644
index 0000000000..e2c36e92ba
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegDataConstants.cs
@@ -0,0 +1,105 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+/// <summary>
+/// Constants used in parsed JPEG data.
+/// </summary>
+internal static class JpegDataConstants
+{
+    /// <summary>
+    /// Maximum number of components.
+    /// </summary>
+    public const int MaxComponents = 4;
+
+    /// <summary>
+    /// Maximum number of quantizer tables.
+    /// </summary>
+    public const int MaximumQuantizationTables = 4;
+
+    /// <summary>
+    /// Maximum number of Huffman code tables.
+    /// </summary>
+    public const int MaxHuffmanTables = 4;
+
+    /// <summary>
+    /// Maximum number of bits for a Huffman code.
+    /// </summary>
+    public const int JpegHuffmanMaxBitLength = 16;
+
+    /// <summary>
+    /// Alphabet size for Huffman tables used in the JPEG format.
+    /// </summary>
+    public const int JpegHuffmanAlphabetSize = 256;
+
+    /// <summary>
+    /// Alphabet size for Huffman tables used in the JPEG format.
+    /// </summary>
+    /// <remarks>
+    /// This is specific to the DC coefficients of the Discrete
+    /// Cosine Transform.
+    /// </remarks>
+    public const int JpegDcAlphabetSize = 12;
+
+    /// <summary>
+    /// Maximum number of DHT "Define Huffman Tables" markers.
+    /// </summary>
+    public const int MaxDhtMarkers = 512;
+
+    /// <summary>
+    /// Largest value for width OR height.
+    /// </summary>
+    public const int MaxDimPixels = 65535;
+
+    /// <summary>
+    /// Marker that specifies APP1.
+    /// </summary>
+    public const int App1 = 0xE1;
+
+    /// <summary>
+    /// Marker that specifies APP2.
+    /// </summary>
+    public const int App2 = 0xE2;
+
+    /// <summary>
+    /// Gets the tag bytes specifying the ICC profile.
+    /// </summary>
+    public static ReadOnlySpan<byte> IccProfileTag => "ICC_PROFILE\0"u8;
+
+    /// <summary>
+    /// Gets the tag bytes specifying the EXIF profile.
+    /// </summary>
+    public static ReadOnlySpan<byte> ExifTag => "Exif\0\0"u8;
+
+    /// <summary>
+    /// Gets the tag bytes specifying the XMP profile.
+    /// </summary>
+    public static ReadOnlySpan<byte> XmpTag => "http://ns.adobe.com/xap/1.0/\0"u8;
+
+    public static ReadOnlySpan<int> JpegNaturalOrder =>
+    [
+        0,   1,  8, 16,  9,  2,  3, 10,
+        17, 24, 32, 25, 18, 11,  4,  5,
+        12, 19, 26, 33, 40, 48, 41, 34,
+        27, 20, 13,  6,  7, 14, 21, 28,
+        35, 42, 49, 56, 57, 50, 43, 36,
+        29, 22, 15, 23, 30, 37, 44, 51,
+        58, 59, 52, 45, 38, 31, 39, 46,
+        53, 60, 61, 54, 47, 55, 62, 63,
+        63, 63, 63, 63, 63, 63, 63, 63,
+        63, 63, 63, 63, 63, 63, 63, 63
+    ];
+
+    public static ReadOnlySpan<int> JpegZigZagOrder =>
+    [
+        0,   1,  5,  6, 14, 15, 27, 28,
+        2,   4,  7, 13, 16, 26, 29, 42,
+        3,   8, 12, 17, 25, 30, 41, 43,
+        9,  11, 18, 24, 31, 40, 44, 53,
+        10, 19, 23, 32, 39, 45, 52, 54,
+        20, 22, 33, 38, 46, 51, 55, 60,
+        21, 34, 37, 47, 50, 56, 59, 61,
+        35, 36, 48, 49, 57, 58, 62, 63
+    ];
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegExtraZeroRunInfo.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegExtraZeroRunInfo.cs
new file mode 100644
index 0000000000..ed2d41eb03
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegExtraZeroRunInfo.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+internal struct JpegExtraZeroRunInfo
+{
+    public int BlockIndex;
+
+    public int NumExtraZeroRuns;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegHuffmanCode.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegHuffmanCode.cs
new file mode 100644
index 0000000000..324ff5f306
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegHuffmanCode.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+// We may need to get a ref to fields, so don't
+// make these properties.
+internal struct JpegHuffmanCode()
+{
+    /// <summary>
+    /// Bit length histogram
+    /// </summary>
+    public InlineArray17<int> Counts;
+
+    /// <summary>
+    /// Symbol values stored by increasing bit lengths.
+    /// </summary>
+    public InlineArray17<int> Values;
+
+    /// <summary>
+    /// The index of the code in the current set of Huffman codes.
+    /// For AC component Huffman codes, 0x10 is added to the index.
+    /// </summary>
+    public int SlotId;
+
+    /// <summary>
+    /// True if the code is last within its marker segment.
+    /// </summary>
+    public bool IsLast = true;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegInfo.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegInfo.cs
new file mode 100644
index 0000000000..2454f6bbe9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegInfo.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+internal struct JpegInfo
+{
+    public int NumberOfAppMarkers { get; set; }
+
+    public int NumberOfComMarkers { get; set; }
+
+    public int NumberOfScans { get; set; }
+
+    public int NumberOfIntermarkers { get; set; }
+
+    public bool HasDri { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegQuantizationTable.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegQuantizationTable.cs
new file mode 100644
index 0000000000..051835048d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegQuantizationTable.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+/// <summary>
+/// Representation of quantization values for an 8x8 pixel block.
+/// </summary>
+// We may need to get a ref to fields, so don't
+// make these properties.
+internal struct JpegQuantizationTable()
+{
+    /// <summary>
+    /// Quantization values
+    /// </summary>
+    public InlineArray64<int> Values;
+
+    public int Precision;
+
+    /// <summary>
+    /// Gets or sets the index of the quantization table
+    /// as it was parsed from the input JPEG.
+    /// </summary>
+    public int Index;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether this table
+    /// is the last one within its marker segment.
+    /// </summary>
+    public bool IsLast = true;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegScanInfo.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegScanInfo.cs
new file mode 100644
index 0000000000..617f0c7357
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/Data/JpegScanInfo.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+// We may need to get a ref to fields, so don't
+// make these properties.
+#pragma warning disable SA1401 // Fields should be private
+
+internal sealed class JpegScanInfo
+{
+    // Variables copied from ITU-T T.81 spec
+
+    /// <summary>
+    /// Start of spectral band in zigzag sequence
+    /// </summary>
+    public int Ss;
+
+    /// <summary>
+    /// End of spectral band in zigzag sequence
+    /// </summary>
+    public int Se;
+
+    /// <summary>
+    /// Successive approximation bit position. (High)
+    /// </summary>
+    public int Ah;
+
+    /// <summary>
+    /// Successive approximation bit position. (Low)
+    /// </summary>
+    public int Al;
+
+    public int NumComponents;
+
+    public InlineArray4<JpegComponentScanInfo> Components;
+
+    public int LastNeededPass;
+
+    public List<int> ResetPoints { get; set; } = [];
+
+    public List<JpegExtraZeroRunInfo> ExtraZeroRuns { get; set; } = [];
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegBitWriter.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegBitWriter.cs
new file mode 100644
index 0000000000..805eb934f6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegBitWriter.cs
@@ -0,0 +1,187 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal sealed class JpegBitWriter
+{
+    private const int ChunkSize = 16 * 1024;
+
+    private readonly Stream stream;
+    private readonly byte[] buffer;
+
+    private int pos;
+    private ulong putBuffer;
+    private int putBits;
+
+    public JpegBitWriter(Stream stream)
+    {
+        this.stream = stream;
+        this.buffer = new byte[ChunkSize];
+        this.putBits = 64;
+    }
+
+    public bool Healthy { get; private set; } = true;
+
+    private void SwapBuffer()
+    {
+        if (this.pos == 0)
+        {
+            return;
+        }
+
+        this.stream.Write(this.buffer, 0, this.pos);
+        this.pos = 0;
+    }
+
+    public void Reserve(int nBytes)
+    {
+        if (this.pos + nBytes > this.buffer.Length)
+        {
+            this.SwapBuffer();
+        }
+    }
+
+    private void EmitByte(int value)
+    {
+        this.buffer[this.pos++] = (byte)value;
+
+        if (value == 0xff)
+        {
+            this.buffer[this.pos++] = 0;
+        }
+    }
+
+    public void EmitMarker(int marker)
+    {
+        this.Reserve(2);
+
+        this.buffer[this.pos++] = 0xff;
+        this.buffer[this.pos++] = (byte)marker;
+    }
+
+    public void StoreBe64(ulong value)
+    {
+        Span<byte> span = this.buffer.AsSpan(this.pos);
+        BinaryPrimitives.WriteUInt64BigEndian(span, value);
+        this.pos += 8;
+    }
+
+    public void DischargeBitBuffer(int nBits, ulong bits)
+    {
+        this.putBuffer |= bits >> -this.putBits;
+
+        if (HasZeroByte(~this.putBuffer))
+        {
+            this.Reserve(16);
+
+            this.EmitByte((int)(this.putBuffer >> 56));
+            this.EmitByte((int)(this.putBuffer >> 48));
+            this.EmitByte((int)(this.putBuffer >> 40));
+            this.EmitByte((int)(this.putBuffer >> 32));
+            this.EmitByte((int)(this.putBuffer >> 24));
+            this.EmitByte((int)(this.putBuffer >> 16));
+            this.EmitByte((int)(this.putBuffer >> 8));
+            this.EmitByte((int)this.putBuffer);
+        }
+        else
+        {
+            this.Reserve(8);
+            this.StoreBe64(this.putBuffer);
+        }
+
+        this.putBits += 64;
+        this.putBuffer = bits << this.putBits;
+    }
+
+    public void WriteBits(int nBits, ulong bits)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(nBits);
+
+        this.putBits -= nBits;
+
+        if (this.putBits < 0)
+        {
+            if (nBits > 64)
+            {
+                this.putBits += nBits;
+                this.Healthy = false;
+            }
+            else
+            {
+                this.DischargeBitBuffer(nBits, bits);
+            }
+        }
+        else
+        {
+            this.putBuffer |= bits << this.putBits;
+        }
+    }
+
+    public bool JumpToByteBoundary(ref ReadOnlySpan<byte> padBits)
+    {
+        int nBits = this.putBits & 7;
+        byte padPattern;
+
+        if (padBits.IsEmpty)
+        {
+            padPattern = (byte)((1 << nBits) - 1);
+        }
+        else
+        {
+            padPattern = 0;
+            byte danglingBits = 0;
+
+            for (int i = 0; i < nBits; ++i)
+            {
+                if (padBits.IsEmpty)
+                {
+                    return false;
+                }
+
+                byte bit = padBits[0];
+                padBits = padBits[1..];
+
+                danglingBits |= bit;
+
+                padPattern <<= 1;
+                padPattern |= bit;
+            }
+
+            if ((danglingBits & ~1) != 0)
+            {
+                return false;
+            }
+        }
+
+        this.Reserve(16);
+
+        while (this.putBits <= 56)
+        {
+            int c = (int)(this.putBuffer >> 56);
+
+            this.EmitByte(c);
+
+            this.putBuffer <<= 8;
+            this.putBits += 8;
+        }
+
+        if (this.putBits < 64)
+        {
+            int padMask = 0xff >> (64 - this.putBits);
+
+            int c =
+                ((int)(this.putBuffer >> 56) & ~padMask) |
+                padPattern;
+
+            this.EmitByte(c);
+        }
+
+        this.putBuffer = 0;
+        this.putBits = 64;
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegDctCodingState.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegDctCodingState.cs
new file mode 100644
index 0000000000..14fc0f9a3a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegDctCodingState.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal sealed class JpegDctCodingState
+{
+    public int EobRun { get; set; }
+
+    public JpegHuffmanCodeTable? CurAcHuff { get; set; }
+
+    public List<ushort> RefinementBits { get; } = new(64);
+
+    public int RefinementBitsCount { get; set; }
+
+    public void Flush(JpegBitWriter writer) => JpegWriter.Flush(this, writer);
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegDebug.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegDebug.cs
new file mode 100644
index 0000000000..21361b694c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegDebug.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal static class JpegDebug
+{
+    [Conditional("DEBUG")]
+    public static void LogWarning(string message) =>
+        // TODO: do we allow Debug.WriteLine in this codebase?
+        Debug.WriteLine($"⚠️ JPEG XL [JPEG parser]: {message}");
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegHuffmanCodeTable.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegHuffmanCodeTable.cs
new file mode 100644
index 0000000000..847485e2e5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegHuffmanCodeTable.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+// InlineArray values cannot be assigned as a property
+#pragma warning disable SA1401 // Fields should be private
+
+internal sealed class JpegHuffmanCodeTable
+{
+    public InlineArray256<byte> Depth;
+
+    public InlineArray256<short> Code;
+
+    public bool Initialized { get; set; }
+
+    public void InitializeDepths(byte value = 0)
+    {
+        Span<byte> depths = this.Depth;
+        depths.Fill(value);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegHuffmanDecoder.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegHuffmanDecoder.cs
new file mode 100644
index 0000000000..d0e11df072
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegHuffmanDecoder.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+/// <summary>
+/// Decodes Huffman codes in a JPEG file for JPEG to JPEG XL encoder.
+/// </summary>
+internal static class JpegHuffmanDecoder
+{
+    public const int RootTableBits = 8;
+    public const int LookupSize = 1024;
+
+    private static int NextTableBitSize(Span<int> count, int length)
+    {
+        int left = 1 << (length - RootTableBits);
+        while (length < MaxBitLength)
+        {
+            left -= count[length];
+
+            if (left <= 0)
+            {
+                break;
+            }
+
+            length++;
+            left <<= 1;
+        }
+
+        return length - RootTableBits;
+    }
+
+    public struct HuffmanTableEntry()
+    {
+        public byte Bits = 0;
+        public ushort Value = 0xFFFF;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegReadMode.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegReadMode.cs
new file mode 100644
index 0000000000..be4de6a5ed
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegReadMode.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal enum JpegReadMode : byte
+{
+    ReadHeader,
+
+    ReadTables,
+
+    ReadEverything
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegReader.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegReader.cs
new file mode 100644
index 0000000000..395d283e83
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegReader.cs
@@ -0,0 +1,1497 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using HuffmanTableEntry = SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.JpegHuffmanDecoder.HuffmanTableEntry;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+/// <summary>
+/// JPEG file parser. The codec uses this parser as part of its
+/// JPEG to JPEG XL lossless compression feature.
+/// </summary>
+internal static class JpegReader
+{
+    private const int BrunsliMaxSampling = 15;
+
+    /// <summary>
+    /// Gets a lookup used by <see cref="FindNextMarker(ReadOnlySpan{byte}, int)"/>
+    /// </summary>
+    private static ReadOnlySpan<byte> IsValidMarkerLookup =>
+    [
+        1, 1, 1, 0, 1, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 1, 1, 1, 1, 1, 1, 1,
+        0, 1, 1, 1, 0, 1, 0, 0,
+        1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 0,
+    ];
+
+    private static int ReadUint8(ReadOnlySpan<byte> data, ref int pos) => data[pos++];
+
+    private static int ReadUint16(ReadOnlySpan<byte> data, ref int pos)
+    {
+        int value = (data[pos] << 8) | data[pos + 1];
+        pos += 2;
+        return value;
+    }
+
+    private static void VerifyLength(int pos, int length, int needed)
+    {
+        if ((uint)needed > (uint)(length - pos))
+        {
+            throw new InvalidDataException($"Unexpected end of input: pos={pos} need={needed} len={length}");
+        }
+    }
+
+    private static void VerifyInput(int value, int low, int high, string name)
+    {
+        if (value < low || value > high)
+        {
+            throw new InvalidDataException($"Invalid {name}: {value}");
+        }
+    }
+
+    private static void VerifyMarkerEnd(int startPos, int markerLength, int pos)
+    {
+        if (startPos + markerLength != pos)
+        {
+            throw new InvalidDataException($"Invalid marker length: declared={markerLength} actual={pos - startPos}");
+        }
+    }
+
+    private static void ExpectMarker(ReadOnlySpan<byte> data, int pos)
+    {
+        if (pos > data.Length - 2 || data[pos] != 0xff)
+        {
+            int value = pos < data.Length ? data[pos] : 0;
+
+            throw new InvalidDataException($"Marker byte (0xff) expected, found: 0x{value:x2} pos={pos} len={data.Length}");
+        }
+    }
+
+    private static void ProcessMarkerSOF(ReadOnlySpan<byte> data, int len, JpegReadMode mode, ref int pos, JpegData jpg)
+    {
+        if (jpg.Width != 0)
+        {
+            throw new InvalidDataException("Duplicate SOF marker");
+        }
+
+        int startPos = pos;
+        VerifyLength(pos, len, 8);
+
+        int markerLength = ReadUint16(data, ref pos);
+        int precision = ReadUint8(data, ref pos);
+        int height = ReadUint16(data, ref pos);
+        int width = ReadUint16(data, ref pos);
+        int numComponents = ReadUint8(data, ref pos);
+
+        VerifyInput(precision, 8, 8, nameof(precision));
+        VerifyInput(height, 1, JpegDataConstants.MaxDimPixels, nameof(height));
+        VerifyInput(width, 1, JpegDataConstants.MaxDimPixels, nameof(width));
+        VerifyInput(numComponents, 1, JpegDataConstants.MaxComponents, nameof(numComponents));
+
+        VerifyLength(pos, len, 3 * numComponents);
+
+        jpg.Height = height;
+        jpg.Width = width;
+        jpg.Components = new(numComponents);
+
+        Span<bool> idsSeen = stackalloc bool[256];
+
+        int maxHSampFactor = 1;
+        int maxVSampFactor = 1;
+
+        foreach (JpegComponent component in jpg.Components)
+        {
+            int id = ReadUint8(data, ref pos);
+
+            if (idsSeen[id])
+            {
+                throw new InvalidDataException($"Duplicate ID {id} in SOF.");
+            }
+
+            idsSeen[id] = true;
+            component.Id = id;
+
+            int factor = ReadUint8(data, ref pos);
+            int hSampFactor = factor >> 4;
+            int vSampFactor = factor & 0xf;
+
+            VerifyInput(hSampFactor, 1, BrunsliMaxSampling, nameof(hSampFactor));
+            VerifyInput(vSampFactor, 1, BrunsliMaxSampling, nameof(vSampFactor));
+
+            component.HorizontalSampleFactor = hSampFactor;
+            component.VerticalSampleFactor = vSampFactor;
+            component.QuantIndex = ReadUint8(data, ref pos);
+
+            maxHSampFactor = Math.Max(maxHSampFactor, hSampFactor);
+            maxVSampFactor = Math.Max(maxVSampFactor, vSampFactor);
+        }
+
+        int mcuRows = JxlMath.DivCeil(height, maxVSampFactor * 8);
+        int mcuCols = JxlMath.DivCeil(width, maxHSampFactor * 8);
+
+        foreach (JpegComponent component in jpg.Components)
+        {
+            if (maxHSampFactor % component.HorizontalSampleFactor != 0 ||
+                maxVSampFactor % component.VerticalSampleFactor != 0)
+            {
+                throw new InvalidDataException("Non-integral subsampling ratios");
+            }
+
+            component.WidthInBlocks = mcuCols * component.HorizontalSampleFactor;
+            component.HeightInBlocks = mcuRows * component.VerticalSampleFactor;
+        }
+
+        VerifyMarkerEnd(startPos, markerLength, pos);
+    }
+
+    private static void ProcessMarkerSOS(ReadOnlySpan<byte> data, int len, ref int pos, JpegData jpg)
+    {
+        int startPos = pos;
+
+        VerifyLength(pos, len, 3);
+
+        int markerLength = ReadUint16(data, ref pos);
+        int componentsInScan = ReadUint8(data, ref pos);
+
+        VerifyInput(
+            componentsInScan,
+            1,
+            jpg.Components.Count,
+            nameof(componentsInScan));
+
+        JpegScanInfo scanInfo = new()
+        {
+            NumComponents = componentsInScan
+        };
+
+        VerifyLength(pos, len, 2 * componentsInScan);
+
+        Span<bool> idsSeen = stackalloc bool[256];
+
+        for (int i = 0; i < componentsInScan; i++)
+        {
+            int id = ReadUint8(data, ref pos);
+
+            if (idsSeen[id])
+            {
+                throw new InvalidDataException($"Duplicate ID {id} in SOS.");
+            }
+
+            idsSeen[id] = true;
+
+            int componentIndex = -1;
+
+            for (int j = 0; j < jpg.Components.Count; j++)
+            {
+                if (jpg.Components[j].Id == id)
+                {
+                    componentIndex = j;
+                    break;
+                }
+            }
+
+            if (componentIndex < 0)
+            {
+                throw new InvalidDataException($"SOS marker: Could not find component with id {id}");
+            }
+
+            int c = ReadUint8(data, ref pos);
+
+            int dcTableIndex = c >> 4;
+            int acTableIndex = c & 0xf;
+
+            VerifyInput(dcTableIndex, 0, 3, nameof(dcTableIndex));
+            VerifyInput(acTableIndex, 0, 3, nameof(acTableIndex));
+
+            scanInfo.Components[i].ComponentIndex = componentIndex;
+            scanInfo.Components[i].DcTableIndex = dcTableIndex;
+            scanInfo.Components[i].AcTableIndex = acTableIndex;
+        }
+
+        VerifyLength(pos, len, 3);
+
+        scanInfo.Ss = ReadUint8(data, ref pos);
+        scanInfo.Se = ReadUint8(data, ref pos);
+
+        VerifyInput(scanInfo.Ss, 0, 63, nameof(scanInfo.Ss));
+        VerifyInput(
+            scanInfo.Se,
+            scanInfo.Ss,
+            63,
+            nameof(scanInfo.Se));
+
+        int c2 = ReadUint8(data, ref pos);
+
+        scanInfo.Ah = c2 >> 4;
+        scanInfo.Al = c2 & 0xf;
+
+        if (scanInfo.Ah != 0 && scanInfo.Al != scanInfo.Ah - 1)
+        {
+            JpegDebug.LogWarning($"Invalid progressive parameters: Al={scanInfo.Al}, Ah={scanInfo.Ah}");
+        }
+
+        // Check that all Huffman tables needed for this scan are defined.
+        for (int i = 0; i < componentsInScan; i++)
+        {
+            bool foundDcTable = false;
+            bool foundAcTable = false;
+
+            int dcTableIndex = scanInfo.Components[i].DcTableIndex;
+            int acTableIndex = scanInfo.Components[i].AcTableIndex;
+
+            foreach (JpegHuffmanCode code in jpg.HuffmanCodes)
+            {
+                int slotId = code.SlotId;
+
+                if (slotId == dcTableIndex)
+                {
+                    foundDcTable = true;
+                }
+                else if (slotId == acTableIndex + 16)
+                {
+                    foundAcTable = true;
+                }
+            }
+
+            if (scanInfo.Ss == 0 && !foundDcTable)
+            {
+                throw new InvalidDataException(
+                    $"SOS marker: Could not find DC Huffman table " +
+                    $"with index {dcTableIndex}");
+            }
+
+            if (scanInfo.Se > 0 && !foundAcTable)
+            {
+                throw new InvalidDataException(
+                    $"SOS marker: Could not find AC Huffman table " +
+                    $"with index {acTableIndex}");
+            }
+        }
+
+        jpg.ScanInfos.Add(scanInfo);
+        VerifyMarkerEnd(startPos, markerLength, pos);
+    }
+
+    private static void ProcessMarkerDHT(ReadOnlySpan<byte> data, int len, JpegReadMode mode, Span<HuffmanTableEntry> dcHuffLut, Span<HuffmanTableEntry> acHuffLut, ref int pos, JpegData jpg)
+    {
+        int startPos = pos;
+
+        VerifyLength(pos, len, 2);
+
+        int markerLength = ReadUint16(data, ref pos);
+
+        if (markerLength == 2)
+        {
+            // Empty DHT marker. Useless, but does occur in the wild.
+            // Represent it with a dummy all-zeroes Huffman table.
+            JpegHuffmanCode huff = new()
+            {
+                IsLast = true
+            };
+
+            jpg.HuffmanCodes.Add(huff);
+            return;
+        }
+
+        Span<bool> valuesSeen = stackalloc bool[256];
+
+        while (pos < startPos + markerLength)
+        {
+            VerifyLength(pos, len, 1 + JpegDataConstants.JpegHuffmanMaxBitLength);
+
+            JpegHuffmanCode huff = new()
+            {
+                SlotId = ReadUint8(data, ref pos)
+            };
+
+            int huffmanIndex = huff.SlotId;
+            bool isAcTable = (huff.SlotId & 0x10) != 0;
+
+            Span<HuffmanTableEntry> huffLut;
+
+            if (isAcTable)
+            {
+                huffmanIndex -= 0x10;
+                VerifyInput(huffmanIndex, 0, 3, nameof(huffmanIndex));
+
+                huffLut = acHuffLut.Slice(
+                    huffmanIndex * JpegHuffmanDecoder.LookupSize,
+                    JpegHuffmanDecoder.LookupSize);
+            }
+            else
+            {
+                VerifyInput(huffmanIndex, 0, 3, nameof(huffmanIndex));
+
+                huffLut = dcHuffLut.Slice(
+                    huffmanIndex * JpegHuffmanDecoder.LookupSize,
+                    JpegHuffmanDecoder.LookupSize);
+            }
+
+            huff.Counts[0] = 0;
+
+            int totalCount = 0;
+            int space = 1 << JpegDataConstants.JpegHuffmanMaxBitLength;
+            int maxDepth = 1;
+
+            for (int i = 1; i <= JpegDataConstants.JpegHuffmanMaxBitLength; i++)
+            {
+                int count = ReadUint8(data, ref pos);
+
+                if (count != 0)
+                {
+                    maxDepth = i;
+                }
+
+                huff.Counts[i] = count;
+                totalCount += count;
+
+                space -= count * (1 << (JpegDataConstants.JpegHuffmanMaxBitLength - i));
+            }
+
+            VerifyInput(
+                totalCount,
+                0,
+                isAcTable ? JpegDataConstants.JpegHuffmanAlphabetSize : JpegDataConstants.JpegDcAlphabetSize,
+                nameof(totalCount));
+
+            VerifyLength(pos, len, totalCount);
+
+            valuesSeen.Clear(); // set everything to false
+
+            for (int i = 0; i < totalCount; i++)
+            {
+                int value = ReadUint8(data, ref pos);
+
+                if (!isAcTable)
+                {
+                    VerifyInput(
+                        value,
+                        0,
+                        JpegDataConstants.JpegDcAlphabetSize - 1,
+                        nameof(value));
+                }
+
+                if (valuesSeen[value])
+                {
+                    throw new InvalidDataException($"Duplicate Huffman code value {value}");
+                }
+
+                valuesSeen[value] = true;
+                huff.Values[i] = value;
+            }
+
+            huff.Counts[maxDepth]++;
+            huff.Values[totalCount] = JpegDataConstants.JpegHuffmanAlphabetSize;
+
+            space -= 1 << (JpegDataConstants.JpegHuffmanMaxBitLength - maxDepth);
+
+            if (space < 0)
+            {
+                throw new InvalidDataException("Invalid Huffman code lengths");
+            }
+
+            if (space > 0 && huffLut[0].Value != 0xffff)
+            {
+                for (int i = 0; i < JpegHuffmanDecoder.LookupSize; i++)
+                {
+                    huffLut[i].Bits = 0;
+                    huffLut[i].Value = 0xffff;
+                }
+            }
+
+            huff.IsLast = pos == startPos + markerLength;
+
+            if (mode == JpegReadMode.ReadEverything)
+            {
+                JpegHuffmanDecoder.BuildJpegHuffmanTable(
+                    huff.Counts,
+                    huff.Values,
+                    huffLut);
+            }
+
+            jpg.HuffmanCodes.Add(huff);
+        }
+
+        VerifyMarkerEnd(startPos, markerLength, pos);
+    }
+
+    private static void ProcessMarkerDQT(ReadOnlySpan<byte> data, int len, ref int pos, JpegData jpg)
+    {
+        int startPos = pos;
+        VerifyLength(pos, len, 2);
+        int markerLength = ReadUint16(data, ref pos);
+
+        if (markerLength == 2)
+        {
+            throw new InvalidDataException("DQT marker: no quantization table found");
+        }
+
+        while (pos < startPos + markerLength && jpg.Quant.Count < JpegDataConstants.MaximumQuantizationTables)
+        {
+            VerifyLength(pos, len, 1);
+
+            int quantTableIndex = ReadUint8(data, ref pos);
+            int quantTablePrecision = quantTableIndex >> 4;
+
+            VerifyInput(
+                quantTablePrecision,
+                0,
+                1,
+                nameof(quantTablePrecision));
+
+            quantTableIndex &= 0xf;
+
+            VerifyInput(
+                quantTableIndex,
+                0,
+                3,
+                nameof(quantTableIndex));
+
+            VerifyLength(
+                pos,
+                len,
+                (quantTablePrecision + 1) * JxlFrameDimensions.DctBlockSize);
+
+            JpegQuantizationTable table = new()
+            {
+                Index = quantTableIndex,
+                Precision = quantTablePrecision
+            };
+
+            for (int i = 0; i < JxlFrameDimensions.DctBlockSize; i++)
+            {
+                int quantValue = quantTablePrecision != 0
+                    ? ReadUint16(data, ref pos)
+                    : ReadUint8(data, ref pos);
+
+                VerifyInput(
+                    quantValue,
+                    1,
+                    65535,
+                    nameof(quantValue));
+
+                table.Values[JpegDataConstants.JpegNaturalOrder[i]] = quantValue;
+            }
+
+            table.IsLast = pos == startPos + markerLength;
+
+            jpg.Quant.Add(table);
+        }
+
+        VerifyMarkerEnd(startPos, markerLength, pos);
+    }
+
+    private static void ProcessDRI(ReadOnlySpan<byte> data, int len, ref int pos, ref bool foundDri, JpegData jpg)
+    {
+        if (foundDri)
+        {
+            throw new InvalidDataException("Duplicate DRI marker.");
+        }
+
+        foundDri = true;
+        int startPos = pos;
+
+        VerifyLength(pos, len, 4);
+
+        int markerLength = ReadUint16(data, ref pos);
+        int restartInterval = ReadUint16(data, ref pos);
+
+        jpg.RestartInterval = restartInterval;
+
+        VerifyMarkerEnd(startPos, markerLength, pos);
+    }
+
+    private static void ProcessAPP(ReadOnlySpan<byte> data, int len, ref int pos, JpegData jpg)
+    {
+        VerifyLength(pos, len, 2);
+
+        int markerLength = ReadUint16(data, ref pos);
+
+        VerifyInput(markerLength, 2, 65535, nameof(markerLength));
+        VerifyLength(pos, len, markerLength - 2);
+
+        if (pos < 3)
+        {
+            throw new InvalidDataException("Invalid APP marker position");
+        }
+
+        ReadOnlySpan<byte> appData = data.Slice(pos - 3, markerLength + 1);
+        jpg.AppData.Add([.. appData]);
+
+        pos += markerLength - 2;
+    }
+
+    private static void ProcessMarkerCOM(ReadOnlySpan<byte> data, int len, ref int pos, JpegData jpg)
+    {
+        VerifyLength(pos, len, 2);
+
+        int markerLength = ReadUint16(data, ref pos);
+
+        VerifyInput(markerLength, 2, 65535, nameof(markerLength));
+        VerifyLength(pos, len, markerLength - 2);
+
+        if (pos < 3)
+        {
+            throw new InvalidDataException("Invalid COM marker position");
+        }
+
+        ReadOnlySpan<byte> comData = data.Slice(pos - 3, markerLength + 1);
+        jpg.ComData.Add([.. comData]);
+
+        pos += markerLength - 2;
+    }
+
+    private static int ReadSymbol(ReadOnlySpan<HuffmanTableEntry> table, ref BitReaderState br)
+    {
+        br.FillBitWindow();
+
+        int value = (int)((br.Value >> (br.BitsLeft - 8)) & 0xff);
+        HuffmanTableEntry entry = table[value];
+
+        int bitCount = entry.Bits - 8;
+
+        if (bitCount > 0)
+        {
+            br.BitsLeft -= 8;
+
+            entry = table[entry.Value + (int)(
+                (br.Value >> (br.BitsLeft - bitCount)) &
+                ((1UL << bitCount) - 1))];
+        }
+
+        br.BitsLeft -= entry.Bits;
+        return entry.Value;
+    }
+
+    private static int HuffExtend(int x, int s)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(s, 1, nameof(s));
+
+        int half = 1 << (s - 1);
+
+        if (x >= half)
+        {
+            if (x < (1 << s))
+            {
+                throw new InvalidOperationException("x is invalid");
+            }
+
+            return x;
+        }
+
+        return x - (1 << s) + 1;
+    }
+
+    private static bool DecodeDCTBlock(
+        ReadOnlySpan<HuffmanTableEntry> dcHuff,
+        ReadOnlySpan<HuffmanTableEntry> acHuff,
+        int ss,
+        int se,
+        int al,
+        ref int eobRun,
+        ref bool resetState,
+        ref int numZeroRuns,
+        ref BitReaderState br,
+        ref int lastDcCoeff,
+        Span<int> coeffs)
+    {
+        int am = 1 << al;
+        bool eobRunAllowed = ss > 0;
+
+        if (ss == 0)
+        {
+            int s = ReadSymbol(dcHuff, ref br);
+
+            if (s >= JpegDataConstants.JpegDcAlphabetSize)
+            {
+                return false;
+            }
+
+            int diff = 0;
+
+            if (s > 0)
+            {
+                int bits = br.ReadBits(s);
+                diff = HuffExtend(bits, s);
+            }
+
+            int coeff = diff + lastDcCoeff;
+            int dcCoeff = coeff * am;
+
+            coeffs[0] = dcCoeff;
+
+            if (dcCoeff != coeffs[0])
+            {
+                return false;
+            }
+
+            lastDcCoeff = coeff;
+            ss++;
+        }
+
+        if (ss > se)
+        {
+            return true;
+        }
+
+        if (eobRun > 0)
+        {
+            eobRun--;
+            return true;
+        }
+
+        numZeroRuns = 0;
+
+        for (int k = ss; k <= se; k++)
+        {
+            int sr = ReadSymbol(acHuff, ref br);
+
+            if (sr >= JpegDataConstants.JpegHuffmanAlphabetSize)
+            {
+                return false;
+            }
+
+            int r = sr >> 4;
+            int s = sr & 15;
+
+            if (s > 0)
+            {
+                k += r;
+
+                if (k > se)
+                {
+                    return false;
+                }
+
+                if (s + al >= JpegDataConstants.JpegDcAlphabetSize)
+                {
+                    return false;
+                }
+
+                int bits = br.ReadBits(s);
+                int coeff = HuffExtend(bits, s);
+
+                coeffs[JpegDataConstants.JpegNaturalOrder[k]] = coeff * am;
+                numZeroRuns = 0;
+            }
+            else if (r == 15)
+            {
+                k += 15;
+                numZeroRuns++;
+            }
+            else
+            {
+                if (eobRunAllowed && k == ss && eobRun == 0)
+                {
+                    // Two EOB runs immediately after each other signal that
+                    // the JPEG encoder should force a state reset here.
+                    resetState = true;
+                }
+
+                eobRun = 1 << r;
+
+                if (r > 0)
+                {
+                    if (!eobRunAllowed)
+                    {
+                        return false;
+                    }
+
+                    eobRun += br.ReadBits(r);
+                }
+
+                break;
+            }
+        }
+
+        eobRun--;
+        return true;
+    }
+
+    private static bool RefineDCTBlock(
+        ReadOnlySpan<HuffmanTableEntry> acHuff,
+        int ss,
+        int se,
+        int al,
+        ref int eobRun,
+        ref bool resetState,
+        ref BitReaderState br,
+        Span<int> coeffs)
+    {
+        int am = 1 << al;
+        bool eobRunAllowed = ss > 0;
+
+        int s;
+        if (ss == 0)
+        {
+            s = br.ReadBits(1);
+            int dcCoeff = coeffs[0];
+
+            dcCoeff |= s * am;
+            coeffs[0] = dcCoeff;
+
+            ++ss;
+        }
+
+        if (ss > se)
+        {
+            return true;
+        }
+
+        int p1 = am;
+        int m1 = -am;
+        int k = ss;
+        bool inZeroRun = false;
+
+        if (eobRun <= 0)
+        {
+            for (; k <= se; k++)
+            {
+                int symbol = ReadSymbol(acHuff, ref br);
+
+                if (symbol >= JpegDataConstants.JpegHuffmanAlphabetSize)
+                {
+                    return false;
+                }
+
+                int r = symbol >> 4;
+                s = symbol & 15;
+
+                if (s != 0)
+                {
+                    if (s != 1)
+                    {
+                        return false;
+                    }
+
+                    s = br.ReadBits(1) != 0 ? p1 : m1;
+                    inZeroRun = false;
+                }
+                else
+                {
+                    if (r != 15)
+                    {
+                        if (eobRunAllowed && k == ss && eobRun == 0)
+                        {
+                            resetState = true;
+                        }
+
+                        eobRun = 1 << r;
+
+                        if (r > 0)
+                        {
+                            if (!eobRunAllowed)
+                            {
+                                return false;
+                            }
+
+                            eobRun += br.ReadBits(r);
+                        }
+
+                        break;
+                    }
+
+                    inZeroRun = true;
+                }
+
+                do
+                {
+                    int index = JpegDataConstants.JpegNaturalOrder[k];
+                    int coefficient = coeffs[index];
+
+                    if (coefficient != 0)
+                    {
+                        if (br.ReadBits(1) != 0)
+                        {
+                            if ((coefficient & p1) == 0)
+                            {
+                                coefficient += coefficient >= 0
+                                    ? p1
+                                    : m1;
+                            }
+                        }
+
+                        coeffs[index] = coefficient;
+                    }
+                    else
+                    {
+                        if (--r < 0)
+                        {
+                            break;
+                        }
+                    }
+
+                    k++;
+                }
+                while (k <= se);
+
+                if (s != 0)
+                {
+                    if (k > se)
+                    {
+                        return false;
+                    }
+
+                    coeffs[JpegDataConstants.JpegNaturalOrder[k]] = s;
+                }
+            }
+        }
+
+        if (inZeroRun)
+        {
+            return false;
+        }
+
+        if (eobRun > 0)
+        {
+            for (; k <= se; k++)
+            {
+                int index = JpegDataConstants.JpegNaturalOrder[k];
+                int coefficient = coeffs[index];
+
+                if (coefficient != 0)
+                {
+                    if (br.ReadBits(1) != 0)
+                    {
+                        if ((coefficient & p1) == 0)
+                        {
+                            coefficient += coefficient >= 0
+                                ? p1
+                                : m1;
+                        }
+                    }
+
+                    coeffs[index] = coefficient;
+                }
+            }
+        }
+
+        --eobRun;
+        return true;
+    }
+
+    private static bool ProcessRestart(ReadOnlySpan<byte> data, ref int nextRestartMarker, ref BitReaderState br, JpegData jpg)
+    {
+        int pos = 0;
+
+        if (!br.FinishStream(jpg, ref pos))
+        {
+            return false;
+        }
+
+        int expectedMarker = 0xd0 + nextRestartMarker;
+        ExpectMarker(data, pos);
+
+        int marker = data[pos + 1];
+
+        if (marker != expectedMarker)
+        {
+            return false;
+        }
+
+        br.Reset(pos + 2);
+
+        nextRestartMarker = (nextRestartMarker + 1) & 0x7;
+
+        return true;
+    }
+
+    private static bool ProcessScan(ReadOnlySpan<byte> data, int len, ReadOnlySpan<HuffmanTableEntry> dcHuffLut, ReadOnlySpan<HuffmanTableEntry> acHuffLut, Span<ushort> scanProgression, bool isProgressive, ref int pos, JpegData jpg)
+    {
+        ProcessMarkerSOS(data, len, ref pos, jpg);
+
+        JpegScanInfo scanInfo = jpg.ScanInfos[^1];
+
+        bool isInterleaved = scanInfo.NumComponents > 1;
+
+        int maxHSampFactor = 1;
+        int maxVSampFactor = 1;
+
+        foreach (JpegComponent component in jpg.Components)
+        {
+            maxHSampFactor = Math.Max(maxHSampFactor, component.HorizontalSampleFactor);
+            maxVSampFactor = Math.Max(maxVSampFactor, component.VerticalSampleFactor);
+        }
+
+        int mcuRows = JxlMath.DivCeil(jpg.Height, maxVSampFactor * 8);
+        int mcusPerRow = JxlMath.DivCeil(jpg.Width, maxHSampFactor * 8);
+
+        if (!isInterleaved)
+        {
+            JpegComponent c = jpg.Components[scanInfo.Components[0].ComponentIndex];
+
+            mcusPerRow = JxlMath.DivCeil(
+                jpg.Width * c.HorizontalSampleFactor,
+                8 * maxHSampFactor);
+
+            mcuRows = JxlMath.DivCeil(
+                jpg.Height * c.VerticalSampleFactor,
+                8 * maxVSampFactor);
+        }
+
+        Span<int> lastDcCoeff = stackalloc int[JpegDataConstants.MaxComponents];
+        lastDcCoeff.Clear();
+
+        BitReaderState br = new(data, pos);
+
+        int restartsToGo = jpg.RestartInterval;
+        int nextRestartMarker = 0;
+        int eobRun = -1;
+        int blockScanIndex = 0;
+
+        int al = isProgressive ? scanInfo.Al : 0;
+        int ah = isProgressive ? scanInfo.Ah : 0;
+        int ss = isProgressive ? scanInfo.Ss : 0;
+        int se = isProgressive ? scanInfo.Se : 63;
+
+        ushort scanBitmask = ah == 0 ? (ushort)(0xffff << al) : (ushort)(1u << al);
+        ushort refinementBitmask = (ushort)((1 << al) - 1);
+
+        for (int i = 0; i < scanInfo.NumComponents; ++i)
+        {
+            int compIdx = scanInfo.Components[i].ComponentIndex;
+
+            for (int k = ss; k <= se; ++k)
+            {
+                int progressionIndex = (compIdx * JxlFrameDimensions.DctBlockSize) + k;
+                ushort previousMask = scanProgression[progressionIndex];
+
+                if ((previousMask & scanBitmask) != 0)
+                {
+                    return false;
+                }
+
+                if ((previousMask & refinementBitmask) != 0)
+                {
+                    return false;
+                }
+
+                scanProgression[progressionIndex] |= scanBitmask;
+            }
+        }
+
+        if (al > 10)
+        {
+            return false;
+        }
+
+        foreach (JpegComponent c in jpg.Components)
+        {
+            if (c.Coefficients.Count == 0)
+            {
+                int numBlocks = c.WidthInBlocks * c.HeightInBlocks;
+                c.Coefficients = new List<int>(numBlocks * JxlFrameDimensions.DctBlockSize);
+            }
+        }
+
+        for (int mcuY = 0; mcuY < mcuRows; ++mcuY)
+        {
+            for (int mcuX = 0; mcuX < mcusPerRow; ++mcuX)
+            {
+                if (jpg.RestartInterval > 0)
+                {
+                    if (restartsToGo == 0)
+                    {
+                        if (!ProcessRestart(data, ref nextRestartMarker, ref br, jpg))
+                        {
+                            return false;
+                        }
+
+                        restartsToGo = jpg.RestartInterval;
+                        lastDcCoeff.Clear();
+
+                        if (eobRun > 0)
+                        {
+                            return false;
+                        }
+
+                        eobRun = -1;
+                    }
+
+                    --restartsToGo;
+                }
+
+                for (int i = 0; i < scanInfo.NumComponents; ++i)
+                {
+                    JpegComponentScanInfo si = scanInfo.Components[i];
+                    JpegComponent c = jpg.Components[si.ComponentIndex];
+
+                    ReadOnlySpan<HuffmanTableEntry> dcLut =
+                        dcHuffLut.Slice(
+                            si.DcTableIndex * JpegHuffmanDecoder.LookupSize,
+                            JpegHuffmanDecoder.LookupSize);
+
+                    ReadOnlySpan<HuffmanTableEntry> acLut =
+                        acHuffLut.Slice(
+                            si.AcTableIndex * JpegHuffmanDecoder.LookupSize,
+                            JpegHuffmanDecoder.LookupSize);
+
+                    int nblocksY = isInterleaved ? c.VerticalSampleFactor : 1;
+                    int nblocksX = isInterleaved ? c.HorizontalSampleFactor : 1;
+
+                    for (int iy = 0; iy < nblocksY; ++iy)
+                    {
+                        for (int ix = 0; ix < nblocksX; ++ix)
+                        {
+                            int blockY = (mcuY * nblocksY) + iy;
+                            int blockX = (mcuX * nblocksX) + ix;
+                            int blockIdx = (blockY * c.WidthInBlocks) + blockX;
+
+                            bool resetState = false;
+                            int numZeroRuns = 0;
+
+                            Span<int> coeffs = CollectionsMarshal.AsSpan(c.Coefficients).Slice(blockIdx * JxlFrameDimensions.DctBlockSize, JxlFrameDimensions.DctBlockSize);
+
+                            bool success;
+
+                            if (ah == 0)
+                            {
+                                success = DecodeDCTBlock(
+                                    dcLut,
+                                    acLut,
+                                    ss,
+                                    se,
+                                    al,
+                                    ref eobRun,
+                                    ref resetState,
+                                    ref numZeroRuns,
+                                    ref br,
+                                    ref lastDcCoeff[si.ComponentIndex],
+                                    coeffs);
+                            }
+                            else
+                            {
+                                success = RefineDCTBlock(
+                                    acLut,
+                                    ss,
+                                    se,
+                                    al,
+                                    ref eobRun,
+                                    ref resetState,
+                                    ref br,
+                                    coeffs);
+                            }
+
+                            if (!success)
+                            {
+                                return false;
+                            }
+
+                            if (resetState)
+                            {
+                                scanInfo.ResetPoints.Add(blockScanIndex);
+                            }
+
+                            if (numZeroRuns > 0)
+                            {
+                                scanInfo.ExtraZeroRuns.Add(
+                                    new JpegExtraZeroRunInfo
+                                    {
+                                        BlockIndex = blockScanIndex,
+                                        NumExtraZeroRuns = numZeroRuns
+                                    });
+                            }
+
+                            blockScanIndex++;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (eobRun > 0)
+        {
+            return false;
+        }
+
+        if (!br.FinishStream(jpg, ref pos))
+        {
+            return false;
+        }
+
+        if (pos > len)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static int FindNextMarker(ReadOnlySpan<byte> data, int pos)
+    {
+        int numSkipped = 0;
+
+        while (pos + 1 < data.Length &&
+               (data[pos] != 0xff ||
+                data[pos + 1] < 0xc0 ||
+                IsValidMarkerLookup[data[pos + 1] - 0xc0] == 0))
+        {
+            pos++;
+            numSkipped++;
+        }
+
+        return numSkipped;
+    }
+
+    private static bool FixupIndexes(JpegData jpg)
+    {
+        for (int i = 0; i < jpg.Components.Count; ++i)
+        {
+            JpegComponent c = jpg.Components[i];
+            bool foundIndex = false;
+
+            for (int j = 0; j < jpg.Quant.Count; ++j)
+            {
+                if (jpg.Quant[j].Index == c.QuantIndex)
+                {
+                    c.QuantIndex = j;
+                    foundIndex = true;
+                    break;
+                }
+            }
+
+            if (!foundIndex)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static bool ReadJpeg(ReadOnlySpan<byte> data, JpegReadMode mode, JpegData jpg)
+    {
+        int len = data.Length;
+        int pos = 0;
+
+        ExpectMarker(data, pos);
+
+        int marker = data[pos + 1];
+        pos += 2;
+
+        if (marker != 0xd8)
+        {
+            return false;
+        }
+
+        int lutSize = JpegDataConstants.MaxHuffmanTables * JpegHuffmanDecoder.LookupSize;
+
+        Span<HuffmanTableEntry> dcHuffLut = stackalloc HuffmanTableEntry[lutSize];
+        Span<HuffmanTableEntry> acHuffLut = stackalloc HuffmanTableEntry[lutSize];
+
+        bool foundSof = false;
+        bool foundSos = false;
+        bool foundDri = false;
+
+        Span<ushort> scanProgression = stackalloc ushort[JpegDataConstants.MaxComponents * JxlFrameDimensions.DctBlockSize];
+
+        scanProgression.Clear();
+
+        jpg.PaddingBits.Clear();
+
+        bool isProgressive = false;
+
+        do
+        {
+            int numSkipped = FindNextMarker(data, pos);
+
+            if (numSkipped > 0)
+            {
+                // Add a fake marker to indicate arbitrary
+                // in-between-markers data.
+                jpg.MarkerOrder.Add(0xff);
+                jpg.InterMarkerData.Add([.. data.Slice(pos, numSkipped)]);
+
+                pos += numSkipped;
+            }
+
+            ExpectMarker(data, pos);
+
+            marker = data[pos + 1];
+            pos += 2;
+
+            switch (marker)
+            {
+                case 0xc0:
+                case 0xc1:
+                case 0xc2:
+                    isProgressive = marker == 0xc2;
+
+                    ProcessMarkerSOF(
+                        data,
+                        len,
+                        mode,
+                        ref pos,
+                        jpg);
+
+                    foundSof = true;
+                    break;
+
+                case 0xc4:
+                    ProcessMarkerDHT(
+                            data,
+                            len,
+                            mode,
+                            dcHuffLut,
+                            acHuffLut,
+                            ref pos,
+                            jpg);
+
+                    break;
+
+                case 0xd0:
+                case 0xd1:
+                case 0xd2:
+                case 0xd3:
+                case 0xd4:
+                case 0xd5:
+                case 0xd6:
+                case 0xd7:
+                    // RST markers do not have any data.
+                    break;
+
+                case 0xd9:
+                    // Found end marker.
+                    break;
+
+                case 0xda:
+                    if (mode == JpegReadMode.ReadEverything)
+                    {
+                        if (!ProcessScan(
+                                data,
+                                len,
+                                dcHuffLut,
+                                acHuffLut,
+                                scanProgression,
+                                isProgressive,
+                                ref pos,
+                                jpg))
+                        {
+                            return false;
+                        }
+                    }
+
+                    foundSos = true;
+                    break;
+
+                case 0xdb:
+                    ProcessMarkerDQT(data, len, ref pos, jpg);
+                    break;
+
+                case 0xdd:
+                    ProcessDRI(data, len, ref pos, ref foundDri, jpg);
+                    break;
+
+                case >= 0xe0 and <= 0xef:
+                    if (mode != JpegReadMode.ReadTables)
+                    {
+                        ProcessAPP(data, len, ref pos, jpg);
+                    }
+
+                    break;
+
+                case 0xfe:
+                    if (mode != JpegReadMode.ReadTables)
+                    {
+                        ProcessMarkerCOM(data, len, ref pos, jpg);
+                    }
+
+                    break;
+
+                default:
+                    return false;
+            }
+
+            jpg.MarkerOrder.Add((byte)marker);
+
+            if (mode == JpegReadMode.ReadHeader && foundSof)
+            {
+                break;
+            }
+        }
+        while (marker != 0xd9);
+
+        if (!foundSof || !foundSos)
+        {
+            return false;
+        }
+
+        if (mode == JpegReadMode.ReadEverything)
+        {
+            if (pos < len)
+            {
+                jpg.TailData = [.. data[pos..]];
+            }
+
+            if (!FixupIndexes(jpg))
+            {
+                return false;
+            }
+
+            if (jpg.HuffmanCodes.Count == 0)
+            {
+                return false;
+            }
+
+            if (jpg.HuffmanCodes.Count >= JpegDataConstants.MaxDhtMarkers)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private ref struct BitReaderState
+    {
+        private readonly ReadOnlySpan<byte> data;
+        private readonly int length;
+
+        private int pos;
+        private ulong value;
+        private int bitsLeft;
+        private int nextMarkerPos;
+
+        public BitReaderState(ReadOnlySpan<byte> data, int pos)
+        {
+            this.data = data;
+            this.length = data.Length;
+
+            this.pos = pos;
+            this.value = 0;
+            this.bitsLeft = 0;
+            this.nextMarkerPos = this.length - 2;
+
+            this.FillBitWindow();
+        }
+
+        public int BitsLeft
+        {
+            readonly get => this.bitsLeft;
+            set => this.bitsLeft = value;
+        }
+
+        public ulong Value
+        {
+            readonly get => this.value;
+            set => this.value = value;
+        }
+
+        public void Reset(int pos)
+        {
+            this.pos = pos;
+            this.value = 0;
+            this.bitsLeft = 0;
+            this.nextMarkerPos = this.length - 2;
+
+            this.FillBitWindow();
+        }
+
+        private byte GetNextByte()
+        {
+            if (this.pos >= this.nextMarkerPos)
+            {
+                ++this.pos;
+                return 0;
+            }
+
+            byte c = this.data[this.pos++];
+
+            if (c == 0xff)
+            {
+                byte escape = this.data[this.pos];
+
+                if (escape == 0)
+                {
+                    ++this.pos;
+                }
+                else
+                {
+                    // 0xff followed by a non-zero byte means that we found
+                    // the start of the next marker segment.
+                    this.nextMarkerPos = this.pos - 1;
+                }
+            }
+
+            return c;
+        }
+
+        public void FillBitWindow()
+        {
+            if (this.bitsLeft <= 16)
+            {
+                while (this.bitsLeft <= 56)
+                {
+                    this.value <<= 8;
+                    this.value |= this.GetNextByte();
+                    this.bitsLeft += 8;
+                }
+            }
+        }
+
+        public int ReadBits(int bitCount)
+        {
+            this.FillBitWindow();
+
+            ulong result =
+                (this.value >> (this.bitsLeft - bitCount)) &
+                ((1UL << bitCount) - 1);
+
+            this.bitsLeft -= bitCount;
+            return (int)result;
+        }
+
+        public bool FinishStream(JpegData jpg, ref int pos)
+        {
+            int paddingBitCount = this.bitsLeft & 7;
+
+            if (paddingBitCount > 0)
+            {
+                ulong paddingMask = (1UL << paddingBitCount) - 1;
+                ulong paddingBits =
+                    (this.value >> (this.bitsLeft - paddingBitCount)) &
+                    paddingMask;
+
+                if (paddingBits != paddingMask)
+                {
+                    jpg.HasZeroPaddingBit = true;
+                }
+
+                for (int i = paddingBitCount - 1; i >= 0; --i)
+                {
+                    jpg.PaddingBits.Add((byte)((paddingBits >> i) & 1));
+                }
+            }
+
+            int unusedBytesLeft = this.bitsLeft >> 3;
+
+            while (unusedBytesLeft-- > 0)
+            {
+                --this.pos;
+
+                if (this.pos < this.nextMarkerPos &&
+                    this.data[this.pos] == 0 &&
+                    this.data[this.pos - 1] == 0xff)
+                {
+                    --this.pos;
+                }
+            }
+
+            if (this.pos > this.nextMarkerPos)
+            {
+                return false;
+            }
+
+            pos = this.pos;
+            return true;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationStage.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationStage.cs
new file mode 100644
index 0000000000..4beb4e51cf
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationStage.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal enum JpegSerializationStage : byte
+{
+    Initialize,
+    SerializeSection,
+    Done,
+    Error
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationState.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationState.cs
new file mode 100644
index 0000000000..0636bf28c9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationState.cs
@@ -0,0 +1,40 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal sealed class JpegSerializationState
+{
+    public JpegSerializationStage Stage { get; set; } = JpegSerializationStage.Initialize;
+
+    public int SectionIndex { get; set; }
+
+    public int DhtIndex { get; set; }
+
+    public int DqtIndex { get; set; }
+
+    public int AppIndex { get; set; }
+
+    public int ComIndex { get; set; }
+
+    public int DataIndex { get; set; }
+
+    public int ScanIndex { get; set; }
+
+    public JpegHuffmanCodeTable[] DcHuffTable { get; set; } = [];
+
+    public JpegHuffmanCodeTable[] AcHuffTable { get; set; } = [];
+
+    // Should be field to get ref to it
+    public ReadOnlyMemory<byte> PadBits;
+
+    public int PadBitsPos { get; set; }
+
+    public bool SeenDriMarker { get; set; }
+
+    public bool IsProgressive { get; set; }
+
+    public List<List<byte>> OutputQueue { get; set; } = [];
+
+    public EncodeScanState ScanState { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationStatus.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationStatus.cs
new file mode 100644
index 0000000000..8b7bf5e0e3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegSerializationStatus.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal enum JpegSerializationStatus : byte
+{
+    NeedsMoreInput,
+    NeedsMoreOutput,
+    Error,
+    Done
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegWriter.cs b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegWriter.cs
new file mode 100644
index 0000000000..0df15a4bea
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/JpegWriter.cs
@@ -0,0 +1,1304 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg;
+
+internal class JpegWriter
+{
+    private static void DCTCodingStateInit(JpegDctCodingState state)
+    {
+        state.EobRun = 0;
+        state.CurAcHuff = null;
+        state.RefinementBits.Clear();
+        state.RefinementBitsCount = 0;
+    }
+
+    internal static void Flush(JpegDctCodingState state, JpegBitWriter bw)
+    {
+        if (state.EobRun > 0)
+        {
+            bw.Reserve(16);
+
+            int nBits = JxlMath.FloorLog2Nonzero(state.EobRun);
+            int symbol = nBits << 4;
+
+            WriteSymbol(symbol, state.CurAcHuff!, bw);
+
+            if (nBits > 0)
+            {
+                bw.WriteBits(
+                    nBits,
+                    (ulong)(state.EobRun & ((1 << nBits) - 1)));
+            }
+
+            state.EobRun = 0;
+        }
+
+        const int stride = 124;
+
+        int numWords = state.RefinementBitsCount >> 4;
+        int i = 0;
+
+        while (i < numWords)
+        {
+            int limit = Math.Min(i + stride, numWords);
+
+            bw.Reserve(512);
+
+            for (; i < limit; ++i)
+            {
+                bw.WriteBits(16, state.RefinementBits[i]);
+            }
+        }
+
+        bw.Reserve(16);
+
+        int tail = state.RefinementBitsCount & 0xf;
+
+        if (tail != 0)
+        {
+            bw.WriteBits(
+                tail,
+                state.RefinementBits[^1]);
+        }
+
+        state.RefinementBits.Clear();
+        state.RefinementBitsCount = 0;
+    }
+
+    private static void WriteSymbol(int symbol, JpegHuffmanCodeTable table, JpegBitWriter bw) => bw.WriteBits(
+            table.Depth[symbol],
+            (ulong)table.Code[symbol]);
+
+    private static void WriteSymbolBits(int symbol, JpegHuffmanCodeTable table, JpegBitWriter bw, int nBits, ulong bits) => bw.WriteBits(
+            nBits + table.Depth[symbol],
+            bits | ((ulong)table.Code[symbol] << nBits));
+
+    private static void BufferEndOfBand(JpegDctCodingState state, JpegHuffmanCodeTable acHuff, ReadOnlySpan<int> newBitsArray, JpegBitWriter bw)
+    {
+        if (state.EobRun == 0)
+        {
+            state.CurAcHuff = acHuff;
+        }
+
+        ++state.EobRun;
+
+        if (!newBitsArray.IsEmpty)
+        {
+            ulong newBits = 0;
+
+            for (int i = 0; i < newBitsArray.Length; ++i)
+            {
+                newBits = (newBits << 1) | (uint)newBitsArray[i];
+            }
+
+            int tail = state.RefinementBitsCount & 0xf;
+
+            if (tail != 0)
+            {
+                int stuffBitsCount = Math.Min(16 - tail, newBitsArray.Length);
+                ushort stuffBits = (ushort)(newBits >> (newBitsArray.Length - stuffBitsCount));
+
+                stuffBits &= (ushort)((1 << stuffBitsCount) - 1);
+
+                int last = state.RefinementBits.Count - 1;
+
+                state.RefinementBits[last] = (ushort)((state.RefinementBits[last] << stuffBitsCount) | stuffBits);
+
+                state.RefinementBitsCount += stuffBitsCount;
+
+                newBitsArray = newBitsArray[stuffBitsCount..];
+            }
+
+            int newBitsCount = newBitsArray.Length;
+
+            while (newBitsCount >= 16)
+            {
+                state.RefinementBits.Add((ushort)(newBits >> (newBitsCount - 16)));
+
+                newBitsCount -= 16;
+                state.RefinementBitsCount += 16;
+            }
+
+            if (newBitsCount != 0)
+            {
+                state.RefinementBits.Add((ushort)(newBits & ((1u << newBitsCount) - 1)));
+
+                state.RefinementBitsCount += newBitsCount;
+            }
+        }
+
+        if (state.EobRun == 0x7fff)
+        {
+            Flush(state, bw);
+        }
+    }
+
+    private static bool BuildJpegHuffmanCodeTable(JpegHuffmanCode huff, JpegHuffmanCodeTable table)
+    {
+        Span<int> huffCode = stackalloc int[JpegDataConstants.JpegHuffmanAlphabetSize];
+        Span<uint> huffSize = stackalloc uint[JpegDataConstants.JpegHuffmanAlphabetSize + 1];
+
+        int p = 0;
+
+        for (int l = 1; l <= JpegDataConstants.JpegHuffmanMaxBitLength; ++l)
+        {
+            int count = huff.Counts[l];
+
+            if (p + count > JpegDataConstants.JpegHuffmanAlphabetSize + 1)
+            {
+                return false;
+            }
+
+            while (count-- > 0)
+            {
+                huffSize[p++] = (uint)l;
+            }
+        }
+
+        if (p == 0)
+        {
+            return true;
+        }
+
+        int lastP = p - 1;
+        huffSize[lastP] = 0;
+
+        int code = 0;
+        uint si = huffSize[0];
+        p = 0;
+
+        while (huffSize[p] != 0)
+        {
+            while (huffSize[p] == si)
+            {
+                huffCode[p++] = code++;
+            }
+
+            code <<= 1;
+            ++si;
+        }
+
+        for (p = 0; p < lastP; ++p)
+        {
+            int value = huff.Values[p];
+            table.Depth[value] = (byte)huffSize[p];
+            table.Code[value] = (short)huffCode[p];
+        }
+
+        return true;
+    }
+
+    private static bool EncodeSOI(JpegSerializationState state)
+    {
+        state.OutputQueue.Add([0xff, 0xd8]);
+        return true;
+    }
+
+    private static bool EncodeEOI(JpegData jpg, JpegSerializationState state)
+    {
+        state.OutputQueue.Add([0xff, 0xd9]);
+        state.OutputQueue.Add(jpg.TailData);
+        return true;
+    }
+
+    private static bool EncodeRestart(byte marker, JpegSerializationState state)
+    {
+        state.OutputQueue.Add([0xff, marker]);
+        return true;
+    }
+
+    private static bool EncodeSOF(JpegData jpg, byte marker, JpegSerializationState state)
+    {
+        if (marker <= 0xc2)
+        {
+            state.IsProgressive = marker == 0xc2;
+        }
+
+        int componentCount = jpg.Components.Count;
+        int markerLength = 8 + (3 * componentCount);
+
+        state.OutputQueue.Add([(byte)(markerLength + 2)]);
+
+        Span<byte> data = CollectionsMarshal.AsSpan(state.OutputQueue[^1]);
+        int pos = 10;
+
+        data[0] = 0xff;
+        data[1] = marker;
+        data[2] = (byte)(markerLength >> 8);
+        data[3] = (byte)markerLength;
+        data[4] = JpegPrecision;
+        data[5] = (byte)(jpg.Height >> 8);
+        data[6] = (byte)jpg.Height;
+        data[7] = (byte)(jpg.Width >> 8);
+        data[8] = (byte)jpg.Width;
+        data[9] = (byte)componentCount;
+
+        for (int i = 0; i < componentCount; ++i)
+        {
+            JpegComponent component = jpg.Components[i];
+
+            data[pos++] = (byte)component.Id;
+            data[pos++] = (byte)((component.HorizontalSampleFactor << 4) | component.VerticalSampleFactor);
+
+            int quantIndex = component.QuantIndex;
+
+            if ((uint)quantIndex >= (uint)jpg.Quant.Count)
+            {
+                return false;
+            }
+
+            data[pos++] = (byte)jpg.Quant[quantIndex].Index;
+        }
+
+        return true;
+    }
+
+    private static bool EncodeSOS(JpegData jpg, JpegScanInfo scanInfo, JpegSerializationState state)
+    {
+        int scanCount = scanInfo.NumComponents;
+        int markerLength = 6 + (2 * scanCount);
+
+        state.OutputQueue.Add([(byte)(markerLength + 2)]);
+
+        Span<byte> data = CollectionsMarshal.AsSpan(state.OutputQueue[^1]);
+        int pos = 5;
+
+        data[0] = 0xff;
+        data[1] = 0xda;
+        data[2] = (byte)(markerLength >> 8);
+        data[3] = (byte)markerLength;
+        data[4] = (byte)scanCount;
+
+        for (int i = 0; i < scanCount; ++i)
+        {
+            JpegComponentScanInfo si = scanInfo.Components[i];
+
+            if ((uint)si.ComponentIndex >= (uint)jpg.Components.Count)
+            {
+                return false;
+            }
+
+            data[pos++] = (byte)jpg.Components[si.ComponentIndex].Id;
+            data[pos++] = (byte)((si.DcTableIndex << 4) + si.AcTableIndex);
+        }
+
+        data[pos++] = (byte)scanInfo.Ss;
+        data[pos++] = (byte)scanInfo.Se;
+        data[pos++] = (byte)((scanInfo.Ah << 4) | scanInfo.Al);
+
+        return true;
+    }
+
+    private static bool EncodeDHT(JpegData jpg, JpegSerializationState state)
+    {
+        List<JpegHuffmanCode> huffmanCode = jpg.HuffmanCodes;
+
+        int markerLength = 2;
+
+        for (int i = state.DhtIndex; i < huffmanCode.Count; ++i)
+        {
+            JpegHuffmanCode huff = huffmanCode[i];
+
+            for (int j = 0; j < 17; ++j)
+            {
+                markerLength += huff.Counts[j];
+            }
+
+            // Empty DHT marker.
+            if (markerLength == 2)
+            {
+                break;
+            }
+
+            markerLength += JpegDataConstants.JpegHuffmanMaxBitLength;
+
+            if (huff.IsLast)
+            {
+                break;
+            }
+        }
+
+        state.OutputQueue.Add([(byte)(markerLength + 2)]);
+
+        Span<byte> data = CollectionsMarshal.AsSpan(state.OutputQueue[^1]);
+        int pos = 4;
+
+        data[0] = 0xff;
+        data[1] = 0xc4;
+        data[2] = (byte)(markerLength >> 8);
+        data[3] = (byte)markerLength;
+
+        while (true)
+        {
+            int huffmanCodeIndex = state.DhtIndex++;
+
+            if ((uint)huffmanCodeIndex >= (uint)huffmanCode.Count)
+            {
+                return false;
+            }
+
+            JpegHuffmanCode huff = huffmanCode[huffmanCodeIndex];
+
+            int index = huff.SlotId;
+            JpegHuffmanCodeTable huffTable = new();
+
+            int totalCount = 0;
+            int maxLength = 0;
+
+            for (int i = 0; i < 17; ++i)
+            {
+                if (huff.Counts[i] != 0)
+                {
+                    maxLength = i;
+                }
+
+                totalCount += huff.Counts[i];
+            }
+
+            // Empty DHT marker.
+            if (totalCount == 0)
+            {
+                break;
+            }
+
+            if ((index & 0x10) != 0)
+            {
+                index -= 0x10;
+                huffTable = state.AcHuffTable[index];
+            }
+            else
+            {
+                huffTable = state.DcHuffTable[index];
+            }
+
+            huffTable.InitializeDepths(127);
+
+            if (!BuildJpegHuffmanCodeTable(huff, huffTable))
+            {
+                return false;
+            }
+
+            huffTable.Initialized = true;
+
+            --totalCount;
+
+            data[pos++] = (byte)huff.SlotId;
+
+            for (int i = 1; i <= JpegDataConstants.JpegHuffmanMaxBitLength; ++i)
+            {
+                data[pos++] = (byte)(i == maxLength ? huff.Counts[i] - 1 : huff.Counts[i]);
+            }
+
+            for (int i = 0; i < totalCount; ++i)
+            {
+                data[pos++] = (byte)huff.Values[i];
+            }
+
+            if (huff.IsLast)
+            {
+                break;
+            }
+        }
+
+        return true;
+    }
+
+    private static bool EncodeDQT(JpegData jpg, JpegSerializationState state)
+    {
+        int markerLength = 2;
+
+        for (int i = state.DqtIndex; i < jpg.Quant.Count; ++i)
+        {
+            JpegQuantizationTable table = jpg.Quant[i];
+
+            markerLength += 1 + ((table.Precision != 0 ? 2 : 1) * JxlFrameDimensions.DctBlockSize);
+
+            if (table.IsLast)
+            {
+                break;
+            }
+        }
+
+        state.OutputQueue.Add([(byte)(markerLength + 2)]);
+
+        Span<byte> data = CollectionsMarshal.AsSpan(state.OutputQueue[^1]);
+        int pos = 4;
+
+        data[0] = 0xff;
+        data[1] = 0xdb;
+        data[2] = (byte)(markerLength >> 8);
+        data[3] = (byte)markerLength;
+
+        while (true)
+        {
+            int index = state.DqtIndex++;
+
+            if ((uint)index >= (uint)jpg.Quant.Count)
+            {
+                return false;
+            }
+
+            JpegQuantizationTable table = jpg.Quant[index];
+
+            data[pos++] = (byte)((table.Precision << 4) + table.Index);
+
+            for (int i = 0; i < JxlFrameDimensions.DctBlockSize; ++i)
+            {
+                int valueIndex = JpegDataConstants.JpegNaturalOrder[i];
+                int value = table.Values[valueIndex];
+
+                if (table.Precision != 0)
+                {
+                    data[pos++] = (byte)(value >> 8);
+                }
+
+                data[pos++] = (byte)value;
+            }
+
+            if (table.IsLast)
+            {
+                break;
+            }
+        }
+
+        return true;
+    }
+
+    private static bool EncodeDRI(JpegData jpg, JpegSerializationState state)
+    {
+        state.SeenDriMarker = true;
+
+        List<byte> driMarker =
+        [
+            0xff,
+            0xdd,
+            0,
+            4,
+            (byte)(jpg.RestartInterval >> 8),
+            (byte)jpg.RestartInterval
+        ];
+
+        state.OutputQueue.Add(driMarker);
+        return true;
+    }
+
+    private static bool EncodeAPP(JpegData jpg, byte marker, JpegSerializationState state)
+    {
+        // TODO: Check that marker corresponds to payload.
+        _ = marker;
+
+        int appIndex = state.AppIndex++;
+
+        if ((uint)appIndex >= (uint)jpg.AppData.Count)
+        {
+            return false;
+        }
+
+        state.OutputQueue.Add([0xff]);
+        state.OutputQueue.Add(jpg.AppData[appIndex]);
+
+        return true;
+    }
+
+    private static bool EncodeCOM(JpegData jpg, JpegSerializationState state)
+    {
+        int comIndex = state.ComIndex++;
+
+        if ((uint)comIndex >= (uint)jpg.ComData.Count)
+        {
+            return false;
+        }
+
+        state.OutputQueue.Add([0xff]);
+        state.OutputQueue.Add(jpg.ComData[comIndex]);
+
+        return true;
+    }
+
+    private static bool EncodeInterMarkerData(JpegData jpg, JpegSerializationState state)
+    {
+        int index = state.DataIndex++;
+
+        if ((uint)index >= (uint)jpg.InterMarkerData.Count)
+        {
+            return false;
+        }
+
+        state.OutputQueue.Add(jpg.InterMarkerData[index]);
+
+        return true;
+    }
+
+    private static bool EncodeDCTBlockSequential(ReadOnlySpan<int> coeffs, JpegHuffmanCodeTable dcHuff, JpegHuffmanCodeTable acHuff, int numZeroRuns, ref int lastDcCoeff, JpegBitWriter bw)
+    {
+        int temp2;
+        int temp;
+        int litmus = 0;
+
+        temp2 = coeffs[0];
+        temp = temp2 - lastDcCoeff;
+        lastDcCoeff = temp2;
+
+        temp2 = temp >> ((8 * sizeof(int)) - 1);
+        temp += temp2;
+        temp2 ^= temp;
+
+        int dcNBits = temp2 == 0 ? 0 : JxlMath.FloorLog2Nonzero(temp2) + 1;
+
+        WriteSymbol(dcNBits, dcHuff, bw);
+
+        if (dcNBits != 0)
+        {
+            bw.WriteBits(dcNBits, (ulong)(temp & ((1 << dcNBits) - 1)));
+        }
+
+        int r = 0;
+
+        for (int i = 1; i < JxlFrameDimensions.DctBlockSize; ++i)
+        {
+            temp = coeffs[JpegDataConstants.JpegNaturalOrder[i]];
+
+            if (temp == 0)
+            {
+                ++r;
+            }
+            else
+            {
+                temp2 = temp >> ((8 * sizeof(int)) - 1);
+                temp += temp2;
+                temp2 ^= temp;
+
+                if (r > 15)
+                {
+                    WriteSymbol(0xf0, acHuff, bw);
+                    r -= 16;
+
+                    if (r > 15)
+                    {
+                        WriteSymbol(0xf0, acHuff, bw);
+                        r -= 16;
+                    }
+
+                    if (r > 15)
+                    {
+                        WriteSymbol(0xf0, acHuff, bw);
+                        r -= 16;
+                    }
+                }
+
+                litmus |= temp2;
+
+                int acNBits = (int)JxlMath.FloorLog2Nonzero((uint)(ushort)temp2) + 1;
+                int symbol = (r << 4) + acNBits;
+
+                WriteSymbolBits(
+                    symbol,
+                    acHuff,
+                    bw,
+                    acNBits,
+                    (ulong)(temp & ((1 << acNBits) - 1)));
+
+                r = 0;
+            }
+        }
+
+        for (int i = 0; i < numZeroRuns; ++i)
+        {
+            WriteSymbol(0xf0, acHuff, bw);
+            r -= 16;
+        }
+
+        if (r > 0)
+        {
+            WriteSymbol(0, acHuff, bw);
+        }
+
+        return litmus >= 0;
+    }
+
+    private static bool EncodeDCTBlockProgressive(
+        ReadOnlySpan<int> coeffs,
+        JpegHuffmanCodeTable dcHuff,
+        JpegHuffmanCodeTable acHuff,
+        int ss,
+        int se,
+        int al,
+        int numZeroRuns,
+        JpegDctCodingState codingState,
+        ref int lastDcCoeff,
+        JpegBitWriter bw)
+    {
+        bool eobRunAllowed = ss > 0;
+
+        int temp2;
+        int temp;
+
+        if (ss == 0)
+        {
+            temp2 = coeffs[0] >> al;
+            temp = temp2 - lastDcCoeff;
+            lastDcCoeff = temp2;
+
+            temp2 = temp;
+
+            if (temp < 0)
+            {
+                temp = -temp;
+
+                if (temp < 0)
+                {
+                    return false;
+                }
+
+                --temp2;
+            }
+
+            int nBits = temp == 0
+                ? 0
+                : JxlMath.FloorLog2Nonzero(temp) + 1;
+
+            WriteSymbol(nBits, dcHuff, bw);
+
+            if (nBits != 0)
+            {
+                bw.WriteBits(nBits, (ulong)(temp2 & ((1 << nBits) - 1)));
+            }
+
+            ++ss;
+        }
+
+        if (ss > se)
+        {
+            return true;
+        }
+
+        int r = 0;
+
+        for (int k = ss; k <= se; ++k)
+        {
+            temp = coeffs[JpegDataConstants.JpegNaturalOrder[k]];
+
+            if (temp == 0)
+            {
+                ++r;
+                continue;
+            }
+
+            if (temp < 0)
+            {
+                temp = -temp;
+
+                if (temp < 0)
+                {
+                    return false;
+                }
+
+                temp >>= al;
+                temp2 = ~temp;
+            }
+            else
+            {
+                temp >>= al;
+                temp2 = temp;
+            }
+
+            if (temp == 0)
+            {
+                ++r;
+                continue;
+            }
+
+            codingState.Flush(bw);
+
+            while (r > 15)
+            {
+                WriteSymbol(0xf0, acHuff, bw);
+                r -= 16;
+            }
+
+            int nBits = JxlMath.FloorLog2Nonzero(temp) + 1;
+            int symbol = (r << 4) + nBits;
+
+            WriteSymbol(symbol, acHuff, bw);
+            bw.WriteBits(nBits, (ulong)(temp2 & ((1 << nBits) - 1)));
+
+            r = 0;
+        }
+
+        if (numZeroRuns > 0)
+        {
+            codingState.Flush(bw);
+
+            for (int i = 0; i < numZeroRuns; ++i)
+            {
+                WriteSymbol(0xf0, acHuff, bw);
+                r -= 16;
+            }
+        }
+
+        if (r > 0)
+        {
+            BufferEndOfBand(
+                codingState,
+                acHuff,
+                [],
+                bw);
+
+            if (!eobRunAllowed)
+            {
+                codingState.Flush(bw);
+            }
+        }
+
+        return true;
+    }
+
+    private static bool EncodeRefinementBits(
+        ReadOnlySpan<int> coeffs,
+        JpegHuffmanCodeTable acHuff,
+        int ss,
+        int se,
+        int al,
+        JpegDctCodingState codingState,
+        JpegBitWriter bw)
+    {
+        bool eobRunAllowed = ss > 0;
+
+        if (ss == 0)
+        {
+            // Emit next bit of DC component.
+            bw.WriteBits(1, (ulong)((coeffs[0] >> al) & 1));
+
+            ++ss;
+        }
+
+        if (ss > se)
+        {
+            return true;
+        }
+
+        Span<int> absValues = stackalloc int[JxlFrameDimensions.DctBlockSize];
+
+        int eob = 0;
+
+        for (int k = ss; k <= se; ++k)
+        {
+            int absValue = Numerics.Abs(coeffs[JpegDataConstants.JpegNaturalOrder[k]]);
+
+            absValues[k] = absValue >> al;
+
+            if (absValues[k] == 1)
+            {
+                eob = k;
+            }
+        }
+
+        int r = 0;
+
+        Span<int> refinementBits = stackalloc int[JxlFrameDimensions.DctBlockSize];
+
+        int refinementBitsCount = 0;
+
+        for (int k = ss; k <= se; ++k)
+        {
+            if (absValues[k] == 0)
+            {
+                ++r;
+                continue;
+            }
+
+            while (r > 15 && k <= eob)
+            {
+                codingState.Flush(bw);
+
+                WriteSymbol(0xf0, acHuff, bw);
+                r -= 16;
+
+                for (int i = 0; i < refinementBitsCount; ++i)
+                {
+                    bw.WriteBits(1, (ulong)refinementBits[i]);
+                }
+
+                refinementBitsCount = 0;
+            }
+
+            if (absValues[k] > 1)
+            {
+                refinementBits[refinementBitsCount++] =
+                    absValues[k] & 1;
+
+                continue;
+            }
+
+            codingState.Flush(bw);
+
+            int symbol = (r << 4) + 1;
+
+            int newNonZeroBit = coeffs[JpegDataConstants.JpegNaturalOrder[k]] < 0 ? 0 : 1;
+
+            WriteSymbol(symbol, acHuff, bw);
+            bw.WriteBits(1, (ulong)newNonZeroBit);
+
+            for (int i = 0; i < refinementBitsCount; ++i)
+            {
+                bw.WriteBits(1, (ulong)refinementBits[i]);
+            }
+
+            refinementBitsCount = 0;
+            r = 0;
+        }
+
+        if (r > 0 || refinementBitsCount != 0)
+        {
+            BufferEndOfBand(
+                codingState,
+                acHuff,
+                refinementBits,
+                bw);
+
+            if (!eobRunAllowed)
+            {
+                codingState.Flush(bw);
+            }
+        }
+
+        return true;
+    }
+
+    private static JpegSerializationStatus DoEncodeScan(
+        JpegData jpg,
+        JpegSerializationState state,
+        int mode)
+    {
+        JpegScanInfo scanInfo = jpg.ScanInfos[state.ScanIndex];
+        EncodeScanState ss = state.ScanState;
+
+        int restartInterval = state.SeenDriMarker
+            ? jpg.RestartInterval
+            : 0;
+
+        int GetNextExtraZeroRunIndex()
+        {
+            if (ss.ExtraZeroRunsPos < scanInfo.ExtraZeroRuns.Count)
+            {
+                return scanInfo.ExtraZeroRuns[ss.ExtraZeroRunsPos].BlockIdx;
+            }
+
+            return -1;
+        }
+
+        int GetNextResetPoint()
+        {
+            if (ss.NextResetPointPos < scanInfo.ResetPoints.Count)
+            {
+                return scanInfo.ResetPoints[ss.NextResetPointPos++];
+            }
+
+            return -1;
+        }
+
+        if (ss.Stage == EncodeScanState.StageHead)
+        {
+            if (!EncodeSOS(jpg, scanInfo, state))
+            {
+                return JpegSerializationStatus.Error;
+            }
+
+            ss.Bw = new JpegBitWriter();
+            ss.CodingState = new JpegDctCodingState();
+            ss.RestartsToGo = restartInterval;
+            ss.NextRestartMarker = 0;
+            ss.BlockScanIndex = 0;
+            ss.ExtraZeroRunsPos = 0;
+            ss.NextExtraZeroRunIndex = GetNextExtraZeroRunIndex();
+            ss.NextResetPointPos = 0;
+            ss.NextResetPoint = GetNextResetPoint();
+            ss.McuY = 0;
+            ss.LastDcCoeff.AsSpan().Clear();
+            ss.Stage = EncodeScanState.StageBody;
+        }
+
+        JpegBitWriter bw = ss.Bw;
+        JpegDctCodingState codingState = ss.CodingState;
+
+        if (ss.Stage != EncodeScanState.StageBody)
+        {
+            return JpegSerializationStatus.Error;
+        }
+
+        bool isInterleaved = scanInfo.NumComponents > 1;
+
+        jpg.CalculateMcuSize(scanInfo, out int mcusPerRow, out int mcuRows);
+
+        bool isProgressive = state.IsProgressive;
+        int al = isProgressive ? scanInfo.Al : 0;
+        int ssValue = isProgressive ? scanInfo.Ss : 0;
+        int se = isProgressive ? scanInfo.Se : 63;
+
+        bool wantAc = ssValue != 0 || se != 0;
+        bool wantDc = ssValue == 0;
+
+        bool completeAc = true;
+        bool hasAc = true;
+
+        if (wantAc && !hasAc)
+        {
+            return JpegSerializationStatus.NeedsMoreInput;
+        }
+
+        bool completeDc = hasAc;
+        bool complete = wantAc ? completeAc : completeDc;
+
+        _ = complete;
+
+        int lastMcuY = complete ? mcuRows : 0;
+
+        for (; ss.McuY < lastMcuY; ++ss.McuY)
+        {
+            for (int mcuX = 0; mcuX < mcusPerRow; ++mcuX)
+            {
+                if (restartInterval > 0 && ss.RestartsToGo == 0)
+                {
+                    codingState.Flush(bw);
+
+                    if (!bw.JumpToByteBoundary(ref state.PadBits))
+                    {
+                        return JpegSerializationStatus.Error;
+                    }
+
+                    bw.EmitMarker((byte)(0xd0 + ss.NextRestartMarker));
+
+                    ss.NextRestartMarker++;
+                    ss.NextRestartMarker &= 0x7;
+                    ss.RestartsToGo = restartInterval;
+                    ss.LastDcCoeff.AsSpan().Clear();
+                }
+
+                // Encode one MCU.
+                for (int i = 0; i < scanInfo.NumComponents; ++i)
+                {
+                    JpegComponentScanInfo si = scanInfo.Components[i];
+                    JpegComponent c = jpg.Components[si.ComponentIndex];
+
+                    int dcTblIdx = si.DcTableIndex;
+                    int acTblIdx = si.AcTableIndex;
+
+                    JpegHuffmanCodeTable dcHuff = state.DcHuffTable[dcTblIdx];
+                    JpegHuffmanCodeTable acHuff = state.AcHuffTable[acTblIdx];
+
+                    if (wantDc && !dcHuff.Initialized)
+                    {
+                        return JpegSerializationStatus.Error;
+                    }
+
+                    if (wantAc && !acHuff.Initialized)
+                    {
+                        return JpegSerializationStatus.Error;
+                    }
+
+                    int nBlocksY = isInterleaved ? c.VerticalSampleFactor : 1;
+                    int nBlocksX = isInterleaved ? c.HorizontalSampleFactor : 1;
+
+                    for (int iy = 0; iy < nBlocksY; ++iy)
+                    {
+                        for (int ix = 0; ix < nBlocksX; ++ix)
+                        {
+                            int blockY = (ss.McuY * nBlocksY) + iy;
+                            int blockX = (mcuX * nBlocksX) + ix;
+                            int blockIdx = (blockY * c.WidthInBlocks) + blockX;
+
+                            if (ss.BlockScanIndex == ss.NextResetPoint)
+                            {
+                                codingState.Flush(bw);
+                                ss.NextResetPoint = GetNextResetPoint();
+                            }
+
+                            int numZeroRuns = 0;
+
+                            if (ss.BlockScanIndex == ss.NextExtraZeroRunIndex)
+                            {
+                                numZeroRuns = scanInfo.ExtraZeroRuns[ss.ExtraZeroRunsPos].NumExtraZeroRuns;
+                                ++ss.ExtraZeroRunsPos;
+                                ss.NextExtraZeroRunIndex = GetNextExtraZeroRunIndex();
+                            }
+
+                            ReadOnlySpan<int> coeffs = CollectionsMarshal.AsSpan(c.Coefficients).Slice(blockIdx << 6, JxlFrameDimensions.DctBlockSize);
+
+                            bool ok;
+
+                            bw.Reserve(512);
+
+                            if (mode == 0)
+                            {
+                                ok = EncodeDCTBlockSequential(
+                                    coeffs,
+                                    dcHuff,
+                                    acHuff,
+                                    numZeroRuns,
+                                    ref ss.LastDcCoeff[si.ComponentIndex],
+                                    bw);
+                            }
+                            else if (mode == 1)
+                            {
+                                ok = EncodeDCTBlockProgressive(
+                                    coeffs,
+                                    dcHuff,
+                                    acHuff,
+                                    ssValue,
+                                    se,
+                                    al,
+                                    numZeroRuns,
+                                    codingState,
+                                    ref ss.LastDcCoeff[si.ComponentIndex],
+                                    bw);
+                            }
+                            else
+                            {
+                                ok = EncodeRefinementBits(
+                                    coeffs,
+                                    acHuff,
+                                    ssValue,
+                                    se,
+                                    al,
+                                    codingState,
+                                    bw);
+                            }
+
+                            if (!ok)
+                            {
+                                return JpegSerializationStatus.Error;
+                            }
+
+                            ++ss.BlockScanIndex;
+                        }
+                    }
+                }
+
+                --ss.RestartsToGo;
+            }
+        }
+
+        if (ss.McuY < mcuRows)
+        {
+            if (!bw.Healthy)
+            {
+                return JpegSerializationStatus.Error;
+            }
+
+            return JpegSerializationStatus.NeedsMoreInput;
+        }
+
+        codingState.Flush(bw);
+
+        if (!bw.JumpToByteBoundary(
+                ref state.PadBits,
+                state.PadBitsEnd))
+        {
+            return JpegSerializationStatus.Error;
+        }
+
+        bw.Finish();
+
+        ss.Stage = EncodeScanState.StageHead;
+        ++state.ScanIndex;
+
+        if (!bw.Healthy)
+        {
+            return JpegSerializationStatus.Error;
+        }
+
+        return JpegSerializationStatus.Done;
+    }
+
+    private static JpegSerializationStatus EncodeScan(JpegData jpg, JpegSerializationState state)
+    {
+        JpegScanInfo scanInfo = jpg.ScanInfos[state.ScanIndex];
+
+        bool isProgressive = state.IsProgressive;
+
+        int al = isProgressive ? scanInfo.Al : 0;
+        int ah = isProgressive ? scanInfo.Ah : 0;
+        int ss = isProgressive ? scanInfo.Ss : 0;
+        int se = isProgressive ? scanInfo.Se : 63;
+
+        bool needSequential =
+            !isProgressive ||
+            (ah == 0 &&
+             al == 0 &&
+             ss == 0 &&
+             se == 63);
+
+        if (needSequential)
+        {
+            return DoEncodeScan(jpg, state, 0);
+        }
+
+        if (ah == 0)
+        {
+            return DoEncodeScan(jpg, state, 1);
+        }
+
+        return DoEncodeScan(jpg, state, 2);
+    }
+
+    private static JpegSerializationStatus SerializeSection(byte marker, JpegSerializationState state, JpegData jpg)
+    {
+        static JpegSerializationStatus ToStatus(bool result) =>
+            result
+                ? JpegSerializationStatus.Done
+                : JpegSerializationStatus.Error;
+
+        return marker switch
+        {
+            0xc0 or 0xc1 or 0xc2 or 0xc9 or 0xca => ToStatus(EncodeSOF(jpg, marker, state)),
+            0xc4 => ToStatus(EncodeDHT(jpg, state)),
+            0xd0 or 0xd1 or 0xd2 or 0xd3 or 0xd4 or 0xd5 or 0xd6 or 0xd7 => ToStatus(EncodeRestart(marker, state)),
+            0xd9 => ToStatus(EncodeEOI(jpg, state)),
+            0xda => EncodeScan(jpg, state),
+            0xdb => ToStatus(EncodeDQT(jpg, state)),
+            0xdd => ToStatus(EncodeDRI(jpg, state)),
+            0xe0 or 0xe1 or 0xe2 or 0xe3 or 0xe4 or 0xe5 or 0xe6 or 0xe7 or 0xe8 or 0xe9 or 0xea or 0xeb or 0xec or 0xed or 0xee or 0xef => ToStatus(EncodeAPP(jpg, marker, state)),
+            0xfe => ToStatus(EncodeCOM(jpg, state)),
+            0xff => ToStatus(EncodeInterMarkerData(jpg, state)),
+            _ => JpegSerializationStatus.Error,
+        };
+    }
+
+    private static bool WriteJpegInternal(JpegData jpg, JpegOutput output, JpegSerializationState state)
+    {
+        bool MaybePushOutput()
+        {
+            if (state.Stage != JpegSerializationStage.Error)
+            {
+                while (state.OutputQueue.Count > 0)
+                {
+                    List<byte> chunk = state.OutputQueue[0];
+
+                    int numWritten = output.Write(
+                        chunk.Next,
+                        chunk.Count);
+
+                    if (numWritten == 0 && chunk.Count > 0)
+                    {
+                        return false;
+                    }
+
+                    if (chunk.Count - numWritten == 0)
+                    {
+                        state.OutputQueue.RemoveAt(0);
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        while (true)
+        {
+            switch (state.Stage)
+            {
+                case JpegSerializationStage.Initialize:
+                {
+                    // Valid Brunsli requires at least the 0xD9 marker.
+                    // This might happen on a corrupted stream or unconditioned JPEGData.
+                    if (jpg.MarkerOrder.Count == 0)
+                    {
+                        state.Stage = JpegSerializationStage.Error;
+                        break;
+                    }
+
+                    state.DcHuffTable = new JpegHuffmanCodeTable[JpegDataConstants.MaxHuffmanTables];
+                    state.AcHuffTable = new JpegHuffmanCodeTable[JpegDataConstants.MaxHuffmanTables];
+
+                    if (jpg.HasZeroPaddingBit)
+                    {
+                        state.PadBits = jpg.PaddingBits;
+                    }
+
+                    _ = EncodeSOI(state);
+
+                    if (!MaybePushOutput())
+                    {
+                        return false;
+                    }
+
+                    state.Stage = JpegSerializationStage.SerializeSection;
+
+                    break;
+                }
+
+                case JpegSerializationStage.SerializeSection:
+                {
+                    if (state.SectionIndex >= jpg.MarkerOrder.Count)
+                    {
+                        state.Stage = JpegSerializationStage.Done;
+                        break;
+                    }
+
+                    byte marker = jpg.MarkerOrder[state.SectionIndex];
+
+                    JpegSerializationStatus status =
+                        SerializeSection(marker, state, jpg);
+
+                    if (status == JpegSerializationStatus.Error)
+                    {
+                        state.Stage = JpegSerializationStage.Error;
+                        break;
+                    }
+
+                    if (!MaybePushOutput())
+                    {
+                        return false;
+                    }
+
+                    if (status == JpegSerializationStatus.NeedsMoreInput)
+                    {
+                        return false;
+                    }
+
+                    if (status != JpegSerializationStatus.Done)
+                    {
+                        state.Stage = JpegSerializationStage.Error;
+                        return false;
+                    }
+
+                    ++state.SectionIndex;
+                    break;
+                }
+
+                case JpegSerializationStage.Done:
+                {
+                    if (state.OutputQueue.Count != 0)
+                    {
+                        return false;
+                    }
+
+                    if (state.PadBits.Length != 0)
+                    {
+                        return false;
+                    }
+
+                    return true;
+                }
+
+                case JpegSerializationStage.Error:
+                    return false;
+
+                default:
+                    return false;
+            }
+        }
+    }
+
+    public static bool WriteJpeg(JpegData jpg, JpegOutput output)
+    {
+        JpegSerializationState state = new();
+        return WriteJpegInternal(jpg, output, state);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Jpeg/README.md b/src/ImageSharp/Formats/Jxl/IO/Jpeg/README.md
new file mode 100644
index 0000000000..bde5de389e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Jpeg/README.md
@@ -0,0 +1,11 @@
+# Jxl/Processing/Jpeg
+This folder contains logic to:
+
+- Parse and represent JPEG data
+- Write JPEG markers
+- JPEG to JXL
+- JXL to JPEG
+
+This does not contain a JPEG codec.
+
+Logic in this folder is used for JPEG&lt;-&gt;JXL lossless compression.
diff --git a/src/ImageSharp/Formats/Jxl/IO/JxlBoxCodingMode.cs b/src/ImageSharp/Formats/Jxl/IO/JxlBoxCodingMode.cs
new file mode 100644
index 0000000000..412d18a8aa
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/JxlBoxCodingMode.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO;
+
+/// <summary>
+/// Specifies the type of box content.
+/// </summary>
+internal enum JxlBoxCodingMode : byte
+{
+    /// <summary>
+    /// Compress using Brotli codec.
+    /// </summary>
+    Brotli,
+
+    /// <summary>
+    /// No compression (raw contents).
+    /// </summary>
+    Uncompressed
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/JxlDataType.cs b/src/ImageSharp/Formats/Jxl/IO/JxlDataType.cs
new file mode 100644
index 0000000000..7370f1b25b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/JxlDataType.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO;
+
+/// <summary>
+/// Specifies which data type to use for sample values
+/// per channel per pixel.
+/// </summary>
+internal enum JxlDataType : byte
+{
+    /// <summary>
+    /// Use float
+    /// </summary>
+    Single = 0,
+
+    /// <summary>
+    /// Use byte. May clip wide color gamut data.
+    /// </summary>
+    Byte = 2,
+
+    /// <summary>
+    /// Use ushort. May clip wide color gamut data.
+    /// </summary>
+    UInt16 = 3,
+
+    /// <summary>
+    /// Use 16-bit IEEE 754 half-precision floating-point values.
+    /// </summary>
+    Half = 5
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/JxlHuffman.cs b/src/ImageSharp/Formats/Jxl/IO/JxlHuffman.cs
new file mode 100644
index 0000000000..678321bab8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/JxlHuffman.cs
@@ -0,0 +1,184 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO;
+
+/// <summary>
+/// Shared Huffman I/O utilities.
+/// </summary>
+internal static class JxlHuffman
+{
+    /// <summary>
+    /// Returns Reverse(Reverse(Key, Len) + 1, Len). The
+    /// Reverse(Key, Len) function performs bitwise reversal
+    /// of the len least significant bits of the key value.
+    /// </summary>
+    public static uint GetNextKey(uint key, int len)
+    {
+        uint step = 1u << (len - 1);
+        while ((key & step) != 0)
+        {
+            step >>= 1;
+        }
+
+        return (key & (step - 1)) + step;
+    }
+
+    /// <summary>
+    /// Replicates <paramref name="code"/> into <paramref name="table"/> every <paramref name="step"/>
+    /// times with the upper bound of <paramref name="end"/>.
+    /// </summary>
+    public static void ReplicateValue(Span<JxlHuffmanCode> table, int step, int end, JxlHuffmanCode code)
+    {
+        do
+        {
+            end -= step;
+            table[end] = code;
+        }
+        while (end > 0);
+    }
+
+    /// <summary>
+    /// Returns the table width of the next 2nd level table.
+    /// </summary>
+    /// <param name="count">The histogram of bit lengths for remaining symbols</param>
+    /// <param name="length">Code length of the next processed symbol</param>
+    /// <param name="rootBits">Amount of bits for the root symbol</param>
+    /// <returns>Table width for the 2nd level table.</returns>
+    public static int NextTableBitSize(ReadOnlySpan<ushort> count, int length, int rootBits)
+    {
+        uint left = 1u << (length - rootBits);
+
+        while (length < JxlAnsConstants.PrefixMaxBits)
+        {
+            if (left <= count[length])
+            {
+                break;
+            }
+
+            left -= count[length];
+            length++;
+            left <<= 1;
+        }
+
+        return length - rootBits;
+    }
+
+    public static uint BuildHuffmanTable(
+        Span<JxlHuffmanCode> rootTable,
+        int rootBits,
+        ReadOnlySpan<byte> codeLengths,
+        Span<ushort> count)
+    {
+        if (codeLengths.Length > (1u << JxlAnsConstants.PrefixMaxBits))
+        {
+            return 0u;
+        }
+
+        Span<ushort> offset = stackalloc ushort[JxlAnsConstants.PrefixMaxBits + 1];
+
+        Span<ushort> sortedStorage = stackalloc ushort[codeLengths.Length];
+
+        int maxLength = 1;
+        ushort sum = 0;
+        int len, symbol;
+        for (len = 1; len <= JxlAnsConstants.PrefixMaxBits; len++)
+        {
+            offset[len] = sum;
+
+            if (count[len] != 0)
+            {
+                sum = (ushort)(sum + count[len]);
+                maxLength = len;
+            }
+        }
+
+        for (symbol = 0; symbol < codeLengths.Length; symbol++)
+        {
+            if (codeLengths[symbol] != 0)
+            {
+                sortedStorage[offset[codeLengths[symbol]]++] = (ushort)symbol;
+            }
+        }
+
+        Span<JxlHuffmanCode> table = rootTable;
+        int tableBits = rootBits;
+        uint tableSize = 1u << tableBits;
+        uint totalSize = tableSize;
+
+        JxlHuffmanCode code = default;
+
+        if (offset[JxlAnsConstants.PrefixMaxBits] == 1)
+        {
+            code.Bits = 0;
+            code.Value = sortedStorage[0];
+
+            for (int i = 0; i < totalSize; i++)
+            {
+                table[i] = code;
+            }
+        }
+
+        if (tableBits > maxLength)
+        {
+            tableBits = maxLength;
+            tableSize = 1u << tableBits;
+        }
+
+        int key = 0;
+        code.Bits = 0;
+        int step = 2;
+
+        do
+        {
+            for (; count[code.Bits] != 0; --count[code.Bits])
+            {
+                code.Value = sortedStorage[symbol++];
+                ReplicateValue(table[key..], step, (int)tableSize, code);
+                key = (int)GetNextKey((uint)key, code.Bits);
+            }
+
+            step <<= 1;
+        }
+        while (++code.Bits <= tableBits);
+
+        while (totalSize != tableSize)
+        {
+            table[..(int)tableSize].CopyTo(table[(int)tableSize..]);
+            tableSize <<= 1;
+        }
+
+        uint mask = totalSize - 1u;
+        int low = -1;
+
+        uint tableOffset = 0;
+        for (step = 2; len <= maxLength; len++, step <<= 1)
+        {
+            for (; count[len] != 0; --count[len])
+            {
+                if ((key & mask) != low)
+                {
+                    tableOffset += tableSize;
+                    table = table[(int)tableSize..];
+                    tableBits = NextTableBitSize(count, len, rootBits);
+                    tableSize = 1u << tableBits;
+                    totalSize += tableSize;
+                    low = key & (int)mask;
+
+                    rootTable[low].Bits = (byte)(tableBits + rootBits);
+                    rootTable[low].Value = (ushort)(tableOffset - low);
+                }
+
+                code.Bits = (byte)(len - rootBits);
+                code.Value = sortedStorage[symbol++];
+
+                ReplicateValue(table[(key >> rootBits)..], step, (int)tableSize, code);
+                key = (int)GetNextKey((uint)key, len);
+            }
+        }
+
+        return totalSize;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/JxlHuffmanCode.cs b/src/ImageSharp/Formats/Jxl/IO/JxlHuffmanCode.cs
new file mode 100644
index 0000000000..2f95f7226c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/JxlHuffmanCode.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO;
+
+/// <summary>
+/// A single Huffman code.
+/// </summary>
+internal struct JxlHuffmanCode(byte bits, ushort value)
+{
+    /// <summary>
+    /// Number of bits for this symbol.
+    /// </summary>
+    public byte Bits = bits;
+
+    /// <summary>
+    /// Symbol value/offset.
+    /// </summary>
+    public ushort Value = value;
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/JxlMemoryWriter.cs b/src/ImageSharp/Formats/Jxl/IO/JxlMemoryWriter.cs
new file mode 100644
index 0000000000..77058802b3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/JxlMemoryWriter.cs
@@ -0,0 +1,82 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO;
+
+/// <summary>
+/// A disposable writer for bytes in memory. It is highly similar to
+/// <see cref="MemoryStream"/>, but its buffer relies on
+/// <see cref="MemoryAllocator"/>.
+/// </summary>
+internal sealed class JxlMemoryWriter(MemoryAllocator allocator) : IDisposable
+{
+    /// <summary>
+    /// The initial capacity in bytes.
+    /// </summary>
+    private const int InitialCapacity = 1024;
+
+    /// <summary>
+    /// Core buffer.
+    /// </summary>
+    private IMemoryOwner<byte> buffer = allocator.Allocate<byte>(InitialCapacity);
+
+    /// <summary>
+    /// Gets the length of the written data in bytes.
+    /// </summary>
+    public int Length { get; private set; }
+
+    /// <summary>
+    /// Gets the capacity of the buffer in bytes.
+    /// </summary>
+    public int Capacity => this.buffer.Memory.Length;
+
+    /// <summary>
+    /// Releases the underlying buffer.
+    /// </summary>
+    public void Dispose() => this.buffer.Dispose();
+
+    /// <summary>
+    /// Writes the specified bytes into the writer.
+    /// </summary>
+    /// <param name="bytes">The bytes to write.</param>
+    public void Write(ReadOnlySpan<byte> bytes)
+    {
+        int requiredCapacity = checked(this.Length + bytes.Length);
+        this.EnsureCapacity(requiredCapacity);
+
+        bytes.CopyTo(this.buffer.Memory.Span[this.Length..]);
+        this.Length = requiredCapacity;
+    }
+
+    /// <summary>
+    /// Returns a span containing the bytes written to the writer.
+    /// </summary>
+    /// <returns>A span containing the written bytes.</returns>
+    public Span<byte> AsSpan() => this.buffer.Memory.Span[..this.Length];
+
+    /// <summary>
+    /// Returns memory containing the bytes written to the writer.
+    /// </summary>
+    /// <returns>Memory containing the written bytes.</returns>
+    public Memory<byte> AsMemory() => this.buffer.Memory[..this.Length];
+
+    private void EnsureCapacity(int requiredCapacity)
+    {
+        if (requiredCapacity <= this.Capacity)
+        {
+            return;
+        }
+
+        int newCapacity = Math.Max(requiredCapacity, checked(this.Capacity * 2));
+
+        IMemoryOwner<byte> previousBuffer = this.buffer;
+        this.buffer = allocator.Allocate<byte>(newCapacity);
+
+        previousBuffer.Memory.Span[..this.Length].CopyTo(this.buffer.Memory.Span);
+
+        previousBuffer.Dispose();
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlAnimationHeader.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlAnimationHeader.cs
new file mode 100644
index 0000000000..647e8bbc7d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlAnimationHeader.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlAnimationHeader : IJxlFields
+{
+    public int TpsNumerator { get; set; }
+
+    public int TpsDenominator { get; set; }
+
+    public int LoopCount { get; set; }
+
+    public bool ContainsTimecodes { get; set; }
+
+    public bool Visit(JxlVisitor visitor) => throw new NotImplementedException();
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlBitDepthMetadata.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlBitDepthMetadata.cs
new file mode 100644
index 0000000000..a6c9f72482
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlBitDepthMetadata.cs
@@ -0,0 +1,129 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+/// <summary>
+/// Represents the JPEG XL Bit Depth image metadata.
+/// </summary>
+internal sealed class JxlBitDepthMetadata : IJxlFields
+{
+    private uint bitsPerSample;
+    private uint exponentBitsPerSample;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlBitDepthMetadata"/> class.
+    /// </summary>
+    public JxlBitDepthMetadata() => JxlBundle.Init(this);
+
+    /// <summary>
+    /// Gets or sets a value indicating whether
+    /// the original (uncompressed) samples are floating point or
+    /// unsigned integer.
+    /// </summary>
+    public bool FloatingPointSample { get; set; }
+
+    /// <summary>
+    /// Gets or sets the bit depth of the original (uncompressed) image samples.
+    /// Must be in the range [1, 32].
+    /// </summary>
+    public uint BitsPerSample
+    {
+        get => this.bitsPerSample;
+        set => this.bitsPerSample = value;
+    }
+
+    /// <summary>
+    /// <para>
+    ///   Gets or sets floating point exponent bits of the original (uncompressed) image samples,
+    ///   only used if <see cref="FloatingPointSample"/>  is <see langword="true"/>.
+    /// </para>
+    /// <para>
+    ///   If used, the samples are floating point with:
+    ///   <list type="bullet">
+    ///     <item>1 sign bit</item>
+    ///     <item><see cref="ExponentBitsPerSample"/> exponent bits</item>
+    ///     <item>(<see cref="BitsPerSample"/> - <see cref="ExponentBitsPerSample"/> - 1) mantissa bits</item>
+    ///   </list>
+    ///   If used, <see cref="ExponentBitsPerSample"/> must be in the range
+    ///   [2, 8] and amount of mantissa bits must be in the range [2, 23].
+    /// </para>
+    /// </summary>
+    public uint ExponentBitsPerSample
+    {
+        get => this.exponentBitsPerSample;
+        set => this.exponentBitsPerSample = value;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (!this.FloatingPointSample)
+        {
+            bool successful = visitor.U32(
+                JxlFieldExpressions.Value(8u),
+                JxlFieldExpressions.Value(10u),
+                JxlFieldExpressions.Value(12u),
+                JxlFieldExpressions.BitsOffset(6u, 1u),
+                8u,
+                ref this.bitsPerSample);
+
+            if (!successful)
+            {
+                return false;
+            }
+
+            this.exponentBitsPerSample = 0;
+        }
+        else
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(32u),
+                JxlFieldExpressions.Value(16u),
+                JxlFieldExpressions.Value(24u),
+                JxlFieldExpressions.BitsOffset(6u, 1u),
+                32u,
+                ref this.bitsPerSample))
+            {
+                return false;
+            }
+
+            this.exponentBitsPerSample--;
+
+            if (!visitor.Bits(4, 7, ref this.exponentBitsPerSample))
+            {
+                return false;
+            }
+
+            this.exponentBitsPerSample++;
+        }
+
+        if (this.FloatingPointSample)
+        {
+            if (this.exponentBitsPerSample is < 2 or > 8)
+            {
+                DebugGuard.IsTrue(false, "Invalid exponent_bits_per_sample");
+
+                return false;
+            }
+
+            int mantissaBits = (int)this.bitsPerSample - (int)this.exponentBitsPerSample - 1;
+
+            if (mantissaBits is < 2 or > 23)
+            {
+                DebugGuard.IsTrue(false, "Invalid bits_per_sample");
+
+                return false;
+            }
+        }
+        else if (this.bitsPerSample > 31)
+        {
+            DebugGuard.IsTrue(false, "Invalid bits_per_sample");
+
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlCodecMetadata.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlCodecMetadata.cs
new file mode 100644
index 0000000000..5a3aaeecb7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlCodecMetadata.cs
@@ -0,0 +1,57 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlCodecMetadata
+{
+    public JxlImageMetadata? ImageMetadata { get; set; }
+
+    public JxlSizeHeader? Size { get; set; }
+
+    public JxlCustomTransformData? CustomTransformData { get; set; }
+
+    public int XSize => this.Size?.XSize ?? 0;
+
+    public int YSize => this.Size?.YSize ?? 0;
+
+    public int GetOrientedPreviewXSize(bool keepOrientation)
+    {
+        if (this.ImageMetadata!.Orientation > 4 && !keepOrientation)
+        {
+            return this.ImageMetadata.PreviewSize.YSize;
+        }
+
+        return this.ImageMetadata.PreviewSize.XSize;
+    }
+
+    public int GetOrientedPreviewYSize(bool keepOrientation)
+    {
+        if (this.ImageMetadata!.Orientation > 4 && !keepOrientation)
+        {
+            return this.ImageMetadata.PreviewSize.XSize;
+        }
+
+        return this.ImageMetadata.PreviewSize.YSize;
+    }
+
+    public int GetOrientedXSize(bool keepOrientation)
+    {
+        if (this.ImageMetadata!.Orientation > 4 && !keepOrientation)
+        {
+            return this.YSize;
+        }
+
+        return this.XSize;
+    }
+
+    public int GetOrientedYSize(bool keepOrientation)
+    {
+        if (this.ImageMetadata!.Orientation > 4 && !keepOrientation)
+        {
+            return this.XSize;
+        }
+
+        return this.YSize;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlCustomTransformData.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlCustomTransformData.cs
new file mode 100644
index 0000000000..882615d73d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlCustomTransformData.cs
@@ -0,0 +1,177 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlCustomTransformData : IJxlFields
+{
+    private InlineArray15<float> upsampling2Weights;
+    private InlineArray55<float> upsampling4Weights;
+    private InlineArray210<float> upsampling8Weights;
+    private uint customWeightsMask;
+    private bool allDefault;
+
+    public JxlCustomTransformData() => JxlBundle.Init(this);
+
+    private static ReadOnlySpan<float> Weights2 =>
+    [
+        -0.01716200f, -0.03452303f, -0.04022174f, -0.02921014f, -0.00624645f,
+        0.14111091f,  0.28896755f,  0.00278718f,  -0.01610267f, 0.56661550f,
+        0.03777607f,  -0.01986694f, -0.03144731f, -0.01185068f, -0.00213539f
+    ];
+
+    private static ReadOnlySpan<float> Weights4 =>
+    [
+        -0.02419067f, -0.03491987f, -0.03693351f, -0.03094285f, -0.00529785f,
+        -0.01663432f, -0.03556863f, -0.03888905f, -0.03516850f, -0.00989469f,
+        0.23651958f,  0.33392945f,  -0.01073543f, -0.01313181f, -0.03556694f,
+        0.13048175f,  0.40103025f,  0.03951150f,  -0.02077584f, 0.46914198f,
+        -0.00209270f, -0.01484589f, -0.04064806f, 0.18942530f,  0.56279892f,
+        0.06674400f,  -0.02335494f, -0.03551682f, -0.00754830f, -0.02267919f,
+        -0.02363578f, 0.00315804f,  -0.03399098f, -0.01359519f, -0.00091653f,
+        -0.00335467f, -0.01163294f, -0.01610294f, -0.00974088f, -0.00191622f,
+        -0.01095446f, -0.03198464f, -0.04455121f, -0.02799790f, -0.00645912f,
+        0.06390599f,  0.22963888f,  0.00630981f,  -0.01897349f, 0.67537268f,
+        0.08483369f,  -0.02534994f, -0.02205197f, -0.01667999f, -0.00384443f
+    ];
+
+    private static ReadOnlySpan<float> Weights8 =>
+    [
+        -0.02928613f, -0.03706353f, -0.03783812f, -0.03324558f, -0.00447632f,
+        -0.02519406f, -0.03752601f, -0.03901508f, -0.03663285f, -0.00646649f,
+        -0.02066407f, -0.03838633f, -0.04002101f, -0.03900035f, -0.00901973f,
+        -0.01626393f, -0.03954148f, -0.04046620f, -0.03979621f, -0.01224485f,
+        0.29895328f,  0.35757708f,  -0.02447552f, -0.01081748f, -0.04314594f,
+        0.23903219f,  0.41119301f,  -0.00573046f, -0.01450239f, -0.04246845f,
+        0.17567618f,  0.45220643f,  0.02287757f,  -0.01936783f, -0.03583255f,
+        0.11572472f,  0.47416733f,  0.06284440f,  -0.02685066f, 0.42720050f,
+        -0.02248939f, -0.01155273f, -0.04562755f, 0.28689496f,  0.49093869f,
+        -0.00007891f, -0.01545926f, -0.04562659f, 0.21238920f,  0.53980934f,
+        0.03369474f,  -0.02070211f, -0.03866988f, 0.14229550f,  0.56593398f,
+        0.08045181f,  -0.02888298f, -0.03680918f, -0.00542229f, -0.02920477f,
+        -0.02788574f, -0.02118180f, -0.03942402f, -0.00775547f, -0.02433614f,
+        -0.03193943f, -0.02030828f, -0.04044014f, -0.01074016f, -0.01930822f,
+        -0.03620399f, -0.01974125f, -0.03919545f, -0.01456093f, -0.00045072f,
+        -0.00360110f, -0.01020207f, -0.01231907f, -0.00638988f, -0.00071592f,
+        -0.00279122f, -0.00957115f, -0.01288327f, -0.00730937f, -0.00107783f,
+        -0.00210156f, -0.00890705f, -0.01317668f, -0.00813895f, -0.00153491f,
+        -0.02128481f, -0.04173044f, -0.04831487f, -0.03293190f, -0.00525260f,
+        -0.01720322f, -0.04052736f, -0.05045706f, -0.03607317f, -0.00738030f,
+        -0.01341764f, -0.03965629f, -0.05151616f, -0.03814886f, -0.01005819f,
+        0.18968273f,  0.33063684f,  -0.01300105f, -0.01372950f, -0.04017465f,
+        0.13727832f,  0.36402234f,  0.01027890f,  -0.01832107f, -0.03365072f,
+        0.08734506f,  0.38194295f,  0.04338228f,  -0.02525993f, 0.56408126f,
+        0.00458352f,  -0.01648227f, -0.04887868f, 0.24585519f,  0.62026135f,
+        0.04314807f,  -0.02213737f, -0.04158014f, 0.16637289f,  0.65027023f,
+        0.09621636f,  -0.03101388f, -0.04082742f, -0.00904519f, -0.02790922f,
+        -0.02117818f, 0.00798662f,  -0.03995711f, -0.01243427f, -0.02231705f,
+        -0.02946266f, 0.00992055f,  -0.03600283f, -0.01684920f, -0.00111684f,
+        -0.00411204f, -0.01297130f, -0.01723725f, -0.01022545f, -0.00165306f,
+        -0.00313110f, -0.01218016f, -0.01763266f, -0.01125620f, -0.00231663f,
+        -0.01374149f, -0.03797620f, -0.05142937f, -0.03117307f, -0.00581914f,
+        -0.01064003f, -0.03608089f, -0.05272168f, -0.03375670f, -0.00795586f,
+        0.09628104f,  0.27129991f,  -0.00353779f, -0.01734151f, -0.03153981f,
+        0.05686230f,  0.28500998f,  0.02230594f,  -0.02374955f, 0.68214326f,
+        0.05018048f,  -0.02320852f, -0.04383616f, 0.18459474f,  0.71517975f,
+        0.10805613f,  -0.03263677f, -0.03637639f, -0.01394373f, -0.02511203f,
+        -0.01728636f, 0.05407331f,  -0.02867568f, -0.01893131f, -0.00240854f,
+        -0.00446511f, -0.01636187f, -0.02377053f, -0.01522848f, -0.00333334f,
+        -0.00819975f, -0.02964169f, -0.04499287f, -0.02745350f, -0.00612408f,
+        0.02727416f,  0.19446600f,  0.00159832f,  -0.02232473f, 0.74982506f,
+        0.11452620f,  -0.03348048f, -0.01605681f, -0.02070339f, -0.00458223f
+    ];
+
+    public bool NonserializedXybEncoded { get; set; }
+
+    public bool AllDefault
+    {
+        get => this.allDefault;
+        set => this.allDefault = value;
+    }
+
+    public JxlOpsinInverseMatrix? OpsinInverseMatrix { get; set; }
+
+    public uint CustomWeightsMask
+    {
+        get => this.customWeightsMask;
+        set => this.customWeightsMask = value;
+    }
+
+    public InlineArray15<float> Upsampling2Weights
+    {
+        get => this.upsampling2Weights;
+        set => this.upsampling2Weights = value;
+    }
+
+    public InlineArray55<float> Upsampling4Weights
+    {
+        get => this.upsampling4Weights;
+        set => this.upsampling4Weights = value;
+    }
+
+    public InlineArray210<float> Upsampling8Weights
+    {
+        get => this.upsampling8Weights;
+        set => this.upsampling8Weights = value;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (visitor.AllDefault(this, ref this.allDefault))
+        {
+            visitor.SetDefault(this);
+            return true;
+        }
+
+        if (visitor.Conditional(this.NonserializedXybEncoded))
+        {
+            if (!visitor.VisitNested(this.OpsinInverseMatrix!))
+            {
+                return false;
+            }
+        }
+
+        if (!visitor.Bits(3, 0, ref this.customWeightsMask))
+        {
+            return false;
+        }
+
+        if (visitor.Conditional((this.CustomWeightsMask & 1) != 0))
+        {
+            for (int i = 0; i < 15; i++)
+            {
+                if (!visitor.F16(Weights2[i], ref this.upsampling2Weights[i]))
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (visitor.Conditional((this.CustomWeightsMask & 2) != 0))
+        {
+            for (int i = 0; i < 55; i++)
+            {
+                if (!visitor.F16(Weights4[i], ref this.upsampling4Weights[i]))
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (visitor.Conditional((this.CustomWeightsMask & 4) != 0))
+        {
+            for (int i = 0; i < 210; i++)
+            {
+                if (!visitor.F16(Weights8[i], ref this.upsampling8Weights[i]))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExifOrientation.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExifOrientation.cs
new file mode 100644
index 0000000000..fb7d8d7bba
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExifOrientation.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal enum JxlExifOrientation : byte
+{
+    Identity = 1,
+    FlipHorizontal = 2,
+    Rotate180 = 3,
+    FlipVertical = 4,
+    Transpose = 5,
+    Rotate90 = 6,
+    AntiTranspose = 7,
+    Rotate270 = 8
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExtraChannel.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExtraChannel.cs
new file mode 100644
index 0000000000..8e2b842a56
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExtraChannel.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal enum JxlExtraChannel : byte
+{
+    Alpha,
+    Depth,
+    SpotColor,
+    SelectionMask,
+    Black,
+    Cfa,
+    Thermal,
+    Reserved0,
+    Reserved1,
+    Reserved2,
+    Reserved3,
+    Reserved4,
+    Reserved5,
+    Reserved6,
+    Reserved7,
+    Unknown,
+    Optional
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExtraChannelInfo.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExtraChannelInfo.cs
new file mode 100644
index 0000000000..2d53a5f380
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlExtraChannelInfo.cs
@@ -0,0 +1,152 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlExtraChannelInfo : IJxlFields
+{
+    private bool allDefault;
+    private JxlExtraChannel type;
+    private JxlBitDepthMetadata? bitDepth;
+    private int dimensionShift;
+    private string? name;
+    private bool alphaAssociated;
+    private InlineArray4<float> spotColor;
+    private int cfaChannel;
+
+    public bool AllDefault
+    {
+        get => this.allDefault;
+        set => this.allDefault = value;
+    }
+
+    public JxlExtraChannel Type
+    {
+        get => this.type;
+        set => this.type = value;
+    }
+
+    public JxlBitDepthMetadata? BitDepth
+    {
+        get => this.bitDepth;
+        set => this.bitDepth = value;
+    }
+
+    public int DimensionShift
+    {
+        get => this.dimensionShift;
+        set => this.dimensionShift = value;
+    }
+
+    public string? Name
+    {
+        get => this.name;
+        set => this.name = value;
+    }
+
+    public bool AlphaAssociated
+    {
+        get => this.alphaAssociated;
+        set => this.alphaAssociated = value;
+    }
+
+    public InlineArray4<float> SpotColor
+    {
+        get => this.spotColor;
+        set => this.spotColor = value;
+    }
+
+    public int CfaChannel
+    {
+        get => this.cfaChannel;
+        set => this.cfaChannel = value;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (visitor.AllDefault(this, ref this.allDefault))
+        {
+            // Overwrite all serialized fields, but not any nonserialized_*.
+            visitor.SetDefault(this);
+            return true;
+        }
+
+        // General
+        if (!visitor.Enum(JxlExtraChannel.Alpha, ref this.type))
+        {
+            return false;
+        }
+
+        if (!visitor.VisitNested(this.bitDepth!))
+        {
+            return false;
+        }
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value(0u),
+            JxlFieldExpressions.Value(3u),
+            JxlFieldExpressions.Value(4u),
+            JxlFieldExpressions.BitsOffset(3u, 1u),
+            0u,
+            ref Unsafe.As<int, uint>(ref this.dimensionShift)))
+        {
+            return false;
+        }
+
+        if ((1u << this.dimensionShift) > 8u)
+        {
+            return false;
+        }
+
+        if (!VisitNameString(visitor, ref this.name))
+        {
+            return false;
+        }
+
+        // Conditional
+        if (visitor.Conditional(this.type == JxlExtraChannel.Alpha))
+        {
+            if (!visitor.Boolean(false, ref this.alphaAssociated))
+            {
+                return false;
+            }
+        }
+
+        if (visitor.Conditional(this.type == JxlExtraChannel.SpotColor))
+        {
+            for (int i = 0; i < 4; i++)
+            {
+                if (!visitor.F16(0F, ref this.spotColor[i]))
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (visitor.Conditional(this.type == JxlExtraChannel.Cfa))
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(1u),
+                JxlFieldExpressions.Bits(2u),
+                JxlFieldExpressions.BitsOffset(4u, 3u),
+                JxlFieldExpressions.BitsOffset(8u, 19u),
+                1u,
+                ref Unsafe.As<int, uint>(ref this.cfaChannel)))
+            {
+                return false;
+            }
+        }
+
+        if (this.type is JxlExtraChannel.Unknown or
+            >= JxlExtraChannel.Reserved0 and
+             <= JxlExtraChannel.Reserved7)
+        {
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlImageMetadata.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlImageMetadata.cs
new file mode 100644
index 0000000000..500fefb1c8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlImageMetadata.cs
@@ -0,0 +1,396 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlImageMetadata : IJxlFields
+{
+    private bool allDefault;
+    private JxlBitDepthMetadata? bitDepth;
+    private bool modular16BitBufferSufficient;
+    private bool xybEncoded;
+    private JxlColorEncoding? colorEncoding;
+    private int orientation = 1;
+    private bool havePreview;
+    private bool haveAnimation;
+    private bool haveIntrinsicSize;
+    private JxlSizeHeader intrinsicSize = new();
+    private JxlToneMapping? toneMapping;
+    private int extraChannelCount;
+    private List<JxlExtraChannelInfo> extraChannels = [];
+    private JxlPreviewHeader previewSize = new();
+    private JxlAnimationHeader animation = new();
+    private long extensions;
+
+    public JxlImageMetadata() => JxlBundle.Init(this);
+
+    public bool AllDefault
+    {
+        get => this.allDefault;
+        set => this.allDefault = value;
+    }
+
+    public JxlBitDepthMetadata? BitDepth
+    {
+        get => this.bitDepth;
+        set => this.bitDepth = value;
+    }
+
+    public bool Modular16BitBufferSufficient
+    {
+        get => this.modular16BitBufferSufficient;
+        set => this.modular16BitBufferSufficient = value;
+    }
+
+    public bool XybEncoded
+    {
+        get => this.xybEncoded;
+        set => this.xybEncoded = value;
+    }
+
+    public JxlColorEncoding? ColorEncoding
+    {
+        get => this.colorEncoding;
+        set => this.colorEncoding = value;
+    }
+
+    public int Orientation
+    {
+        get => this.orientation;
+        set => this.orientation = value;
+    }
+
+    public bool HavePreview
+    {
+        get => this.havePreview;
+        set => this.havePreview = value;
+    }
+
+    public bool HaveAnimation
+    {
+        get => this.haveAnimation;
+        set => this.haveAnimation = value;
+    }
+
+    public bool HaveIntrinsicSize
+    {
+        get => this.haveIntrinsicSize;
+        set => this.haveIntrinsicSize = value;
+    }
+
+    public JxlSizeHeader IntrinsicSize
+    {
+        get => this.intrinsicSize;
+        set => this.intrinsicSize = value;
+    }
+
+    public JxlToneMapping? ToneMapping
+    {
+        get => this.toneMapping;
+        set => this.toneMapping = value;
+    }
+
+    public int ExtraChannelCount
+    {
+        get => this.extraChannelCount;
+        set => this.extraChannelCount = value;
+    }
+
+    public List<JxlExtraChannelInfo> ExtraChannels
+    {
+        get => this.extraChannels;
+        set => this.extraChannels = value;
+    }
+
+    public JxlPreviewHeader PreviewSize
+    {
+        get => this.previewSize;
+        set => this.previewSize = value;
+    }
+
+    public JxlAnimationHeader Animation
+    {
+        get => this.animation;
+        set => this.animation = value;
+    }
+
+    public long Extensions
+    {
+        get => this.extensions;
+        set => this.extensions = value;
+    }
+
+    public bool NonserializedOnlyParseBasicInfos { get; set; }
+
+    public float IntensityTarget
+    {
+        get
+        {
+            float intensityTarget = this.ToneMapping?.IntensityTarget ?? 0f;
+
+            if (intensityTarget == 0f)
+            {
+                throw new InvalidOperationException("Intensity target should be present");
+            }
+
+            return intensityTarget;
+        }
+
+        set
+        {
+            if (this.ToneMapping != null)
+            {
+                this.ToneMapping.IntensityTarget = value;
+            }
+        }
+    }
+
+    public int AlphaBits
+    {
+        get
+        {
+            JxlExtraChannelInfo? ec = this.FindExtraChannel(JxlExtraChannel.Alpha);
+
+            if (ec == null)
+            {
+                return 0;
+            }
+
+            return (int?)ec.BitDepth?.BitsPerSample ?? 0;
+        }
+
+        set
+        {
+        }
+    }
+
+    public bool HasAlpha => this.AlphaBits != 0;
+
+    public JxlExtraChannelInfo? FindExtraChannel(JxlExtraChannel type)
+        => this.ExtraChannels.FirstOrDefault(eci => eci.Type == type);
+
+    public JxlExifOrientation GetExifOrientation() => (JxlExifOrientation)this.Orientation;
+
+    public void SetFloat16Samples()
+    {
+        if (this.BitDepth != null)
+        {
+            this.BitDepth.BitsPerSample = 16;
+            this.BitDepth.ExponentBitsPerSample = 5;
+            this.BitDepth.FloatingPointSample = true;
+        }
+
+        this.Modular16BitBufferSufficient = false;
+    }
+
+    public void SetFloat32Samples()
+    {
+        if (this.BitDepth != null)
+        {
+            this.BitDepth.BitsPerSample = 32;
+            this.BitDepth.ExponentBitsPerSample = 8;
+            this.BitDepth.FloatingPointSample = true;
+        }
+
+        this.Modular16BitBufferSufficient = false;
+    }
+
+    public void SetUIntSamples(int bits)
+    {
+        if (this.BitDepth != null)
+        {
+            this.BitDepth.BitsPerSample = (uint)bits;
+            this.BitDepth.ExponentBitsPerSample = 0;
+            this.BitDepth.FloatingPointSample = false;
+        }
+
+        this.Modular16BitBufferSufficient = bits <= 12;
+    }
+
+    public void SetIntensityTarget()
+    {
+        JxlCustomTransferFunction? tf = this.ColorEncoding?.TransferFunction;
+
+        if (tf is not null)
+        {
+            if (tf.Value.IsPq)
+            {
+                this.SetIntensityTarget(10000);
+            }
+            else if (tf.Value.IsHlg)
+            {
+                this.SetIntensityTarget(1000);
+            }
+            else
+            {
+                this.SetIntensityTarget(DefaultIntensityTarget);
+            }
+        }
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (visitor.AllDefault(this, ref this.allDefault))
+        {
+            // Overwrite all serialized fields, but not any nonserialized_*.
+            visitor.SetDefault(this);
+            return true;
+        }
+
+        // Bundle.AllDefault does not allow usage when reading because it may abort
+        // when a codestream has invalid values. When reading, extraFields is
+        // overwritten below, so AllDefault is not needed.
+        bool toneMappingDefault = !visitor.IsReading && JxlBundle.AllDefault(this.toneMapping!);
+
+        bool extraFields = this.orientation != 1 ||
+                           this.havePreview ||
+                           this.haveAnimation ||
+                           this.haveIntrinsicSize ||
+                           !toneMappingDefault;
+
+        if (!visitor.Boolean(false, ref extraFields))
+        {
+            return false;
+        }
+
+        if (visitor.Conditional(extraFields))
+        {
+            this.orientation--;
+
+            if (!visitor.Bits(3, 0, ref Unsafe.As<int, uint>(ref this.orientation)))
+            {
+                return false;
+            }
+
+            this.orientation++;
+
+            // No bounds checking is necessary because exactly 3 bits are read.
+            if (!visitor.Boolean(false, ref this.haveIntrinsicSize))
+            {
+                return false;
+            }
+
+            if (visitor.Conditional(this.haveIntrinsicSize))
+            {
+                if (!visitor.VisitNested(this.intrinsicSize))
+                {
+                    return false;
+                }
+            }
+
+            if (!visitor.Boolean(false, ref this.havePreview))
+            {
+                return false;
+            }
+
+            if (visitor.Conditional(this.havePreview))
+            {
+                if (!visitor.VisitNested(this.previewSize))
+                {
+                    return false;
+                }
+            }
+
+            if (!visitor.Boolean(false, ref this.haveAnimation))
+            {
+                return false;
+            }
+
+            if (visitor.Conditional(this.haveAnimation))
+            {
+                if (!visitor.VisitNested(this.animation))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            this.orientation = 1;
+            this.haveIntrinsicSize = false;
+            this.havePreview = false;
+            this.haveAnimation = false;
+        }
+
+        if (!visitor.VisitNested(this.bitDepth!))
+        {
+            return false;
+        }
+
+        if (!visitor.Boolean(true, ref this.modular16BitBufferSufficient))
+        {
+            return false;
+        }
+
+        this.extraChannelCount = this.extraChannels.Count;
+
+        if (!visitor.U32(
+            JxlFieldExpressions.Value(0u),
+            JxlFieldExpressions.Value(1u),
+            JxlFieldExpressions.BitsOffset(4u, 2u),
+            JxlFieldExpressions.BitsOffset(12u, 1u),
+            0u,
+            ref Unsafe.As<int, uint>(ref this.extraChannelCount)))
+        {
+            return false;
+        }
+
+        if (visitor.Conditional(this.extraChannelCount != 0))
+        {
+            if (visitor.IsReading)
+            {
+                this.extraChannels.Clear();
+                this.extraChannels.Capacity = this.extraChannelCount;
+
+                for (int i = 0; i < this.extraChannelCount; i++)
+                {
+                    this.extraChannels.Add(new JxlExtraChannelInfo());
+                }
+            }
+
+            for (int i = 0; i < this.extraChannels.Count; i++)
+            {
+                if (!visitor.VisitNested(this.extraChannels[i]))
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (!visitor.Boolean(true, ref this.xybEncoded))
+        {
+            return false;
+        }
+
+        if (!visitor.VisitNested(this.colorEncoding!))
+        {
+            return false;
+        }
+
+        if (visitor.Conditional(extraFields))
+        {
+            if (!visitor.VisitNested(this.toneMapping!))
+            {
+                return false;
+            }
+        }
+
+        // Treat as if only the fields up to extra channels exist.
+        if (visitor.IsReading && this.NonserializedOnlyParseBasicInfos)
+        {
+            return true;
+        }
+
+        if (!visitor.BeginExtensions(ref Unsafe.As<long, ulong>(ref this.extensions)))
+        {
+            return false;
+        }
+
+        // Extensions: in chronological order of being added to the format.
+        return visitor.EndExtensions();
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlOpsinInverseMatrix.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlOpsinInverseMatrix.cs
new file mode 100644
index 0000000000..9148e7dc77
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlOpsinInverseMatrix.cs
@@ -0,0 +1,83 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#pragma warning disable SA1401 // Fields should be private
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlOpsinInverseMatrix : IJxlFields
+{
+    private InlineArray3<float> opsinBiases;
+    private InlineArray3<float> quantBiases;
+    private bool allDefault;
+    private JxlMatrix3x3F inverseMatrix;
+
+    public InlineArray3<float> OpsinBiases
+    {
+        get => this.opsinBiases;
+        set => this.opsinBiases = value;
+    }
+
+    public InlineArray3<float> QuantBiases
+    {
+        get => this.quantBiases;
+        set => this.quantBiases = value;
+    }
+
+    public bool AllDefault
+    {
+        get => this.allDefault;
+        set => this.allDefault = value;
+    }
+
+    public JxlMatrix3x3F InverseMatrix
+    {
+        get => this.inverseMatrix;
+        set => this.inverseMatrix = value;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (visitor.AllDefault(this, ref this.allDefault))
+        {
+            // Overwrite all serialized fields, but not any nonserialized_*.
+            visitor.SetDefault(this);
+            return true;
+        }
+
+        JxlMatrix3x3F defaultInverse = JxlCms.DefaultInverseOpsinAbsorbanceMatrix();
+
+        for (int j = 0; j < 3; j++)
+        {
+            for (int i = 0; i < 3; i++)
+            {
+                if (!visitor.F16(defaultInverse[j][i], ref this.inverseMatrix[j][i]))
+                {
+                    return false;
+                }
+            }
+        }
+
+        for (int i = 0; i < 3; i++)
+        {
+            if (!visitor.F16(JxlCms.NegOpsinAbsorbanceBiasRgb[i], ref this.opsinBiases[i]))
+            {
+                return false;
+            }
+        }
+
+        for (int i = 0; i < 4; i++)
+        {
+            if (!visitor.F16(DefaultQuantBias[i], ref this.quantBiases[i]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlPreviewHeader.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlPreviewHeader.cs
new file mode 100644
index 0000000000..e46763cfeb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlPreviewHeader.cs
@@ -0,0 +1,68 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlPreviewHeader : IJxlFields
+{
+    private bool div8;
+    private int ySizeDiv8;
+    private int ySize;
+    private int ratio;
+    private int xSizeDiv8;
+    private int xSize;
+
+    public int YSize => this.div8 ? (this.ySizeDiv8 * 8) : this.ySize;
+
+    public int XSize
+    {
+        get
+        {
+            if (this.ratio != 0)
+            {
+                SignedRational signedRational = JxlAspectRatioHelpers.FixedAspectRatios(this.ratio);
+
+                return JxlAspectRatioHelpers.MultiplyTruncate(signedRational, this.YSize);
+            }
+
+            return this.div8 ? (this.xSizeDiv8 * 8) : this.xSize;
+        }
+    }
+
+    public void Set(int x, int y)
+    {
+        if (x == 0 || y == 0)
+        {
+            throw new ArgumentException("Empty preview");
+        }
+
+        this.div8 = ((x % JxlFrameDimensions.BlockDimensions) | (y % JxlFrameDimensions.BlockDimensions)) == 0;
+
+        if (this.div8)
+        {
+            this.ySizeDiv8 = y / 8;
+        }
+        else
+        {
+            this.ySize = y;
+        }
+
+        this.ratio = JxlAspectRatioHelpers.FindAspectRatio(x, y);
+
+        if (this.ratio == 0)
+        {
+            if (this.div8)
+            {
+                this.xSizeDiv8 = x / 8;
+            }
+            else
+            {
+                this.xSize = x;
+            }
+        }
+    }
+
+    public bool Visit(JxlVisitor visitor) => throw new NotImplementedException();
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlSizeHeader.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlSizeHeader.cs
new file mode 100644
index 0000000000..e40720a53c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlSizeHeader.cs
@@ -0,0 +1,74 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlSizeHeader : IJxlFields
+{
+    private bool isSmall;
+    private int ySizeDiv8Minus1;
+    private int ySize;
+    private int ratio;
+    private int xSizeDiv8Minus1;
+    private int xSize;
+
+    public int YSize => this.isSmall ? ((this.ySizeDiv8Minus1 + 1) * 8) : this.ySize;
+
+    public int XSize
+    {
+        get
+        {
+            if (this.ratio != 0)
+            {
+                SignedRational aspectRatio = JxlAspectRatioHelpers.FixedAspectRatios(this.ratio);
+
+                return JxlAspectRatioHelpers.MultiplyTruncate(aspectRatio, this.YSize);
+            }
+
+            return this.isSmall ? ((this.xSizeDiv8Minus1 + 1) * 8) : this.xSize;
+        }
+    }
+
+    public void Set(int x, int y)
+    {
+        if (x > int.MaxValue || y > int.MaxValue)
+        {
+            throw new ArgumentException("Image too large");
+        }
+
+        if (x == 0 || y == 0)
+        {
+            throw new ArgumentException("Empty image");
+        }
+
+        this.ratio = JxlAspectRatioHelpers.FindAspectRatio(x, y);
+        this.isSmall = y < 256 && (y % JxlFrameDimensions.BlockDimensions) == 0
+                    && (this.ratio != 0 || (x <= 256 && (x % JxlFrameDimensions.BlockDimensions) == 0));
+
+        if (this.isSmall)
+        {
+            this.ySizeDiv8Minus1 = (y / 8) - 1;
+        }
+        else
+        {
+            this.ySize = y;
+        }
+
+        if (this.ratio == 0)
+        {
+            if (this.isSmall)
+            {
+                this.xSizeDiv8Minus1 = (x / 8) - 1;
+            }
+            else
+            {
+                this.xSize = x;
+            }
+        }
+    }
+
+    public bool Visit(JxlVisitor visitor) => throw new NotImplementedException();
+}
diff --git a/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlToneMapping.cs b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlToneMapping.cs
new file mode 100644
index 0000000000..3c3b5a498a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/IO/Metadata/JxlToneMapping.cs
@@ -0,0 +1,99 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+
+internal sealed class JxlToneMapping : IJxlFields
+{
+    private bool allDefault;
+    private float intensityTarget;
+    private float lowerBoundIntensityLevel;
+    private bool relativeToMaxDisplay;
+    private float linearBelow;
+    private float minNits;
+
+    public bool AllDefault
+    {
+        get => this.allDefault;
+        set => this.allDefault = value;
+    }
+
+    public float IntensityTarget
+    {
+        get => this.intensityTarget;
+        set => this.intensityTarget = value;
+    }
+
+    public float LowerBoundIntensityLevel
+    {
+        get => this.lowerBoundIntensityLevel;
+        set => this.lowerBoundIntensityLevel = value;
+    }
+
+    public bool RelativeToMaxDisplay
+    {
+        get => this.relativeToMaxDisplay;
+        set => this.relativeToMaxDisplay = value;
+    }
+
+    public float LinearBelow
+    {
+        get => this.linearBelow;
+        set => this.linearBelow = value;
+    }
+
+    public float MinimumNits
+    {
+        get => this.minNits;
+        set => this.minNits = value;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (visitor.AllDefault(this, ref this.allDefault))
+        {
+            // Overwrite all serialized fields, but not any nonserialized_*.
+            visitor.SetDefault(this);
+            return true;
+        }
+
+        if (!visitor.F16(JxlFieldExpressions.Value(JxlConstants.DefaultIntensityTarget), ref this.intensityTarget))
+        {
+            return false;
+        }
+
+        if (this.intensityTarget <= 0F)
+        {
+            return false;
+        }
+
+        if (!visitor.F16(0F, ref this.minNits))
+        {
+            return false;
+        }
+
+        if (this.minNits < 0F || this.minNits > this.intensityTarget)
+        {
+            return false;
+        }
+
+        if (!visitor.Boolean(false, ref this.relativeToMaxDisplay))
+        {
+            return false;
+        }
+
+        if (!visitor.F16(0F, ref this.linearBelow))
+        {
+            return false;
+        }
+
+        if (this.linearBelow < 0F || (this.relativeToMaxDisplay && this.linearBelow > 1F))
+        {
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/InlineArrays.cs b/src/ImageSharp/Formats/Jxl/InlineArrays.cs
new file mode 100644
index 0000000000..f61f7490ea
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/InlineArrays.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+namespace SixLabors.ImageSharp.Formats.Jxl;
+
+/// <summary>
+/// Used by JxlCustomTransformData
+/// </summary>
+[InlineArray(55)]
+internal struct InlineArray55<T>
+{
+    private T first;
+}
+
+/// <summary>
+/// Used by JpegQuantizationTable
+/// </summary>
+[InlineArray(64)]
+internal struct InlineArray64<T>
+{
+    private T first;
+}
+
+/// <summary>
+/// Used by JxlCustomTransformData
+/// </summary>
+[InlineArray(210)]
+internal struct InlineArray210<T>
+{
+    private T first;
+}
diff --git a/src/ImageSharp/Formats/Jxl/JxlFormat.cs b/src/ImageSharp/Formats/Jxl/JxlFormat.cs
new file mode 100644
index 0000000000..f5c23ad685
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/JxlFormat.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl;
+
+/// <summary>
+/// JPEG XL format
+/// </summary>
+public sealed class JxlFormat : IImageFormat
+{
+    /// <inheritdoc />
+    public string Name => "JPEG XL";
+
+    /// <inheritdoc />
+    public string DefaultMimeType => "image/jxl";
+
+    /// <inheritdoc />
+    IEnumerable<string> IImageFormat.MimeTypes => new[] { "image/jxl" };
+
+    /// <inheritdoc />
+    IEnumerable<string> IImageFormat.FileExtensions => new[] { "jxl" };
+}
diff --git a/src/ImageSharp/Formats/Jxl/JxlImageFormatDetector.cs b/src/ImageSharp/Formats/Jxl/JxlImageFormatDetector.cs
new file mode 100644
index 0000000000..17484114ce
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/JxlImageFormatDetector.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace SixLabors.ImageSharp.Formats.Jxl;
+
+/// <summary>
+/// Checks if the first few bytes of a file represent
+/// JPEG XL.
+/// </summary>
+public sealed class JxlImageFormatDetector : IImageFormatDetector
+{
+    /// <summary>
+    /// Gets file signature bytes which represent a container-based
+    /// JPEG XL file.
+    /// </summary>
+    private static ReadOnlySpan<byte> ContainerStart =>
+    [
+        0x00, 0x00, 0x00, 0x0C,
+        0x4A, 0x58, 0x4C, 0x20,
+        0x0D, 0x0A, 0x87, 0x0A,
+    ];
+
+    /// <inheritdoc/>
+    public int HeaderSize => 12;
+
+    /// <inheritdoc/>
+    public bool TryDetectFormat(ReadOnlySpan<byte> header, [NotNullWhen(true)] out IImageFormat? format)
+    {
+        if (header.StartsWith([(byte)0xFF, (byte)0x0A]))
+        {
+            // Just codestream.
+            format = new JxlFormat();
+            return true;
+        }
+        else if (header.SequenceEqual(ContainerStart))
+        {
+            // Container format.
+            format = new JxlFormat();
+            return true;
+        }
+        else
+        {
+            format = null;
+            return false;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/JxlImageInfo.cs b/src/ImageSharp/Formats/Jxl/JxlImageInfo.cs
new file mode 100644
index 0000000000..47f5e4e954
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/JxlImageInfo.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Metadata;
+
+namespace SixLabors.ImageSharp.Formats.Jxl;
+
+/// <summary>
+/// Image information specific to the JPEG XL format.
+/// </summary>
+public class JxlImageInfo : ImageInfo
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlImageInfo"/> class. 
+    /// </summary>
+    /// <param name="size">Image size</param>
+    /// <param name="metadata">Image metadata</param>
+    public JxlImageInfo(Size size, ImageMetadata metadata)
+        : base(size, metadata)
+    {
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/JxlThrowHelper.cs b/src/ImageSharp/Formats/Jxl/JxlThrowHelper.cs
new file mode 100644
index 0000000000..a39dfe707c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/JxlThrowHelper.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace SixLabors.ImageSharp.Formats.Jxl;
+
+internal static class JxlThrowHelper
+{
+    [DoesNotReturn]
+    public static void ThrowEndOfStream() => throw new EndOfStreamException();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3B.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3B.cs
new file mode 100644
index 0000000000..8c3b2ae36a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3B.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a three-plane, 2D raster image of type <see cref="byte"/>.
+/// </summary>
+internal sealed class JxlImage3B : JxlImage3<byte>
+{
+    public JxlImage3B()
+    {
+    }
+
+    public JxlImage3B(Configuration configuration, int xSize, int ySize)
+        : base(configuration, xSize, ySize)
+    {
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3F.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3F.cs
new file mode 100644
index 0000000000..8387f63194
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3F.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a three-plane, 2D raster image of type <see cref="float"/>.
+/// </summary>
+internal sealed class JxlImage3F : JxlImage3<float>
+{
+    public JxlImage3F()
+    {
+    }
+
+    public JxlImage3F(Configuration configuration, int xSize, int ySize)
+        : base(configuration, xSize, ySize)
+    {
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3I.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3I.cs
new file mode 100644
index 0000000000..f3486b95a7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3I.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a three-plane, 2D raster image of type <see cref="int"/>.
+/// </summary>
+internal sealed class JxlImage3I : JxlImage3<int>
+{
+    public JxlImage3I()
+    {
+    }
+
+    public JxlImage3I(Configuration configuration, int xSize, int ySize)
+        : base(configuration, xSize, ySize)
+    {
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3S.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3S.cs
new file mode 100644
index 0000000000..94b88056a1
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3S.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a three-plane, 2D raster image of type <see cref="short"/>.
+/// </summary>
+internal sealed class JxlImage3S : JxlImage3<short>
+{
+    public JxlImage3S()
+    {
+    }
+
+    public JxlImage3S(Configuration configuration, int xSize, int ySize)
+        : base(configuration, xSize, ySize)
+    {
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3U.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3U.cs
new file mode 100644
index 0000000000..8d118c048c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImage3U.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a three-plane, 2D raster image of type <see cref="ushort"/>.
+/// </summary>
+internal sealed class JxlImage3U : JxlImage3<ushort>
+{
+    public JxlImage3U()
+    {
+    }
+
+    public JxlImage3U(Configuration configuration, int xSize, int ySize)
+        : base(configuration, xSize, ySize)
+    {
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageB.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageB.cs
new file mode 100644
index 0000000000..2d36f5b668
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageB.cs
@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a single-plane, 2D raster image of type <see cref="byte"/>.
+/// </summary>
+internal sealed class JxlImageB : JxlPlane<byte>
+{
+    public JxlImageB()
+    {
+    }
+
+    public JxlImageB(int width, int height)
+        : base(width, height)
+    {
+    }
+
+    public JxlImageB(Configuration configuration, int xSize, int ySize, int prePadding = 0)
+        : base(xSize, ySize)
+        => this.Allocate(configuration, prePadding);
+
+    public Memory<byte> GetRowBytesMemory(int y)
+    {
+        DebugGuard.MustBeLessThan(y, this.YSize, nameof(y));
+
+        Memory<byte> row = this.Bytes[(y * this.BytesPerRow)..];
+
+        return row;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageF.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageF.cs
new file mode 100644
index 0000000000..6810e87df9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageF.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a single-plane, 2D raster image of type <see cref="float"/>.
+/// </summary>
+internal sealed class JxlImageF : JxlPlane<float>
+{
+    public JxlImageF()
+    {
+    }
+
+    public JxlImageF(int width, int height)
+        : base(width, height)
+    {
+    }
+
+    public JxlImageF(Configuration configuration, int xSize, int ySize, int prePadding = 0)
+        : base(xSize, ySize)
+        => this.Allocate(configuration, prePadding);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageI.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageI.cs
new file mode 100644
index 0000000000..0261ffd63c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageI.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a single-plane, 2D raster image of type <see cref="int"/>.
+/// </summary>
+internal sealed class JxlImageI : JxlPlane<int>
+{
+    public JxlImageI()
+    {
+    }
+
+    public JxlImageI(int width, int height)
+        : base(width, height)
+    {
+    }
+
+    public JxlImageI(Configuration configuration, int xSize, int ySize, int prePadding = 0)
+        : base(xSize, ySize)
+        => this.Allocate(configuration, prePadding);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageS.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageS.cs
new file mode 100644
index 0000000000..b53716f12f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageS.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a single-plane, 2D raster image of type <see cref="short"/>.
+/// </summary>
+internal sealed class JxlImageS : JxlPlane<short>
+{
+    public JxlImageS()
+    {
+    }
+
+    public JxlImageS(int width, int height)
+        : base(width, height)
+    {
+    }
+
+    public JxlImageS(Configuration configuration, int xSize, int ySize, int prePadding = 0)
+        : base(xSize, ySize)
+        => this.Allocate(configuration, prePadding);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageSB.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageSB.cs
new file mode 100644
index 0000000000..355c50785c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageSB.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a single-plane, 2D raster image of type <see cref="sbyte"/>.
+/// </summary>
+internal sealed class JxlImageSB : JxlPlane<sbyte>
+{
+    public JxlImageSB()
+    {
+    }
+
+    public JxlImageSB(int width, int height)
+        : base(width, height)
+    {
+    }
+
+    public JxlImageSB(Configuration configuration, int xSize, int ySize, int prePadding = 0)
+        : base(xSize, ySize)
+        => this.Allocate(configuration, prePadding);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageU.cs b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageU.cs
new file mode 100644
index 0000000000..d41669e4d1
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/ImageTypes/JxlImageU.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+/// <summary>
+/// Represents a single-plane, 2D raster image of type <see cref="ushort"/>.
+/// </summary>
+internal sealed class JxlImageU : JxlPlane<ushort>
+{
+    public JxlImageU()
+    {
+    }
+
+    public JxlImageU(int width, int height)
+        : base(width, height)
+    {
+    }
+
+    public JxlImageU(Configuration configuration, int xSize, int ySize, int prePadding = 0)
+        : base(xSize, ySize)
+        => this.Allocate(configuration, prePadding);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/JxlImage3{T}.cs b/src/ImageSharp/Formats/Jxl/Memory/JxlImage3{T}.cs
new file mode 100644
index 0000000000..882c1098bb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/JxlImage3{T}.cs
@@ -0,0 +1,145 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory;
+
+// NOTE: Do not seal this class.
+internal class JxlImage3<T> : IDisposable
+    where T : unmanaged
+{
+    private sealed class TypeChangingMemoryManager<TTarget>(Memory<byte> memory) : MemoryManager<TTarget>
+        where TTarget : unmanaged
+    {
+        public override Span<TTarget> GetSpan() => MemoryMarshal.Cast<byte, TTarget>(memory.Span);
+
+        // we don't use these
+        public override MemoryHandle Pin(int elementIndex = 0) => throw new NotImplementedException();
+
+        public override void Unpin() => throw new NotImplementedException();
+
+        protected override void Dispose(bool disposing)
+        {
+        }
+    }
+
+    private const int PlaneCount = 3;
+
+    private JxlPlane<T>[] planes = new JxlPlane<T>[3];
+
+    public JxlImage3()
+    {
+    }
+
+    public JxlImage3(Configuration configuration, int xSize, int ySize)
+        => this.Allocate(configuration, xSize, ySize);
+
+    public JxlImage3(JxlImage3<T> other)
+    {
+        for (int i = 0; i < PlaneCount; i++)
+        {
+            this.planes[i] = other.planes[i];
+        }
+    }
+
+    public int XSize => this.planes[0].XSize;
+
+    public int YSize => this.planes[0].YSize;
+
+    public int BytesPerRow => this.planes[0].BytesPerRow;
+
+    public int PixelsPerRow => this.planes[0].PixelsPerRow;
+
+    public Span<T> PlaneRow(int plane, int row)
+    {
+        this.PlaneRowBoundsCheck(plane, row);
+
+        int rowOffset = row * this.planes[0].BytesPerRow;
+        Span<T> rowSpan = MemoryMarshal.Cast<byte, T>(this.planes[plane].BytesSpan[rowOffset..]);
+
+        return rowSpan;
+    }
+
+    // This method performs minor allocations!
+    public Memory<T> PlaneRowMemory(int plane, int row)
+    {
+        this.PlaneRowBoundsCheck(plane, row);
+
+        int rowOffset = row * this.planes[0].BytesPerRow;
+        Memory<byte> rowMemoryBytes = this.planes[plane].Bytes[rowOffset..];
+
+        // we have to allocate a utility class so we can reinterpret
+        // a Memory<T>.
+        // Unsafe.As is truly unsafe because, f.e. what if there are
+        // 400 bytes but T is 4 bytes? the length will remain as 400.
+        TypeChangingMemoryManager<T> reinterpreter = new(rowMemoryBytes);
+        return reinterpreter.Memory;
+    }
+
+    public Span<T> PlaneRow(Rectangle rectangle, int c, int y)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(y + rectangle.Top, 0, nameof(y));
+
+        return this.PlaneRow(c, y + rectangle.Top)[rectangle.Left..];
+    }
+
+    public JxlPlane<T> Plane(int index) => this.planes[index];
+
+    public void Swap(JxlImage3<T> other)
+    {
+        for (int i = 0; i < PlaneCount; i++)
+        {
+            other.planes[i].Swap(this.planes[i]);
+        }
+    }
+
+    public static JxlImage3<T> Create(Configuration configuration, int xSize, int ySize)
+        => new(configuration, xSize, ySize);
+
+    public void Allocate(Configuration configuration, int xSize, int ySize)
+    {
+        JxlPlane<T> plane0 = JxlPlane<T>.Create(configuration, xSize, ySize);
+        JxlPlane<T> plane1 = JxlPlane<T>.Create(configuration, xSize, ySize);
+        JxlPlane<T> plane2 = JxlPlane<T>.Create(configuration, xSize, ySize);
+
+        this.planes = [plane0, plane1, plane2];
+    }
+
+    public bool ShrinkTo(int x, int y)
+    {
+        for (int i = 0; i < PlaneCount; i++)
+        {
+            if (!this.planes[i].ShrinkTo(x, y))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private void PlaneRowBoundsCheck(int c, int y)
+    {
+        DebugGuard.MustBeLessThan(c, PlaneCount, nameof(c));
+        DebugGuard.MustBeLessThan(y, this.YSize, nameof(y));
+    }
+
+    /// <summary>
+    /// Returns the rectangle for this image bounds.
+    /// </summary>
+    /// <returns>A rectangle with x,y=0,0 width,height=XSize,YSize.</returns>
+    public Rectangle GetRectangle() => new(0, 0, this.XSize, this.YSize);
+
+    public void Dispose()
+    {
+        foreach (JxlPlane<T> plane in this.planes)
+        {
+            plane.Dispose();
+        }
+
+        GC.SuppressFinalize(this);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/JxlPlaneBase.cs b/src/ImageSharp/Formats/Jxl/Memory/JxlPlaneBase.cs
new file mode 100644
index 0000000000..5d2300c2a0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/JxlPlaneBase.cs
@@ -0,0 +1,200 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory;
+
+/// <summary>
+/// Base class for a single-plane image.
+/// </summary>
+internal class JxlPlaneBase : IDisposable
+{
+    /// <summary>
+    /// Underlying bytes
+    /// </summary>
+    private IMemoryOwner<byte>? bytes;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlPlaneBase"/> class.
+    /// </summary>
+    /// <param name="xSize">Plane width</param>
+    /// <param name="ySize">Plane height</param>
+    /// <param name="sizeOfT">The size of each pixel in bytes.</param>
+    public JxlPlaneBase(int xSize, int ySize, int sizeOfT)
+    {
+        this.XSize = xSize;
+        this.YSize = ySize;
+        this.OriginalXSize = xSize;
+        this.OriginalYSize = ySize;
+        this.BytesPerRow = 0;
+        this.Size = sizeOfT;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlPlaneBase"/> class with empty values.
+    /// </summary>
+    public JxlPlaneBase()
+        : this(0, 0, 0)
+    {
+    }
+
+    /// <summary>
+    /// Gets the number of bytes per row.
+    /// </summary>
+    public int BytesPerRow { get; private set; }
+
+    /// <summary>
+    /// Gets the width of the image.
+    /// </summary>
+    public int XSize { get; private set; }
+
+    /// <summary>
+    /// Gets the height of the image.
+    /// </summary>
+    public int YSize { get; private set; }
+
+    /// <summary>
+    /// Gets the underlying bytes of this image as a Memory&lt;T&gt;.
+    /// </summary>
+    public Memory<byte> Bytes =>
+#if DEBUG
+        this.bytes?.Memory ?? throw new InvalidOperationException("Bytes are missing");
+#else
+        return this.bytes!.Memory;
+#endif
+
+    /// <summary>
+    /// Gets the underlying bytes of this image as a Span&lt;T&gt;.
+    /// </summary>
+    public Span<byte> BytesSpan => this.Bytes.Span;
+
+    protected int Size { get; set; }
+
+    /// <summary>
+    /// Gets or sets the width that was initially assigned. For example, if the image gets shrinked,
+    /// the XSize YSize properties get changed while this property will stay same.
+    /// </summary>
+    protected int OriginalXSize { get; set; }
+
+    /// <summary>
+    /// Gets or sets the height that was initially assigned. For example, if the image gets shrinked,
+    /// the XSize YSize properties get changed while this property will stay same.
+    /// </summary>
+    protected int OriginalYSize { get; set; }
+
+    /// <summary>
+    /// Allocates the underlying memory for the plane.
+    /// </summary>
+    /// <param name="configuration">The configuration which has a memory allocator used to allocate memory.</param>
+    /// <param name="prePadding">Padding</param>
+    /// <returns>Status of allocation.</returns>
+    public bool Allocate(Configuration configuration, int prePadding)
+    {
+        if (this.bytes != null || this.BytesPerRow != 0)
+        {
+            return false;
+        }
+
+        if (this.XSize == 0 || this.YSize == 0)
+        {
+            return true;
+        }
+
+        int totalBytes = unchecked(this.YSize * this.BytesPerRow);
+
+        this.bytes = configuration.MemoryAllocator.Allocate<byte>(totalBytes + (prePadding * this.Size));
+
+        return true;
+    }
+
+    /// <summary>
+    /// Shrinks the image so its width is equal to <paramref name="x"/> and its height is
+    /// equal to <paramref name="y"/>.
+    /// </summary>
+    /// <param name="x">The output width</param>
+    /// <param name="y">The output height</param>
+    /// <returns>Status of the shrinking operation.</returns>
+    /// <remarks>
+    ///   <para>
+    ///     This method can only shrink memory. It cannot expand it.
+    ///   </para>
+    ///   <para>
+    ///     When shrinking, the underlying memory does not get resized.
+    ///   </para>
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool ShrinkTo(int x, int y)
+    {
+        if (x <= this.OriginalXSize || y <= this.OriginalYSize)
+        {
+            return false;
+        }
+
+        DebugGuard.MustBeLessThanOrEqualTo(x, this.OriginalXSize, nameof(x));
+        DebugGuard.MustBeLessThanOrEqualTo(y, this.OriginalYSize, nameof(y));
+
+        this.XSize = x;
+        this.YSize = y;
+
+        return true;
+    }
+
+    /// <summary>
+    /// Base function to return the span for a specified row as a generic &lt;T&gt;.
+    /// </summary>
+    /// <typeparam name="T">The type of the row.</typeparam>
+    /// <param name="y">The index of the row to get the span for.</param>
+    /// <returns>A span which covers the row memory.</returns>
+    protected Span<T> GetRowBase<T>(int y)
+        where T : unmanaged
+    {
+        DebugGuard.MustBeLessThan(y, this.YSize, nameof(y));
+
+        Span<byte> row = this.Bytes.Span[(y * this.BytesPerRow)..];
+        return MemoryMarshal.Cast<byte, T>(row);
+    }
+
+    protected Span<T> GetRowMinusBase<T>(int y, int minus)
+        where T : unmanaged
+    {
+        DebugGuard.MustBeLessThan(y, this.YSize, nameof(y));
+
+        Span<byte> row = this.Bytes.Span[((y * this.BytesPerRow) - minus)..];
+        return MemoryMarshal.Cast<byte, T>(row);
+    }
+
+    protected Span<T> GetRowPlusBase<T>(int y, int plus)
+        where T : unmanaged
+    {
+        DebugGuard.MustBeLessThan(y, this.YSize, nameof(y));
+
+        Span<byte> row = this.Bytes.Span[((y * this.BytesPerRow) + plus)..];
+        return MemoryMarshal.Cast<byte, T>(row);
+    }
+
+    /// <summary>
+    /// Swaps properties &amp; data of this image with the specified image.
+    /// </summary>
+    /// <param name="other">The other image to swap with.</param>
+    public void Swap(JxlPlaneBase other)
+    {
+        (this.XSize, other.XSize) = (other.XSize, this.XSize);
+        (this.YSize, other.YSize) = (other.YSize, this.YSize);
+        (this.OriginalXSize, other.OriginalXSize) = (other.OriginalXSize, this.OriginalXSize);
+        (this.OriginalYSize, other.OriginalYSize) = (other.OriginalYSize, this.OriginalYSize);
+        (this.BytesPerRow, other.BytesPerRow) = (other.BytesPerRow, this.BytesPerRow);
+        (this.bytes, other.bytes) = (other.bytes, this.bytes);
+    }
+
+    /// <summary>
+    /// Releases all underlying memory used by this plane.
+    /// </summary>
+    public void Dispose()
+    {
+        this.bytes?.Dispose();
+        GC.SuppressFinalize(this);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/JxlPlane{T}.cs b/src/ImageSharp/Formats/Jxl/Memory/JxlPlane{T}.cs
new file mode 100644
index 0000000000..489b529221
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/JxlPlane{T}.cs
@@ -0,0 +1,113 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory;
+
+/// <summary>
+/// A generic version of a 2D single-plane JPEG XL image.
+/// </summary>
+/// <typeparam name="T">The type of each pixel.</typeparam>
+internal class JxlPlane<T> : JxlPlaneBase
+    where T : unmanaged
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlPlane{T}"/> class.
+    /// </summary>
+    public JxlPlane()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlPlane{T}"/> class with the specified width and height.
+    /// </summary>
+    /// <param name="width">Plane width.</param>
+    /// <param name="height">Plane height</param>
+    public unsafe JxlPlane(int width, int height)
+        : base(width, height, sizeof(T))
+    {
+    }
+
+    /// <summary>
+    /// Gets the number of pixels per row.
+    /// </summary>
+    public unsafe int PixelsPerRow => this.BytesPerRow / sizeof(T);
+
+    /// <summary>
+    /// Allocates a new plane.
+    /// </summary>
+    /// <param name="configuration">The configuration which contains a memory allocator.</param>
+    /// <param name="xSize">Plane width</param>
+    /// <param name="ySize">Plane height</param>
+    /// <param name="prePadding">Padding</param>
+    /// <returns>A new allocated plane</returns>
+    /// <exception cref="InvalidOperationException">Thrown when allocation fails.</exception>
+    public static JxlPlane<T> Create(Configuration configuration, int xSize, int ySize, int prePadding = 0)
+    {
+        JxlPlane<T> plane = new(xSize, ySize);
+
+        bool allocated = plane.Allocate(configuration, prePadding);
+
+        if (!allocated)
+        {
+            throw new InvalidOperationException("Failed to allocate a JPEG XL plane");
+        }
+
+        return plane;
+    }
+
+    /// <summary>
+    /// Returns a span for the specified row.
+    /// </summary>
+    /// <param name="y">The row index.</param>
+    /// <returns>A span which covers memory for the specified row.</returns>
+    public Span<T> GetRow(int y) => this.GetRowBase<T>(y);
+
+    /// <summary>
+    /// Returns a span for the specified row, but backwards by specified number of elements.
+    /// </summary>
+    /// <param name="y">The row index.</param>
+    /// <param name="minus">Once the offset of the row was derived, this is how much to subtract the offset.</param>
+    /// <returns>A span which covers memory for the specified row.</returns>
+    public Span<T> GetRowMinus(int y, int minus) => this.GetRowMinusBase<T>(y, minus);
+
+    /// <summary>
+    /// Returns a span for the specified row, but with offset by specified number of elements.
+    /// </summary>
+    /// <param name="y">The row index.</param>
+    /// <param name="plus">Once the offset of the row was derived, this is the additional offset.</param>
+    /// <returns>A span which covers memory for the specified row.</returns>
+    public Span<T> GetRowPlus(int y, int plus) => this.GetRowMinusBase<T>(y, plus);
+
+    /// <summary>
+    /// Returns a span for the specified row within the specified rectangle bounds.
+    /// </summary>
+    /// <param name="rectangle">The bounds.</param>
+    /// <param name="y">The row index.</param>
+    /// <returns>A span which covers memory for the specified row with the rectangle offsets.</returns>
+    public Span<T> GetRow(Rectangle rectangle, int y)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(y + rectangle.Top, 0, nameof(y));
+
+        return this.GetRow(y + rectangle.Top)[rectangle.Left..];
+    }
+
+    /// <summary>
+    /// Checks if the specified rectangle is within the bounds image.
+    /// </summary>
+    /// <param name="rectangle">The input rectangle.</param>
+    /// <returns>Boolean indicating whether the rectangle is inside.</returns>
+    public bool IsRectangleInside(Rectangle rectangle) => rectangle.Contains(this.GetRectangle());
+
+    /// <summary>
+    /// Returns the rectangle for this image bounds.
+    /// </summary>
+    /// <returns>A rectangle with x,y=0,0 width,height=XSize,YSize.</returns>
+    public Rectangle GetRectangle() => new(0, 0, this.XSize, this.YSize);
+
+    /// <summary>
+    /// Fills everything in this image with 0.
+    /// </summary>
+    public void Clear() => JxlImageOperations.ZeroFillImage(this);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Memory/JxlSpanHelper.cs b/src/ImageSharp/Formats/Jxl/Memory/JxlSpanHelper.cs
new file mode 100644
index 0000000000..fcf9b61aa5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Memory/JxlSpanHelper.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Memory;
+
+internal static class JxlSpanHelper
+{
+    public static T NthElement<T>(this Span<T> span, int n)
+        where T : IComparable<T>
+    {
+        int left = 0;
+        int right = span.Length - 1;
+
+        while (true)
+        {
+            int pivotIndex = Partition(span, left, right);
+            if (pivotIndex == n)
+            {
+                return span[pivotIndex];
+            }
+            else if (n < pivotIndex)
+            {
+                right = pivotIndex - 1;
+            }
+            else
+            {
+                left = pivotIndex + 1;
+            }
+        }
+    }
+
+    private static int Partition<T>(Span<T> span, int left, int right)
+        where T : IComparable<T>
+    {
+        T pivot = span[right];
+        int storeIndex = left;
+
+        for (int i = left; i < right; i++)
+        {
+            if (span[i].CompareTo(pivot) < 0)
+            {
+                (span[i], span[storeIndex]) = (span[storeIndex], span[i]);
+                storeIndex++;
+            }
+        }
+
+        (span[storeIndex], span[right]) = (span[right], span[storeIndex]);
+        return storeIndex;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/IJxlDctAcImage.cs b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/IJxlDctAcImage.cs
new file mode 100644
index 0000000000..6d773d7cd3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/IJxlDctAcImage.cs
@@ -0,0 +1,70 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+/// <summary>
+/// Base DCT AC coefficient image
+/// </summary>
+internal interface IJxlDctAcImage
+{
+    /// <summary>
+    /// Gets the bit width of AC coefficients
+    /// </summary>
+    public JxlDctAcType Type { get; }
+
+    /// <summary>
+    /// Gets the number of pixels per row.
+    /// </summary>
+    public int PixelsPerRow { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the image is empty and doesn't
+    /// have anything within.
+    /// </summary>
+    public bool IsEmpty { get; }
+
+    /// <summary>
+    /// Returns a reference to the coefficients at the specified row.
+    /// </summary>
+    /// <param name="channel">The plane index (which channel).</param>
+    /// <param name="y">The row index within plane specified by <paramref name="channel"/>.</param>
+    /// <param name="xBase">The X offset at the specified row.</param>
+    /// <returns>
+    /// A reference to the coefficients inside the channel
+    /// specified by index <paramref name="channel"/>, at index of
+    /// the row specified by <paramref name="y"/>, with X offset
+    /// specified by <paramref name="xBase"/>.
+    /// </returns>
+    public JxlDctAcPointer GetPlaneRow(int channel, int y, int xBase = 0);
+
+    /// <summary>
+    /// Returns a reference to the coefficients at the specified row.
+    /// </summary>
+    /// <param name="channel">The plane index (which channel).</param>
+    /// <param name="y">The row index within plane specified by <paramref name="channel"/>.</param>
+    /// <param name="xBase">The X offset at the specified row.</param>
+    /// <returns>
+    /// A reference to the coefficients inside the channel
+    /// specified by index <paramref name="channel"/>, at index of
+    /// the row specified by <paramref name="y"/>, with X offset
+    /// specified by <paramref name="xBase"/>.
+    /// </returns>
+    /// <remarks>
+    /// This is a read-only kind of <see cref="GetPlaneRow(int, int, int)"/>.
+    /// </remarks>
+    public JxlDctReadOnlyAcPointer GetReadOnlyPlaneRow(int channel, int y, int xBase = 0);
+
+    /// <summary>
+    /// Fills all planes with zero.
+    /// </summary>
+    public void Clear();
+
+    /// <summary>
+    /// Fills everything within the specified plane with zero.
+    /// </summary>
+    /// <param name="plane">Desired index of the plane.</param>
+    public void Clear(int plane = 0);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcContext.cs b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcContext.cs
new file mode 100644
index 0000000000..61893c621b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcContext.cs
@@ -0,0 +1,55 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+/// <summary>
+/// AC context
+/// </summary>
+internal static class JxlAcContext
+{
+    public const int DctOrderContextStart = 0;
+    public const int NonZeroBuckets = 37;
+    public const int ZeroDensityContextCount = 458;
+    public const int ZeroDensityContextLimit = 474;
+
+    public static ReadOnlySpan<int> CoefficientFrequencyContext =>
+    [
+        0xBAD, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14,
+        15,    15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+        23,    23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26,
+        27,    27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 30,
+    ];
+
+    public static ReadOnlySpan<int> CoefficientNumNonzeroContext =>
+    [
+        0xBAD, 0,   31,  62,  62,  93,  93,  93,  93,  123, 123, 123, 123,
+        152,   152, 152, 152, 152, 152, 152, 152, 180, 180, 180, 180, 180,
+        180,   180, 180, 180, 180, 180, 180, 206, 206, 206, 206, 206, 206,
+        206,   206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
+        206,   206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
+    ];
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int ZeroDensityContext(int nonZeroesLeft, int k, int coveredBlocks, int log2CoveredBlocks, int prev)
+    {
+        DebugGuard.IsTrue((1 << log2CoveredBlocks) == coveredBlocks, "log2CoveredBlocks must be equal to Log2(coveredBlocks)");
+
+        nonZeroesLeft = (nonZeroesLeft + coveredBlocks - 1) >> log2CoveredBlocks;
+        k >>= log2CoveredBlocks;
+
+        if (k is < 0 or >= 64)
+        {
+            throw new InvalidOperationException("k must be within range of 0..63 inclusive");
+        }
+
+        if (nonZeroesLeft is <= 0 or >= 64)
+        {
+            throw new InvalidOperationException("nonZeroesLeft must be within range of 1..63 inclusive");
+        }
+
+        return ((CoefficientNumNonzeroContext[nonZeroesLeft] + CoefficientFrequencyContext[k]) * 2) + prev;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategy.cs b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategy.cs
new file mode 100644
index 0000000000..78e97ed16c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategy.cs
@@ -0,0 +1,182 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives.JxlFrameDimensions;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+[StructLayout(LayoutKind.Sequential, Pack = 8)]
+internal struct JxlAcStrategy
+{
+    public const int MaximumCoefficientBlocks = 32;
+    public const int MaximumBlockDimension = BlockDimensions * MaximumCoefficientBlocks;
+    public const int MaximumCoefficientArea = MaximumBlockDimension * MaximumBlockDimension;
+    public const int NumberOfValidStrategies = 27;
+
+    private static readonly int MultiblockBits =
+        GetTypeBit(JxlAcStrategyType.DCT16X16) | GetTypeBit(JxlAcStrategyType.DCT32X32) |
+        GetTypeBit(JxlAcStrategyType.DCT16X8) | GetTypeBit(JxlAcStrategyType.DCT8X16) |
+        GetTypeBit(JxlAcStrategyType.DCT32X8) | GetTypeBit(JxlAcStrategyType.DCT8X32) |
+        GetTypeBit(JxlAcStrategyType.DCT16X32) | GetTypeBit(JxlAcStrategyType.DCT32X16) |
+        GetTypeBit(JxlAcStrategyType.DCT32X64) | GetTypeBit(JxlAcStrategyType.DCT64X32) |
+        GetTypeBit(JxlAcStrategyType.DCT64X64) | GetTypeBit(JxlAcStrategyType.DCT64X128) |
+        GetTypeBit(JxlAcStrategyType.DCT128X64) |
+        GetTypeBit(JxlAcStrategyType.DCT128X128) |
+        GetTypeBit(JxlAcStrategyType.DCT128X256) |
+        GetTypeBit(JxlAcStrategyType.DCT256X128) |
+        GetTypeBit(JxlAcStrategyType.DCT256X256);
+
+    private readonly bool isFirst;
+
+    public JxlAcStrategy(JxlAcStrategyType strategy, bool isFirst)
+    {
+        this.Strategy = strategy;
+        this.isFirst = isFirst;
+    }
+
+    public JxlAcStrategy(JxlAcStrategyType strategy)
+        : this(strategy, true)
+    {
+    }
+
+    public JxlAcStrategy(int rawStrategy)
+        : this((JxlAcStrategyType)rawStrategy)
+    {
+    }
+
+    private static ReadOnlySpan<byte> CoveredBlocksXLookup =>
+    [
+        1, 1, 1, 1,  2, 4,  1,  2,  1,
+        4, 2, 4, 1,  1, 1,  1,  1,  1,
+        8, 4, 8, 16, 8, 16, 32, 16, 32
+    ];
+
+    private static ReadOnlySpan<byte> CoveredBlocksYLookup =>
+    [
+        1, 1, 1, 1,  2,  4, 2,  1,  4,
+        1, 4, 2, 1,  1,  1, 1,  1,  1,
+        8, 8, 4, 16, 16, 8, 32, 32, 16
+    ];
+
+    private static ReadOnlySpan<byte> Log2CoveredBlocksLookup =>
+    [
+        0, 0, 0, 0, 2, 4, 1,  1, 2,
+        2, 3, 3, 0, 0, 0, 0,  0, 0,
+        6, 5, 5, 8, 7, 7, 10, 9, 9
+    ];
+
+    public readonly bool IsMultiblock => ((1 << (int)this.Strategy) & MultiblockBits) != 0;
+
+    public readonly int RawStrategy => (int)this.Strategy;
+
+    public readonly int CoveredBlocksX => CoveredBlocksXLookup[(int)this.Strategy];
+
+    public readonly int CoveredBlocksY => CoveredBlocksYLookup[(int)this.Strategy];
+
+    public readonly int Log2CoveredBlocks => Log2CoveredBlocksLookup[(int)this.Strategy];
+
+    public readonly bool IsFirstBlock => this.isFirst;
+
+    public readonly JxlAcStrategyType Strategy { get; }
+
+    public readonly void ComputeNaturalCoefficientOrder(Span<int> order) => CoefficientOrderAndLookup(this, false, order);
+
+    public readonly void ComputeNaturalCoefficientOrderLookup(Span<int> lookup) => CoefficientOrderAndLookup(this, true, lookup);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int GetTypeBit(JxlAcStrategyType type) => 1 << (int)type;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool IsRawStrategyValid(int rawStrategy) => rawStrategy is < NumberOfValidStrategies and >= 0;
+
+    private static void CoefficientOrderAndLookup(JxlAcStrategy strategy, bool isLookup, Span<int> output)
+    {
+        // TODO: CoefficientLayout
+        int cx = strategy.CoveredBlocksX;
+        int cy = strategy.CoveredBlocksY;
+
+        JxlForwardCoefficientOrder.CoefficientLayout(ref cx, ref cy);
+
+        int xs = cx / cy;
+        int xsm = xs - 1;
+        int xss = JxlMath.CeilLog2Nonzero(xs);
+        int cur = cx * cy;
+
+        for (int i = 0; i < cx * BlockDimensions; i++)
+        {
+            for (int j = 0; j <= i; j++)
+            {
+                int x = j;
+                int y = i - j;
+
+                if ((i & 1) == 0)
+                {
+                    // swap
+                    (x, y) = (y, x);
+                }
+
+                if ((y & xsm) != 0)
+                {
+                    continue;
+                }
+
+                y >>= xss;
+                int value = 0;
+
+                if (x < cx && y < cy)
+                {
+                    value = (y * cx) + x;
+                }
+                else
+                {
+                    value = cur++;
+                }
+
+                if (isLookup)
+                {
+                    output[((y * cx) * BlockDimensions) + x] = value;
+                }
+                else
+                {
+                    output[value] = ((y * cx) * BlockDimensions) + x;
+                }
+            }
+        }
+
+        for (int ip = (cx * BlockDimensions) - 1; ip > 0; ip--)
+        {
+            int i = ip - 1;
+
+            for (int j = 0; j <= i; j++)
+            {
+                int x = (cx * BlockDimensions) - 1 - (i - j);
+                int y = (cx * BlockDimensions) - 1 - j;
+
+                if ((i & 1) != 0)
+                {
+                    // swap
+                    (x, y) = (y, x);
+                }
+
+                if ((y & xsm) != 0)
+                {
+                    continue;
+                }
+
+                y >>= xss;
+                int value = cur++;
+
+                if (isLookup)
+                {
+                    output[((y * cx) * BlockDimensions) + x] = value;
+                }
+                else
+                {
+                    output[value] = ((y * cx) * BlockDimensions) + x;
+                }
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyImage.cs b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyImage.cs
new file mode 100644
index 0000000000..4c751e290c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyImage.cs
@@ -0,0 +1,118 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+internal sealed class JxlAcStrategyImage : IDisposable
+{
+    private const byte Invalid = byte.MaxValue; // 255
+
+    private JxlImageB? layers;
+    private Memory<byte> row;
+    private int stride;
+
+    public int XSize => this.layers!.XSize;
+
+    public int YSize => this.layers!.YSize;
+
+    public int PixelsPerRow => this.layers!.PixelsPerRow;
+
+    public JxlAcStrategyRow GetRow(int y, int xPrefix = 0)
+    {
+        ReadOnlyMemory<byte> layerRow = this.layers!.GetRowBytesMemory(y);
+        ReadOnlyMemory<byte> row = layerRow[xPrefix..];
+
+        return new JxlAcStrategyRow(row);
+    }
+
+    public static JxlAcStrategyImage Create(Configuration memoryManager, int xSize, int ySize)
+    {
+        JxlAcStrategyImage image = new()
+        {
+            layers = new JxlImageB(memoryManager, xSize, ySize)
+        };
+
+        image.row = image.layers.GetRowBytesMemory(0);
+        image.stride = image.layers.PixelsPerRow;
+
+        return image;
+    }
+
+    public int CountBlocks(JxlAcStrategyType type)
+    {
+        int value = 0;
+        int compare = ((int)type << 1) | 1;
+
+        for (int y = 0; y < this.layers!.YSize; y++)
+        {
+            ReadOnlySpan<byte> row = this.layers!.GetRow(y);
+
+            for (int x = 0; x < this.layers!.XSize; x++)
+            {
+                if (row[x] == compare)
+                {
+                    value++;
+                }
+            }
+        }
+
+        return value;
+    }
+
+    public JxlAcStrategyRow GetRow(in Rectangle rect, int y) => this.GetRow(rect.Y + y, rect.X);
+
+    public bool IsValid(int x, int y) => this.row.Span[(y * this.stride) + x] != Invalid;
+
+    public bool SetNoBoundsChecks(int x, int y, JxlAcStrategyType type, bool check = true)
+    {
+        JxlAcStrategy strategy = new(type);
+        Span<byte> rowSpan = this.row.Span;
+        int rawType = (int)type;
+        int rawTypeTimes2 = rawType << 1;
+
+        for (int iy = 0; iy < strategy.CoveredBlocksX; iy++)
+        {
+            for (int ix = 0; ix < strategy.CoveredBlocksX; ix++)
+            {
+                int pos = ((y + iy) * this.stride) + x + ix;
+
+                if (check && rowSpan[pos] != Invalid)
+                {
+                    throw new InvalidOperationException("Invalid AC strategy. Blocks overlap.");
+                }
+
+                rowSpan[pos] = (byte)(rawTypeTimes2 | ((iy | ix) == 0 ? 1 : 0));
+            }
+        }
+
+        return true;
+    }
+
+    public bool Set(int x, int y, JxlAcStrategyType type)
+    {
+        JxlAcStrategy strategy = new(type);
+
+        if (y + strategy.CoveredBlocksX > this.layers!.YSize ||
+            x + strategy.CoveredBlocksX > this.layers.XSize)
+        {
+            throw new InvalidOperationException("Invalid range");
+        }
+
+        return this.SetNoBoundsChecks(x, y, type, check: false);
+    }
+
+    public void FillDct8(in Rectangle rect) => JxlImageOperations.FillPlane((byte)(((int)JxlAcStrategyType.DCT << 1) | 1), this.layers ?? throw new InvalidOperationException("Image is missing"), rect);
+
+    public void FillDct8() => this.FillDct8(this.layers!.GetRectangle());
+
+    public void FillInvalid() => JxlImageOperations.FillImage(Invalid, this.layers ?? throw new InvalidOperationException("Image is missing"));
+
+    public void Dispose()
+    {
+        this.layers?.Dispose();
+        GC.SuppressFinalize(this);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyRow.cs b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyRow.cs
new file mode 100644
index 0000000000..60900dc578
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyRow.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+internal readonly struct JxlAcStrategyRow(ReadOnlyMemory<byte> row)
+{
+    public readonly JxlAcStrategy this[int x]
+    {
+        get
+        {
+            ReadOnlySpan<byte> span = row.Span;
+
+            DebugGuard.MustBeLessThan(x * 8, span.Length, "x overflows");
+
+            ref byte first = ref MemoryMarshal.GetReference(span);
+            JxlAcStrategyType strategy = (JxlAcStrategyType)(Unsafe.Add(ref Unsafe.As<byte, int>(ref first), x) >> 1);
+            bool isFirst = Unsafe.Add(ref first, x) != 0;
+
+            return new JxlAcStrategy(strategy, isFirst);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyType.cs b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyType.cs
new file mode 100644
index 0000000000..317f71ccb3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/AcStrategy/JxlAcStrategyType.cs
@@ -0,0 +1,67 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+internal enum JxlAcStrategyType : ushort
+{
+    // Regular block size DCT
+    DCT = 0,
+
+    // Encode pixels without transforming
+    IDENTITY = 1,
+
+    // Use 2-by-2 DCT
+    DCT2X2 = 2,
+
+    // Use 4-by-4 DCT
+    DCT4X4 = 3,
+
+    // Use 16-by-16 DCT
+    DCT16X16 = 4,
+
+    // Use 32-by-32 DCT
+    DCT32X32 = 5,
+
+    // Use 16-by-8 DCT
+    DCT16X8 = 6,
+
+    // Use 8-by-16 DCT
+    DCT8X16 = 7,
+
+    // Use 32-by-8 DCT
+    DCT32X8 = 8,
+
+    // Use 8-by-32 DCT
+    DCT8X32 = 9,
+
+    // Use 32-by-16 DCT
+    DCT32X16 = 10,
+
+    // Use 16-by-32 DCT
+    DCT16X32 = 11,
+
+    // 4x8 and 8x4 DCT
+    DCT4X8 = 12,
+    DCT8X4 = 13,
+
+    // Corner-DCT.
+    AFV0 = 14,
+
+    AFV1 = 15,
+    AFV2 = 16,
+    AFV3 = 17,
+
+    // Larger DCTs
+    DCT64X64 = 18,
+    DCT64X32 = 19,
+    DCT32X64 = 20,
+
+    // No transforms smaller than 64x64 are allowed below.
+    DCT128X128 = 21,
+    DCT128X64 = 22,
+    DCT64X128 = 23,
+    DCT256X256 = 24,
+    DCT256X128 = 25,
+    DCT128X256 = 26
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaBlendingInputLayer.cs b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaBlendingInputLayer.cs
new file mode 100644
index 0000000000..b749a5ba26
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaBlendingInputLayer.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Blending;
+
+internal ref struct JxlAlphaBlendingInputLayer(ReadOnlySpan<float> singleSpan)
+{
+    public ReadOnlySpan<float> R = singleSpan;
+
+    public ReadOnlySpan<float> G = singleSpan;
+
+    public ReadOnlySpan<float> B = singleSpan;
+
+    public ReadOnlySpan<float> A = singleSpan;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaBlendingOutput.cs b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaBlendingOutput.cs
new file mode 100644
index 0000000000..76a10d2158
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaBlendingOutput.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Blending;
+
+internal ref struct JxlAlphaBlendingOutput(Span<float> singleSpan)
+{
+    public Span<float> R = singleSpan;
+
+    public Span<float> G = singleSpan;
+
+    public Span<float> B = singleSpan;
+
+    public Span<float> A = singleSpan;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaHelper.cs b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaHelper.cs
new file mode 100644
index 0000000000..1393e5cfa6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlAlphaHelper.cs
@@ -0,0 +1,189 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Blending;
+
+// TODO: SIMD support
+internal sealed class JxlAlphaHelper
+{
+    private const float SmallAlpha = 1f / (1 << 26);
+
+    // Force x to stay within the range of 0 through 1
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float Clamp(float x) => Math.Clamp(x, 0f, 1f);
+
+    public static void PerformAlphaBlending(
+        JxlAlphaBlendingInputLayer background,
+        JxlAlphaBlendingInputLayer foreground,
+        JxlAlphaBlendingOutput output,
+        int pixelCount,
+        bool alphaIsPremultiplied,
+        bool clamp)
+    {
+        ReadOnlySpan<float> fgR = foreground.R;
+        ReadOnlySpan<float> fgG = foreground.G;
+        ReadOnlySpan<float> fgB = foreground.B;
+        ReadOnlySpan<float> fgA = foreground.A;
+
+        ReadOnlySpan<float> bgR = background.R;
+        ReadOnlySpan<float> bgG = background.G;
+        ReadOnlySpan<float> bgB = background.B;
+        ReadOnlySpan<float> bgA = background.A;
+
+        Span<float> outR = output.R;
+        Span<float> outG = output.G;
+        Span<float> outB = output.B;
+        Span<float> outA = output.A;
+
+        if (alphaIsPremultiplied)
+        {
+            for (int x = 0; x < pixelCount; x++)
+            {
+                float fga = clamp ? Clamp(fgA[x]) : fgA[x];
+                outR[x] = fgR[x] + (bgR[x] * (1f - fga));
+                outG[x] = fgG[x] + (bgG[x] * (1f - fga));
+                outB[x] = fgB[x] + (bgB[x] * (1f - fga));
+                outA[x] = 1f - ((1f - fga) * (1f - bgA[x]));
+            }
+        }
+        else
+        {
+            for (int x = 0; x < pixelCount; x++)
+            {
+                float fga = clamp ? Clamp(fgA[x]) : fgA[x];
+                float newA = 1f - ((1f - fga) * (1f - bgA[x]));
+                float rnewA = newA > 0 ? 1f / newA : 0f;
+                outR[x] = ((fgR[x] * fga) + (bgR[x] * bgA[x] * (1f - fga))) * rnewA;
+                outG[x] = ((fgG[x] * fga) + (bgG[x] * bgA[x] * (1f - fga))) * rnewA;
+                outB[x] = ((fgB[x] * fga) + (bgB[x] * bgA[x] * (1f - fga))) * rnewA;
+                outA[x] = newA;
+            }
+        }
+    }
+
+    public static void PerformAlphaBlending(
+        ReadOnlySpan<float> bg,
+        ReadOnlySpan<float> bga,
+        ReadOnlySpan<float> fg,
+        ReadOnlySpan<float> fga,
+        Span<float> output,
+        int pixelCount,
+        bool alphaIsPremultiplied,
+        bool clamp)
+    {
+        if (bg == bga && fg == fga)
+        {
+            for (int x = 0; x < pixelCount; x++)
+            {
+                float fa = clamp ? Clamp(fga[x]) : fga[x];
+                output[x] = 1f - ((1f - fa) * (1f - bga[x]));
+            }
+        }
+        else
+        {
+            if (alphaIsPremultiplied)
+            {
+                for (int x = 0; x < pixelCount; x++)
+                {
+                    float fa = clamp ? Clamp(fga[x]) : fga[x];
+                    output[x] = fg[x] + (bg[x] * (1f - fa));
+                }
+            }
+            else
+            {
+                for (int x = 0; x < pixelCount; x++)
+                {
+                    float fa = clamp ? Clamp(fga[x]) : fga[x];
+                    float new_a = 1f - ((1f - fa) * (1f - bga[x]));
+                    float rnew_a = new_a > 0 ? 1f / new_a : 0f;
+                    output[x] = ((fg[x] * fa) + (bg[x] * bga[x] * (1f - fa))) * rnew_a;
+                }
+            }
+        }
+    }
+
+    public static void PerformAlphaWeightedAdd(
+        ReadOnlySpan<float> bg,
+        ReadOnlySpan<float> fg,
+        ReadOnlySpan<float> fga,
+        Span<float> output,
+        int pixelCount,
+        bool clamp)
+    {
+        if (fg == fga)
+        {
+            bg[pixelCount..].CopyTo(output);
+        }
+        else if (clamp)
+        {
+            for (int x = 0; x < pixelCount; x++)
+            {
+                output[x] = bg[x] + (fg[x] * Clamp(fga[x]));
+            }
+        }
+        else
+        {
+            for (int x = 0; x < pixelCount; ++x)
+            {
+                output[x] = bg[x] + (fg[x] * fga[x]);
+            }
+        }
+    }
+
+    public static void PerformMultiplyBlending(
+        ReadOnlySpan<float> bg,
+        ReadOnlySpan<float> fg,
+        Span<float> output,
+        int pixelCount,
+        bool clamp)
+    {
+        if (clamp)
+        {
+            for (int x = 0; x < pixelCount; x++)
+            {
+                output[x] = bg[x] * Clamp(fg[x]);
+            }
+        }
+        else
+        {
+            for (int x = 0; x < pixelCount; x++)
+            {
+                output[x] = bg[x] * fg[x];
+            }
+        }
+    }
+
+    public static void PremultiplyAlpha(
+        Span<float> r,
+        Span<float> g,
+        Span<float> b,
+        ReadOnlySpan<float> a,
+        int pixelCount)
+    {
+        for (int x = 0; x < pixelCount; x++)
+        {
+            float multiplier = Math.Max(SmallAlpha, a[x]);
+            r[x] *= multiplier;
+            g[x] *= multiplier;
+            b[x] *= multiplier;
+        }
+    }
+
+    public static void UnpremultiplyAlpha(
+        Span<float> r,
+        Span<float> g,
+        Span<float> b,
+        ReadOnlySpan<float> a,
+        int pixelCount)
+    {
+        for (int x = 0; x < pixelCount; x++)
+        {
+            float multiplier = 1f / Math.Max(SmallAlpha, a[x]);
+            r[x] *= multiplier;
+            g[x] *= multiplier;
+            b[x] *= multiplier;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlBlending.cs b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlBlending.cs
new file mode 100644
index 0000000000..a595406f36
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Blending/JxlBlending.cs
@@ -0,0 +1,368 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Blending;
+
+internal static class JxlBlending
+{
+    public static bool NeedsBlending(JxlFrameHeader header)
+    {
+        if (header.FrameType is not JxlFrameType.RegularFrame and not JxlFrameType.SkipProgressive)
+        {
+            return false;
+        }
+
+        JxlBlendingInfo? blendingInfo = header.BlendingInfo;
+        if (blendingInfo is null)
+        {
+            return false;
+        }
+
+        bool replaceAll = blendingInfo.BlendMode == JxlBlendMode.Replace;
+
+        foreach (JxlBlendingInfo info in header.ExtraChannelBlendingInfo)
+        {
+            if (info.BlendMode != JxlBlendMode.Replace)
+            {
+                replaceAll = false;
+            }
+        }
+
+        if (!header.CustomSizeOrOrigin && replaceAll)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static void PerformBlending(
+        Configuration configuration,
+        Buffer2D<float> bg,
+        Buffer2D<float> fg,
+        Buffer2D<float> output,
+        int x0,
+        int xsize,
+        JxlPatchBlending colorBlending,
+        Span<JxlPatchBlending> ecBlending,
+        List<JxlExtraChannelInfo> extraChannelInfo)
+    {
+        bool hasAlpha = extraChannelInfo.Any(x => x.Type == JxlExtraChannel.Alpha);
+
+        int numEc = extraChannelInfo.Count;
+        using JxlImageF tmp = new(configuration, xsize, 3 + numEc);
+
+        for (int i = 0; i < numEc; i++)
+        {
+            int i3 = 3 + i;
+
+            switch (ecBlending[i].Mode)
+            {
+                case JxlPatchBlendMode.Add:
+                {
+                    Span<float> row = tmp.GetRow(i3);
+                    for (int x = 0; x < xsize; x++)
+                    {
+                        row[x] = bg[i3, x + x0] + fg[i3, x + x0];
+                    }
+
+                    continue;
+                }
+
+                case JxlPatchBlendMode.BlendAbove:
+                {
+                    int alpha = ecBlending[i].AlphaChannel;
+                    bool isPremultiplied = extraChannelInfo[alpha].AlphaAssociated;
+
+                    Span<float> bgSpan3 = bg.DangerousGetRowSpan(i3)[x0..];
+                    Span<float> bgSpan3Alpha = bg.DangerousGetRowSpan(3 + alpha)[x0..];
+                    Span<float> fgSpan3 = fg.DangerousGetRowSpan(i3)[x0..];
+                    Span<float> fgSpan3Alpha = fg.DangerousGetRowSpan(3 + alpha)[x0..];
+
+                    JxlAlphaHelper.PerformAlphaBlending(
+                        bgSpan3,
+                        bgSpan3Alpha,
+                        fgSpan3,
+                        fgSpan3Alpha,
+                        tmp.GetRow(i3),
+                        xsize,
+                        isPremultiplied,
+                        ecBlending[i].Clamp);
+
+                    continue;
+                }
+
+                case JxlPatchBlendMode.BlendBelow:
+                {
+                    int alpha = ecBlending[i].AlphaChannel;
+                    bool isPremultiplied = extraChannelInfo[alpha].AlphaAssociated;
+
+                    Span<float> bgSpan3 = bg.DangerousGetRowSpan(i3)[x0..];
+                    Span<float> bgSpan3Alpha = bg.DangerousGetRowSpan(3 + alpha)[x0..];
+                    Span<float> fgSpan3 = fg.DangerousGetRowSpan(i3)[x0..];
+                    Span<float> fgSpan3Alpha = fg.DangerousGetRowSpan(3 + alpha)[x0..];
+
+                    JxlAlphaHelper.PerformAlphaBlending(
+                        bgSpan3,
+                        bgSpan3Alpha,
+                        fgSpan3,
+                        fgSpan3Alpha,
+                        tmp.GetRow(3 + i),
+                        xsize,
+                        isPremultiplied,
+                        ecBlending[i].Clamp);
+
+                    continue;
+                }
+
+                case JxlPatchBlendMode.AlphaWeightedAddAbove:
+                {
+                    int alpha = ecBlending[i].AlphaChannel;
+
+                    Span<float> bgSpan3 = bg.DangerousGetRowSpan(i3)[x0..];
+                    Span<float> bgSpan3Alpha = bg.DangerousGetRowSpan(3 + alpha)[x0..];
+                    Span<float> fgSpan3 = fg.DangerousGetRowSpan(i3)[x0..];
+
+                    JxlAlphaHelper.PerformAlphaWeightedAdd(
+                        bgSpan3,
+                        fgSpan3,
+                        bgSpan3Alpha,
+                        tmp.GetRow(3 + i),
+                        xsize,
+                        ecBlending[i].Clamp);
+
+                    continue;
+                }
+
+                case JxlPatchBlendMode.AlphaWeightedAddBelow:
+                {
+                    int alpha = ecBlending[i].AlphaChannel;
+
+                    Span<float> bgSpan3 = bg.DangerousGetRowSpan(i3)[x0..];
+                    Span<float> bgSpan3Alpha = bg.DangerousGetRowSpan(3 + alpha)[x0..];
+                    Span<float> fgSpan3 = fg.DangerousGetRowSpan(i3)[x0..];
+
+                    JxlAlphaHelper.PerformAlphaWeightedAdd(
+                        fgSpan3,
+                        bgSpan3,
+                        bgSpan3Alpha,
+                        tmp.GetRow(3 + i),
+                        xsize,
+                        ecBlending[i].Clamp);
+
+                    continue;
+                }
+
+                case JxlPatchBlendMode.Multiply:
+                {
+                    Span<float> bgSpan3 = bg.DangerousGetRowSpan(i3)[x0..];
+                    Span<float> fgSpan3 = fg.DangerousGetRowSpan(i3)[x0..];
+
+                    JxlAlphaHelper.PerformMultiplyBlending(
+                        bgSpan3,
+                        fgSpan3,
+                        tmp.GetRow(i3),
+                        xsize,
+                        ecBlending[i].Clamp);
+
+                    continue;
+                }
+
+                case JxlPatchBlendMode.Replace:
+                    if (xsize > 0)
+                    {
+                        Span<float> fgSpan3 = fg.DangerousGetRowSpan(i3)[x0..];
+                        fgSpan3.Slice(0, xsize).CopyTo(tmp.GetRow(i3));
+                    }
+
+                    continue;
+
+                case JxlPatchBlendMode.None:
+                    if (xsize > 0)
+                    {
+                        Span<float> bgSpan3 = bg.DangerousGetRowSpan(i3)[x0..];
+                        bgSpan3.Slice(0, xsize).CopyTo(tmp.GetRow(i3));
+                    }
+
+                    continue;
+            }
+        }
+
+        int colorBlendingAlpha = colorBlending.AlphaChannel;
+
+        void Add()
+        {
+            for (int p = 0; p < 3; p++)
+            {
+                Span<float> output = tmp.GetRow(p);
+                Span<float> bgSpan = bg.DangerousGetRowSpan(p);
+                Span<float> fgSpan = fg.DangerousGetRowSpan(p);
+
+                for (int x = 0; x < xsize; x++)
+                {
+                    int xPlusX0 = x + x0;
+
+                    output[x] = bgSpan[xPlusX0] + fgSpan[xPlusX0];
+                }
+            }
+        }
+
+        void BlendWeighted(Span<float> bottom, Span<float> top)
+        {
+            bool isPremultiplied = extraChannelInfo[colorBlendingAlpha].AlphaAssociated;
+
+            JxlAlphaHelper.PerformAlphaBlending(
+                new JxlAlphaBlendingInputLayer()
+                {
+                    R = bottom[x0..],
+                    G = bottom[(x0 + 1)..],
+                    B = bottom[(2 + x0)..],
+                    A = bottom[(3 + colorBlendingAlpha + x0)..]
+                },
+                new JxlAlphaBlendingInputLayer()
+                {
+                    R = top[x0..],
+                    G = top[(x0 + 1)..],
+                    B = top[(x0 + 2)..],
+                    A = top[(3 + colorBlendingAlpha + x0)..]
+                },
+                new JxlAlphaBlendingOutput()
+                {
+                    R = tmp.GetRow(0),
+                    G = tmp.GetRow(1),
+                    B = tmp.GetRow(2),
+                    A = tmp.GetRow(3)
+                },
+                xsize,
+                isPremultiplied,
+                colorBlending.Clamp);
+        }
+
+        void AddWeighted(Span<float> bottom, Span<float> top)
+        {
+            for (int c = 0; c < 3; c++)
+            {
+                JxlAlphaHelper.PerformAlphaWeightedAdd(bottom[(c + x0)..], top[(c + x0)..], top[(3 + colorBlendingAlpha + x0)..], tmp.GetRow(c), xsize, colorBlending.Clamp);
+            }
+        }
+
+        void Copy(Span<float> src)
+        {
+            for (int p = 0; p < 3; p++)
+            {
+                src.Slice(p + x0, xsize).CopyTo(tmp.GetRow(p));
+            }
+        }
+
+        switch (colorBlending.Mode)
+        {
+            case JxlPatchBlendMode.Add:
+            {
+                Add();
+                break;
+            }
+
+            case JxlPatchBlendMode.AlphaWeightedAddAbove:
+            {
+                if (hasAlpha)
+                {
+                    AddWeighted(bg.DangerousGetSingleSpan(), fg.DangerousGetSingleSpan());
+                }
+                else
+                {
+                    Add();
+                }
+
+                break;
+            }
+
+            case JxlPatchBlendMode.AlphaWeightedAddBelow:
+            {
+                if (hasAlpha)
+                {
+                    AddWeighted(fg.DangerousGetSingleSpan(), bg.DangerousGetSingleSpan());
+                }
+                else
+                {
+                    Add();
+                }
+
+                break;
+            }
+
+            case JxlPatchBlendMode.BlendAbove:
+            {
+                if (hasAlpha)
+                {
+                    BlendWeighted(bg.DangerousGetSingleSpan(), fg.DangerousGetSingleSpan());
+                }
+                else
+                {
+                    Copy(fg.DangerousGetSingleSpan());
+                }
+
+                break;
+            }
+
+            case JxlPatchBlendMode.BlendBelow:
+            {
+                if (hasAlpha)
+                {
+                    BlendWeighted(fg.DangerousGetSingleSpan(), bg.DangerousGetSingleSpan());
+                }
+                else
+                {
+                    Copy(fg.DangerousGetSingleSpan());
+                }
+
+                break;
+            }
+
+            case JxlPatchBlendMode.Multiply:
+            {
+                Span<float> bgSpan = bg.DangerousGetSingleSpan();
+                Span<float> fgSpan = fg.DangerousGetSingleSpan();
+
+                for (int p = 0; p < 3; p++)
+                {
+                    JxlAlphaHelper.PerformMultiplyBlending(
+                        bgSpan[(p + x0)..],
+                        fgSpan[(p + x0)..],
+                        tmp.GetRow(p),
+                        xsize,
+                        colorBlending.Clamp);
+                }
+
+                break;
+            }
+
+            case JxlPatchBlendMode.Replace:
+            {
+                Copy(fg.DangerousGetSingleSpan());
+                break;
+            }
+
+            case JxlPatchBlendMode.None:
+            {
+                Copy(bg.DangerousGetSingleSpan());
+                break;
+            }
+        }
+
+        if (xsize != 0)
+        {
+            Span<float> outputSpan = output.DangerousGetSingleSpan();
+
+            for (int i = 0; i < 3; i++)
+            {
+                tmp.GetRow(i).Slice(0, xsize).CopyTo(outputSpan[(i + x0)..]);
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/Butteraugli.cs b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/Butteraugli.cs
new file mode 100644
index 0000000000..aad9e1972b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/Butteraugli.cs
@@ -0,0 +1,2674 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Butteraugli;
+
+/// <summary>
+/// Implementation of Google Butteraugli, an advanced
+/// image comparison system. Unlike PSNR or SSIM,
+/// Butteraugli compares images the way humans may
+/// spot differences instead of pixelwise.
+/// </summary>
+internal static class Butteraugli
+{
+    // NOTE: The meaning of those constants
+    // is not perfectly understood.
+    public const float WMfMalta = 37.0819870399f;
+    public const float Norm1Mf = 130262059.556f;
+    public const float WMfMaltaX = 8246.75321353f;
+    public const float Norm1MfX = 1009002.70582f;
+
+    public const float WHfMalta = 18.7237414387f;
+    public const float Norm1Hf = 4498534.45232f;
+    public const float WHfMaltaX = 6923.99476109f;
+    public const float Norm1HfX = 8051.15833247f;
+
+    public const float WUhfMalta = 1.10039032555f;
+    public const float Norm1Uhf = 71.7800275169f;
+    public const float WUhfMaltaX = 173.5f;
+    public const float Norm1UhfX = 5.0f;
+
+    private const float IntensityTargetNormalizationHack = 0.79079917404f;
+
+    private const float InternalGoodQualityThreshold =
+        17.83f * IntensityTargetNormalizationHack;
+
+    private const float GlobalScale =
+        1.0f / InternalGoodQualityThreshold;
+
+#pragma warning disable // Just indentation warnings
+    /// <summary>
+    /// Underlying data for <see cref="Heatmap"/>.
+    /// </summary>
+    private static readonly float[,] HeatmapData =
+    {
+        {0, 0, 0},       {0, 0, 1},
+        {0, 1, 1},       {0, 1, 0},  // Good level
+        {1, 1, 0},       {1, 0, 0},  // Bad level
+        {1, 0, 1},       {0.5f, 0.5f, 1.0f},
+        {1.0f, 0.5f, 0.5f},  // Pastel colors for the very bad quality range.
+        {1.0f, 1.0f, 0.5f}, {1, 1, 1},
+        {1, 1, 1},  // Last color repeated to have a solid range of white.
+    };
+#pragma warning restore
+
+    private static readonly DenseMatrix<float> Heatmap = new(HeatmapData);
+
+    public static ReadOnlySpan<float> Wmul =>
+    [
+        400.0f,         1.50815703118f,  0f,
+        2150.0f,        10.6195433239f,  16.2176043152f,
+        29.2353797994f, 0.844626970982f, 0.703646627719f,
+    ];
+
+    public static ReadOnlySpan<float> ComputeKernel(float sigma)
+    {
+        const float m = 2.25f;  // Accuracy increases when m is increased
+        float scaler = -1.0f / (2.0f * sigma * sigma);
+        int diff = Math.Max(1, (int)(m * MathF.Abs(sigma)));
+
+        // If sigma is very large we should not return a 'new float[]' allocation.
+        // This guard is temporary so we can verify the range of the number of elements.
+        // TODO: remove guard if the value doesn't exceed the limit for many JXL files
+        DebugGuard.MustBeLessThanOrEqualTo(sigma, 32f, nameof(sigma));
+
+        float[] kernel = new float[(2 * diff) + 1];
+
+        for (int i = -diff; i <= diff; i++)
+        {
+            kernel[i + diff] = MathF.Exp(scaler * i * i);
+        }
+
+        return kernel;
+    }
+
+    public static void ConvolveBorderColumn(
+        JxlPlane<float> input,
+        ReadOnlySpan<float> kernel,
+        int x,
+        Span<float> rowOut)
+    {
+        int offset = kernel.Length / 2;
+
+        int minX = x < offset ? 0 : x - offset;
+        int maxX = Math.Min(input.XSize - 1, x + offset);
+
+        float weight = 0.0f;
+
+        for (int j = minX; j <= maxX; j++)
+        {
+            weight += kernel[j - x + offset];
+        }
+
+        float scale = 1.0f / weight;
+
+        for (int y = 0; y < input.YSize; y++)
+        {
+            Span<float> rowIn = input.GetRow(y);
+
+            float sum = 0.0f;
+
+            for (int j = minX; j <= maxX; j++)
+            {
+                sum += rowIn[j] * kernel[j - x + offset];
+            }
+
+            rowOut[y] = sum * scale;
+        }
+    }
+
+    public static bool ConvolutionWithTranspose(
+        JxlPlane<float> input,
+        ReadOnlySpan<float> kernel,
+        JxlPlane<float> output)
+    {
+        if (output.XSize != input.YSize)
+        {
+            return false;
+        }
+
+        if (output.YSize != input.XSize)
+        {
+            return false;
+        }
+
+        int len = kernel.Length;
+        int offset = len / 2;
+
+        float weightNoBorder = 0.0f;
+
+        for (int j = 0; j < len; j++)
+        {
+            weightNoBorder += kernel[j];
+        }
+
+        float scaleNoBorder = 1.0f / weightNoBorder;
+
+        int border1 = Math.Min(input.XSize, offset);
+        int border2 = input.XSize > offset ? input.XSize - offset : 0;
+
+        Span<float> scaledKernel = stackalloc float[(len / 2) + 1];
+
+        for (int i = 0; i <= len / 2; i++)
+        {
+            scaledKernel[i] = kernel[i] * scaleNoBorder;
+        }
+
+        // Middle
+        switch (len)
+        {
+            case 7:
+            {
+                float sk0 = scaledKernel[0];
+                float sk1 = scaledKernel[1];
+                float sk2 = scaledKernel[2];
+                float sk3 = scaledKernel[3];
+
+                for (int y = 0; y < input.YSize; y++)
+                {
+                    Span<float> rowIn = input.GetRow(y);
+
+                    for (int x = border1; x < border2; x++)
+                    {
+                        int i = x - border1;
+
+                        float sum0 = (rowIn[i + 0] + rowIn[i + 6]) * sk0;
+                        float sum1 = (rowIn[i + 1] + rowIn[i + 5]) * sk1;
+                        float sum2 = (rowIn[i + 2] + rowIn[i + 4]) * sk2;
+                        float sum = (rowIn[i + 3] * sk3) + sum0 + sum1 + sum2;
+
+                        output.GetRow(x)[y] = sum;
+                    }
+                }
+
+                break;
+            }
+
+            case 13:
+            {
+                for (int y = 0; y < input.YSize; y++)
+                {
+                    Span<float> rowIn = input.GetRow(y);
+
+                    for (int x = border1; x < border2; x++)
+                    {
+                        int i = x - border1;
+
+                        float sum0 = (rowIn[i + 0] + rowIn[i + 12]) * scaledKernel[0];
+                        float sum1 = (rowIn[i + 1] + rowIn[i + 11]) * scaledKernel[1];
+                        float sum2 = (rowIn[i + 2] + rowIn[i + 10]) * scaledKernel[2];
+                        float sum3 = (rowIn[i + 3] + rowIn[i + 9]) * scaledKernel[3];
+
+                        sum0 += (rowIn[i + 4] + rowIn[i + 8]) * scaledKernel[4];
+                        sum1 += (rowIn[i + 5] + rowIn[i + 7]) * scaledKernel[5];
+
+                        float sum = rowIn[i + 6] * scaledKernel[6];
+
+                        output.GetRow(x)[y] = sum + sum0 + sum1 + sum2 + sum3;
+                    }
+                }
+
+                break;
+            }
+
+            case 15:
+            {
+                for (int y = 0; y < input.YSize; y++)
+                {
+                    Span<float> rowIn = input.GetRow(y);
+
+                    for (int x = border1; x < border2; x++)
+                    {
+                        int i = x - border1;
+
+                        float sum0 = (rowIn[i + 0] + rowIn[i + 14]) * scaledKernel[0];
+                        float sum1 = (rowIn[i + 1] + rowIn[i + 13]) * scaledKernel[1];
+                        float sum2 = (rowIn[i + 2] + rowIn[i + 12]) * scaledKernel[2];
+                        float sum3 = (rowIn[i + 3] + rowIn[i + 11]) * scaledKernel[3];
+
+                        sum0 += (rowIn[i + 4] + rowIn[i + 10]) * scaledKernel[4];
+                        sum1 += (rowIn[i + 5] + rowIn[i + 9]) * scaledKernel[5];
+                        sum2 += (rowIn[i + 6] + rowIn[i + 8]) * scaledKernel[6];
+
+                        float sum = rowIn[i + 7] * scaledKernel[7];
+
+                        output.GetRow(x)[y] = sum + sum0 + sum1 + sum2 + sum3;
+                    }
+                }
+
+                break;
+            }
+
+            case 33:
+            {
+                for (int y = 0; y < input.YSize; y++)
+                {
+                    Span<float> rowIn = input.GetRow(y);
+
+                    for (int x = border1; x < border2; x++)
+                    {
+                        int i = x - border1;
+
+                        float sum0 = (rowIn[i + 0] + rowIn[i + 32]) * scaledKernel[0];
+                        float sum1 = (rowIn[i + 1] + rowIn[i + 31]) * scaledKernel[1];
+                        float sum2 = (rowIn[i + 2] + rowIn[i + 30]) * scaledKernel[2];
+                        float sum3 = (rowIn[i + 3] + rowIn[i + 29]) * scaledKernel[3];
+
+                        sum0 += (rowIn[i + 4] + rowIn[i + 28]) * scaledKernel[4];
+                        sum1 += (rowIn[i + 5] + rowIn[i + 27]) * scaledKernel[5];
+                        sum2 += (rowIn[i + 6] + rowIn[i + 26]) * scaledKernel[6];
+                        sum3 += (rowIn[i + 7] + rowIn[i + 25]) * scaledKernel[7];
+
+                        sum0 += (rowIn[i + 8] + rowIn[i + 24]) * scaledKernel[8];
+                        sum1 += (rowIn[i + 9] + rowIn[i + 23]) * scaledKernel[9];
+                        sum2 += (rowIn[i + 10] + rowIn[i + 22]) * scaledKernel[10];
+                        sum3 += (rowIn[i + 11] + rowIn[i + 21]) * scaledKernel[11];
+
+                        sum0 += (rowIn[i + 12] + rowIn[i + 20]) * scaledKernel[12];
+                        sum1 += (rowIn[i + 13] + rowIn[i + 19]) * scaledKernel[13];
+                        sum2 += (rowIn[i + 14] + rowIn[i + 18]) * scaledKernel[14];
+                        sum3 += (rowIn[i + 15] + rowIn[i + 17]) * scaledKernel[15];
+
+                        float sum = rowIn[i + 16] * scaledKernel[16];
+
+                        output.GetRow(x)[y] = sum + sum0 + sum1 + sum2 + sum3;
+                    }
+                }
+
+                break;
+            }
+
+            default:
+                throw new NotSupportedException($"Kernel size {len} not implemented.");
+        }
+
+        // Left border
+        for (int x = 0; x < border1; x++)
+        {
+            ConvolveBorderColumn(input, kernel, x, output.GetRow(x));
+        }
+
+        // Right border
+        for (int x = border2; x < input.XSize; x++)
+        {
+            ConvolveBorderColumn(input, kernel, x, output.GetRow(x));
+        }
+
+        return true;
+    }
+
+    private static bool Blur(
+        Configuration configuration,
+        JxlPlane<float> input,
+        float sigma,
+        ButteraugliBlurTemp temp,
+        JxlPlane<float> output)
+    {
+        ReadOnlySpan<float> kernel = ComputeKernel(sigma);
+
+        // Separable5 does an in-place convolution, so this fast path is not safe
+        // if input aliases output.
+        if (kernel.Length == 5 && !ReferenceEquals(input, output))
+        {
+            float sumWeights = 0.0f;
+
+            foreach (float w in kernel)
+            {
+                sumWeights += w;
+            }
+
+            float scale = 1.0f / sumWeights;
+
+            float w0 = kernel[2] * scale;
+            float w1 = kernel[1] * scale;
+            float w2 = kernel[0] * scale;
+
+            JxlWeightsSeparable5 weights = default;
+            FillRep4(ref weights.Horizontal, w0, w1, w2);
+            FillRep4(ref weights.Vertical, w0, w1, w2);
+
+            if (!Separable5(input, input.GetRectangle(), weights, null, output))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        JxlPlane<float> tempT = temp.GetTransposed(configuration, input);
+
+        if (!ConvolutionWithTranspose(input, kernel, tempT))
+        {
+            return false;
+        }
+
+        if (!ConvolutionWithTranspose(tempT, kernel, output))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Equivalent to HWY_REP4.
+    /// </summary>
+    private static void FillRep4(ref InlineArray12<float> values, float a, float b, float c)
+    {
+        for (int i = 0; i < 4; i++)
+        {
+            values[i] = a;
+            values[4 + i] = b;
+            values[8 + i] = c;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> MaximumClamp(Vector<float> value, float maximum)
+    {
+        Vector<float> multiplier = new(0.724216145665f);
+        Vector<float> maximumValue = new(maximum);
+        Vector<float> ifPositive = ((value - maximumValue) * multiplier) + maximumValue;
+        Vector<float> ifNegative = ((value + maximumValue) * multiplier) - maximumValue;
+        Vector<float> positiveOrValue = Vector.ConditionalSelect(Vector.GreaterThan(value, maximumValue), ifPositive, value);
+        Vector<float> result = Vector.ConditionalSelect(Vector.LessThan(value, Vector.Negate(maximumValue)), ifNegative, positiveOrValue);
+
+        return result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> RemoveRangeAroundZero(Vector<float> x, float width)
+    {
+        Vector<float> w = new(width);
+
+        return Vector.ConditionalSelect(
+            Vector.GreaterThan(x, w),
+            x - w,
+            Vector.ConditionalSelect(
+                Vector.LessThan(x, -w),
+                x + w,
+                Vector<float>.Zero));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> AmplifyRangeAroundZero(Vector<float> x, float width)
+    {
+        Vector<float> w = new(width);
+
+        return Vector.ConditionalSelect(
+            Vector.GreaterThan(x, w),
+            x + w,
+            Vector.ConditionalSelect(
+                Vector.LessThan(x, -w),
+                x - w,
+                x + x));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void XybLowFrequencyToValues(
+        Vector<float> x,
+        Vector<float> y,
+        Vector<float> bArg,
+        out Vector<float> valX,
+        out Vector<float> valY,
+        out Vector<float> valB)
+    {
+        Vector<float> xMul = new(33.832837186260f);
+        Vector<float> yMul = new(14.458268100570f);
+        Vector<float> bMul = new(49.87984651440f);
+        Vector<float> yToBMul = new(-0.362267051518f);
+
+        Vector<float> b = (yToBMul * y) + bArg;
+
+        valB = b * bMul;
+        valX = x * xMul;
+        valY = y * yMul;
+    }
+
+    public static void XybLowFrequencyToValues(JxlImage3F xybLf)
+    {
+        int lanes = Vector<float>.Count;
+
+        for (int y = 0; y < xybLf.YSize; y++)
+        {
+            Span<float> rowX = xybLf.PlaneRow(0, y);
+            Span<float> rowY = xybLf.PlaneRow(1, y);
+            Span<float> rowB = xybLf.PlaneRow(2, y);
+
+            for (int x = 0; x < xybLf.XSize; x += lanes)
+            {
+                Vector<float> valX = new(rowX.Slice(x, lanes));
+                Vector<float> valY = new(rowY.Slice(x, lanes));
+                Vector<float> valB = new(rowB.Slice(x, lanes));
+
+                XybLowFrequencyToValues(
+                    valX,
+                    valY,
+                    valB,
+                    out valX,
+                    out valY,
+                    out valB);
+
+                valX.CopyTo(rowX.Slice(x, lanes));
+                valY.CopyTo(rowY.Slice(x, lanes));
+                valB.CopyTo(rowB.Slice(x, lanes));
+            }
+        }
+    }
+
+    public static bool SuppressXByY(JxlPlane<float> inY, JxlPlane<float> inOutX)
+    {
+        if (!JxlImageOperations.SameSize(inOutX, inY))
+        {
+            return false;
+        }
+
+        int xSize = inY.XSize;
+        int ySize = inY.YSize;
+        int lanes = Vector<float>.Count;
+
+        const float suppress = 46.0f;
+        const float s = 0.653020556257f;
+
+        Vector<float> sv = new(s);
+        Vector<float> oneMinusS = new(1.0f - s);
+        Vector<float> ywv = new(suppress);
+
+        for (int y = 0; y < ySize; y++)
+        {
+            ReadOnlySpan<float> rowY = inY.GetRow(y);
+            Span<float> rowX = inOutX.GetRow(y);
+
+            for (int x = 0; x < xSize; x += lanes)
+            {
+                Vector<float> vx = new(rowX.Slice(x, lanes));
+                Vector<float> vy = new(rowY.Slice(x, lanes));
+
+                Vector<float> scaler =
+                    ((ywv / ((vy * vy) + ywv)) * oneMinusS) + sv;
+
+                (scaler * vx).CopyTo(rowX.Slice(x, lanes));
+            }
+        }
+
+        return true;
+    }
+
+    public static void Subtract(JxlPlane<float> a, JxlPlane<float> b, JxlPlane<float> c)
+    {
+        int lanes = Vector<float>.Count;
+
+        for (int y = 0; y < a.YSize; y++)
+        {
+            ReadOnlySpan<float> rowA = a.GetRow(y);
+            ReadOnlySpan<float> rowB = b.GetRow(y);
+            Span<float> rowC = c.GetRow(y);
+
+            for (int x = 0; x < a.XSize; x += lanes)
+            {
+                Vector<float> va = new(rowA.Slice(x, lanes));
+                Vector<float> vb = new(rowB.Slice(x, lanes));
+
+                (va - vb).CopyTo(rowC.Slice(x, lanes));
+            }
+        }
+    }
+
+    public static bool SeparateLFAndMF(
+        Configuration configuration,
+        JxlImage3F xyb,
+        JxlImage3F lf,
+        JxlImage3F mf,
+        ButteraugliBlurTemp blurTemp)
+    {
+        const float sigmaLf = 7.15593339443f;
+
+        for (int i = 0; i < 3; i++)
+        {
+            if (!Blur(
+                    configuration,
+                    xyb.Plane(i),
+                    sigmaLf,
+                    blurTemp,
+                    lf.Plane(i)))
+            {
+                return false;
+            }
+
+            Subtract(
+                xyb.Plane(i),
+                lf.Plane(i),
+                mf.Plane(i));
+        }
+
+        XybLowFrequencyToValues(lf);
+
+        return true;
+    }
+
+    public static bool SeparateMfAndHf(
+        Configuration configuration,
+        JxlImage3F mf,
+        ref InlineArray2<JxlPlane<float>> hf,
+        ButteraugliBlurTemp blurTemp)
+    {
+        const float sigmaHf = 3.22489901262f;
+
+        int xSize = mf.XSize;
+        int ySize = mf.YSize;
+
+        hf[0] = JxlPlane<float>.Create(configuration, xSize, ySize);
+        hf[1] = JxlPlane<float>.Create(configuration, xSize, ySize);
+
+        int lanes = Vector<float>.Count;
+
+        for (int i = 0; i < 3; i++)
+        {
+            if (i == 2)
+            {
+                if (!Blur(configuration, mf.Plane(i), sigmaHf, blurTemp, mf.Plane(i)))
+                {
+                    return false;
+                }
+
+                break;
+            }
+
+            for (int y = 0; y < ySize; y++)
+            {
+                Span<float> rowMf = mf.PlaneRow(i, y);
+                Span<float> rowHf = hf[i].GetRow(y);
+
+                for (int x = 0; x < xSize; x += lanes)
+                {
+                    new Vector<float>(rowMf.Slice(x, lanes))
+                        .CopyTo(rowHf.Slice(x, lanes));
+                }
+            }
+
+            if (!Blur(configuration, mf.Plane(i), sigmaHf, blurTemp, mf.Plane(i)))
+            {
+                return false;
+            }
+
+            if (i == 0)
+            {
+                const float removeMfRange = 0.29f;
+
+                for (int y = 0; y < ySize; y++)
+                {
+                    Span<float> rowMf = mf.PlaneRow(0, y);
+                    Span<float> rowHf = hf[0].GetRow(y);
+
+                    for (int x = 0; x < xSize; x += lanes)
+                    {
+                        Vector<float> mfv = new(rowMf.Slice(x, lanes));
+                        Vector<float> hfv = new Vector<float>(rowHf.Slice(x, lanes)) - mfv;
+
+                        mfv = RemoveRangeAroundZero(mfv, removeMfRange);
+
+                        mfv.CopyTo(rowMf.Slice(x, lanes));
+                        hfv.CopyTo(rowHf.Slice(x, lanes));
+                    }
+                }
+            }
+            else
+            {
+                const float addMfRange = 0.1f;
+
+                for (int y = 0; y < ySize; y++)
+                {
+                    Span<float> rowMf = mf.PlaneRow(1, y);
+                    Span<float> rowHf = hf[1].GetRow(y);
+
+                    for (int x = 0; x < xSize; x += lanes)
+                    {
+                        Vector<float> mfv = new(rowMf.Slice(x, lanes));
+                        Vector<float> hfv = new Vector<float>(rowHf.Slice(x, lanes)) - mfv;
+
+                        mfv = AmplifyRangeAroundZero(mfv, addMfRange);
+
+                        mfv.CopyTo(rowMf.Slice(x, lanes));
+                        hfv.CopyTo(rowHf.Slice(x, lanes));
+                    }
+                }
+            }
+        }
+
+        return SuppressXByY(hf[1], hf[0]);
+    }
+
+    public static bool SeparateHFAndUHF(
+        Configuration configuration,
+        InlineArray2<JxlPlane<float>> hf,
+        InlineArray2<JxlPlane<float>> uhf,
+        ButteraugliBlurTemp blurTemp)
+    {
+        const float sigmaUhf = 1.56416327805f;
+
+        int xSize = hf[0].XSize;
+        int ySize = hf[0].YSize;
+
+        uhf[0] = JxlPlane<float>.Create(configuration, xSize, ySize);
+        uhf[1] = JxlPlane<float>.Create(configuration, xSize, ySize);
+
+        int lanes = Vector<float>.Count;
+
+        for (int i = 0; i < 2; i++)
+        {
+            for (int y = 0; y < ySize; y++)
+            {
+                Span<float> rowUhf = uhf[i].GetRow(y);
+                Span<float> rowHf = hf[i].GetRow(y);
+
+                for (int x = 0; x < xSize; x += lanes)
+                {
+                    new Vector<float>(rowHf.Slice(x, lanes)).CopyTo(rowUhf.Slice(x, lanes));
+                }
+            }
+
+            if (!Blur(configuration, hf[i], sigmaUhf, blurTemp, hf[i]))
+            {
+                return false;
+            }
+
+            if (i == 0)
+            {
+                const float removeHfRange = 1.5f;
+                const float removeUhfRange = 0.04f;
+
+                for (int y = 0; y < ySize; y++)
+                {
+                    Span<float> rowUhf = uhf[0].GetRow(y);
+                    Span<float> rowHf = hf[0].GetRow(y);
+
+                    for (int x = 0; x < xSize; x += lanes)
+                    {
+                        Vector<float> hfv = new(rowHf.Slice(x, lanes));
+                        Vector<float> uhfv = new Vector<float>(rowUhf.Slice(x, lanes)) - hfv;
+
+                        hfv = RemoveRangeAroundZero(hfv, removeHfRange);
+                        uhfv = RemoveRangeAroundZero(uhfv, removeUhfRange);
+
+                        hfv.CopyTo(rowHf.Slice(x, lanes));
+                        uhfv.CopyTo(rowUhf.Slice(x, lanes));
+                    }
+                }
+            }
+            else
+            {
+                const float addHfRange = 0.132f;
+                const float maxClampHf = 28.4691806922f;
+                const float maxClampUhf = 5.19175294647f;
+                const float mulYHf = 2.155f;
+                const float mulYUhf = 2.69313763794f;
+
+                Vector<float> mulHf = new(mulYHf);
+                Vector<float> mulUhf = new(mulYUhf);
+
+                for (int y = 0; y < ySize; y++)
+                {
+                    Span<float> rowUhf = uhf[1].GetRow(y);
+                    Span<float> rowHf = hf[1].GetRow(y);
+
+                    for (int x = 0; x < xSize; x += lanes)
+                    {
+                        Vector<float> hfv = new(rowHf.Slice(x, lanes));
+                        hfv = MaximumClamp(hfv, maxClampHf);
+
+                        Vector<float> uhfv = new Vector<float>(rowUhf.Slice(x, lanes)) - hfv;
+
+                        uhfv = MaximumClamp(uhfv, maxClampUhf);
+                        uhfv *= mulUhf;
+
+                        uhfv.CopyTo(rowUhf.Slice(x, lanes));
+
+                        hfv *= mulHf;
+                        hfv = AmplifyRangeAroundZero(hfv, addHfRange);
+
+                        hfv.CopyTo(rowHf.Slice(x, lanes));
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public static void DeallocateHFAndUHF(InlineArray2<JxlPlane<float>> hf, InlineArray2<JxlPlane<float>> uhf)
+    {
+        for (int i = 0; i < 2; i++)
+        {
+            hf[i].Dispose();
+            uhf[i].Dispose();
+
+            hf[i] = new JxlPlane<float>();
+            uhf[i] = new JxlPlane<float>();
+        }
+    }
+
+    public static bool SeparateFrequencies(
+        Configuration configuration,
+        ButteraugliBlurTemp blurTemp,
+        JxlImage3F xyb,
+        ButteraugliPsychoImage ps)
+    {
+        ps.Lf = new JxlImage3F(
+            configuration,
+            xyb.XSize,
+            xyb.YSize);
+
+        ps.Mf = new JxlImage3F(
+            configuration,
+            xyb.XSize,
+            xyb.YSize);
+
+        if (!SeparateLFAndMF(
+                configuration,
+                xyb,
+                ps.Lf,
+                ps.Mf,
+                blurTemp))
+        {
+            return false;
+        }
+
+        if (!SeparateMfAndHf(
+                configuration,
+                ps.Mf,
+                ref ps.Hf,
+                blurTemp))
+        {
+            return false;
+        }
+
+        if (!SeparateHFAndUHF(
+                configuration,
+                ps.Hf,
+                ps.Uhf,
+                blurTemp))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> Sum(
+        Vector<float> a,
+        Vector<float> b,
+        Vector<float> c,
+        Vector<float> d)
+        => (a + b) + (c + d);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> Sum(
+        Vector<float> a,
+        Vector<float> b,
+        Vector<float> c,
+        Vector<float> d,
+        Vector<float> e)
+        => Sum(a, b, c, d + e);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> Sum(
+        Vector<float> a,
+        Vector<float> b,
+        Vector<float> c,
+        Vector<float> d,
+        Vector<float> e,
+        Vector<float> f,
+        Vector<float> g)
+        => Sum(a, b, c, Sum(d, e, f, g));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> Sum(
+        Vector<float> a,
+        Vector<float> b,
+        Vector<float> c,
+        Vector<float> d,
+        Vector<float> e,
+        Vector<float> f,
+        Vector<float> g,
+        Vector<float> h,
+        Vector<float> i)
+        => (Sum(a, b, c, d) + Sum(e, f, g, h)) + i;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> MaltaUnitLF(
+        ReadOnlySpan<float> row,
+        int index,
+        int xs)
+    {
+        // helper
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Vector<float> Load(ReadOnlySpan<float> row, int index)
+            => new(row.Slice(index, Vector<float>.Count));
+
+        int xs3 = 3 * xs;
+
+        Vector<float> center = Load(row, index);
+
+        Vector<float> sumYConst = Sum(
+            Load(row, index - 4),
+            Load(row, index - 2),
+            center,
+            Load(row, index + 2),
+            Load(row, index + 4));
+
+        Vector<float> retval = sumYConst * sumYConst;
+
+        Vector<float> sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs),
+            Load(row, index - xs - xs),
+            center,
+            Load(row, index + xs + xs),
+            Load(row, index + xs3 + xs));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 - 3),
+            Load(row, index - xs - xs - 2),
+            center,
+            Load(row, index + xs + xs + 2),
+            Load(row, index + xs3 + 3));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 + 3),
+            Load(row, index - xs - xs + 2),
+            center,
+            Load(row, index + xs + xs - 2),
+            Load(row, index + xs3 - 3));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs + 1),
+            Load(row, index - xs - xs + 1),
+            center,
+            Load(row, index + xs + xs - 1),
+            Load(row, index + xs3 + xs - 1));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs - 1),
+            Load(row, index - xs - xs - 1),
+            center,
+            Load(row, index + xs + xs + 1),
+            Load(row, index + xs3 + xs + 1));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - 4 - xs),
+            Load(row, index - 2 - xs),
+            center,
+            Load(row, index + 2 + xs),
+            Load(row, index + 4 + xs));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - 4 + xs),
+            Load(row, index - 2 + xs),
+            center,
+            Load(row, index + 2 - xs),
+            Load(row, index + 4 - xs));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 - 2),
+            Load(row, index - xs - xs - 1),
+            center,
+            Load(row, index + xs + xs + 1),
+            Load(row, index + xs3 + 2));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 + 2),
+            Load(row, index - xs - xs + 1),
+            center,
+            Load(row, index + xs + xs - 1),
+            Load(row, index + xs3 - 2));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs - xs - 3),
+            Load(row, index - xs - 2),
+            center,
+            Load(row, index + xs + 2),
+            Load(row, index + xs + xs + 3));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs - xs + 3),
+            Load(row, index - xs + 2),
+            center,
+            Load(row, index + xs - 2),
+            Load(row, index + xs + xs - 3));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index + xs + xs - 4),
+            Load(row, index + xs - 2),
+            center,
+            Load(row, index - xs + 2),
+            Load(row, index - xs - xs + 4));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs - xs - 4),
+            Load(row, index - xs - 2),
+            center,
+            Load(row, index + xs + 2),
+            Load(row, index + xs + xs + 4));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs - 2),
+            Load(row, index - xs - xs - 1),
+            center,
+            Load(row, index + xs + xs + 1),
+            Load(row, index + xs3 + xs + 2));
+        retval = (sum * sum) + retval;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs + 2),
+            Load(row, index - xs - xs + 1),
+            center,
+            Load(row, index + xs + xs - 1),
+            Load(row, index + xs3 + xs - 2));
+        retval = (sum * sum) + retval;
+
+        return retval;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> MaltaUnit(
+        ReadOnlySpan<float> row,
+        int index,
+        int xs)
+    {
+        // helper
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Vector<float> Load(ReadOnlySpan<float> row, int index)
+            => new(row.Slice(index, Vector<float>.Count));
+
+        int xs3 = 3 * xs;
+
+        Vector<float> center = Load(row, index);
+
+        Vector<float> sumYConst = Sum(
+            Load(row, index - 4),
+            Load(row, index - 3),
+            Load(row, index - 2),
+            Load(row, index - 1),
+            center,
+            Load(row, index + 1),
+            Load(row, index + 2),
+            Load(row, index + 3),
+            Load(row, index + 4));
+
+        Vector<float> retval = sumYConst * sumYConst;
+
+        Vector<float> sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs),
+            Load(row, index - xs3),
+            Load(row, index - xs - xs),
+            Load(row, index - xs),
+            center,
+            Load(row, index + xs),
+            Load(row, index + xs + xs),
+            Load(row, index + xs3),
+            Load(row, index + xs3 + xs));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - 3),
+            Load(row, index - xs - xs - 2),
+            Load(row, index - xs - 1),
+            center,
+            Load(row, index + xs + 1),
+            Load(row, index + xs + xs + 2),
+            Load(row, index + xs3 + 3));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 + 3),
+            Load(row, index - xs - xs + 2),
+            Load(row, index - xs + 1),
+            center,
+            Load(row, index + xs - 1),
+            Load(row, index + xs + xs - 2),
+            Load(row, index + xs3 - 3));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs + 1),
+            Load(row, index - xs3 + 1),
+            Load(row, index - xs - xs + 1),
+            Load(row, index - xs),
+            center,
+            Load(row, index + xs),
+            Load(row, index + xs + xs - 1),
+            Load(row, index + xs3 - 1),
+            Load(row, index + xs3 + xs - 1));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs - 1),
+            Load(row, index - xs3 - 1),
+            Load(row, index - xs - xs - 1),
+            Load(row, index - xs),
+            center,
+            Load(row, index + xs),
+            Load(row, index + xs + xs + 1),
+            Load(row, index + xs3 + 1),
+            Load(row, index + xs3 + xs + 1));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - 4 - xs),
+            Load(row, index - 3 - xs),
+            Load(row, index - 2 - xs),
+            Load(row, index - 1),
+            center,
+            Load(row, index + 1),
+            Load(row, index + 2 + xs),
+            Load(row, index + 3 + xs),
+            Load(row, index + 4 + xs));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - 4 + xs),
+            Load(row, index - 3 + xs),
+            Load(row, index - 2 + xs),
+            Load(row, index - 1),
+            center,
+            Load(row, index + 1),
+            Load(row, index + 2 - xs),
+            Load(row, index + 3 - xs),
+            Load(row, index + 4 - xs));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - 2),
+            Load(row, index - xs - xs - 1),
+            Load(row, index - xs - 1),
+            center,
+            Load(row, index + xs + 1),
+            Load(row, index + xs + xs + 1),
+            Load(row, index + xs3 + 2));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 + 2),
+            Load(row, index - xs - xs + 1),
+            Load(row, index - xs + 1),
+            center,
+            Load(row, index + xs - 1),
+            Load(row, index + xs + xs - 1),
+            Load(row, index + xs3 - 2));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs - xs - 3),
+            Load(row, index - xs - 2),
+            Load(row, index - xs - 1),
+            center,
+            Load(row, index + xs + 1),
+            Load(row, index + xs + 2),
+            Load(row, index + xs + xs + 3));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs - xs + 3),
+            Load(row, index - xs + 2),
+            Load(row, index - xs + 1),
+            center,
+            Load(row, index + xs - 1),
+            Load(row, index + xs - 2),
+            Load(row, index + xs + xs - 3));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index + xs - 4),
+            Load(row, index + xs - 3),
+            Load(row, index + xs - 2),
+            Load(row, index - 1),
+            center,
+            Load(row, index + 1),
+            Load(row, index - xs + 2),
+            Load(row, index - xs + 3),
+            Load(row, index - xs + 4));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs - 4),
+            Load(row, index - xs - 3),
+            Load(row, index - xs - 2),
+            Load(row, index - 1),
+            center,
+            Load(row, index + 1),
+            Load(row, index + xs + 2),
+            Load(row, index + xs + 3),
+            Load(row, index + xs + 4));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs - 1),
+            Load(row, index - xs3 - 1),
+            Load(row, index - xs - xs - 1),
+            Load(row, index - xs),
+            center,
+            Load(row, index + xs),
+            Load(row, index + xs + xs + 1),
+            Load(row, index + xs3 + 1),
+            Load(row, index + xs3 + xs + 1));
+        retval += sum * sum;
+
+        sum = Sum(
+            Load(row, index - xs3 - xs + 1),
+            Load(row, index - xs3 + 1),
+            Load(row, index - xs - xs + 1),
+            Load(row, index - xs),
+            center,
+            Load(row, index + xs),
+            Load(row, index + xs + xs - 1),
+            Load(row, index + xs3 - 1),
+            Load(row, index + xs3 + xs - 1));
+        retval += sum * sum;
+
+        return retval;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float PaddedMaltaUnit(
+        JxlPlane<float> diffs,
+        int x0,
+        int y0,
+        bool isLF)
+    {
+        if (x0 >= 4 &&
+            y0 >= 4 &&
+            x0 < diffs.XSize - 4 &&
+            y0 < diffs.YSize - 4)
+        {
+            return isLF
+                ? MaltaUnitLF(
+                    diffs.GetRow(y0),
+                    x0,
+                    diffs.PixelsPerRow)[0]
+                : MaltaUnit(
+                    diffs.GetRow(y0),
+                    x0,
+                    diffs.PixelsPerRow)[0];
+        }
+
+        Span<float> borderImage = stackalloc float[12 * 9];
+
+        for (int dy = 0; dy < 9; dy++)
+        {
+            int y = y0 + dy - 4;
+
+            if (y < 0 || y >= diffs.YSize)
+            {
+                borderImage.Slice(dy * 12, 12).Clear();
+                continue;
+            }
+
+            ReadOnlySpan<float> rowDiffs = diffs.GetRow(y);
+
+            for (int dx = 0; dx < 9; dx++)
+            {
+                int x = x0 + dx - 4;
+
+                borderImage[(dy * 12) + dx] =
+                    x < 0 || x >= diffs.XSize
+                        ? 0.0f
+                        : rowDiffs[x];
+            }
+
+            borderImage.Slice((dy * 12) + 9, 3).Clear();
+        }
+
+        return isLF
+                ? MaltaUnitLF(
+                    diffs.GetRow(y0),
+                    x0,
+                    diffs.PixelsPerRow)[0]
+                : MaltaUnit(
+                    borderImage,
+                    (4 * 12) + 4,
+                    12)[0];
+    }
+
+    public static bool MaltaDiffMap(
+        bool isLf,
+        JxlPlane<float> lum0,
+        JxlPlane<float> lum1,
+        float w0Gt1,
+        float w0Lt1,
+        float norm1,
+        JxlPlane<float> diffs,
+        JxlPlane<float> blockDiffAc)
+    {
+        if (isLf)
+        {
+            const float len = 3.75f;
+            const float mulli = 0.39905817637f;
+
+            return MaltaDiffMap(true, lum0, lum1, w0Gt1, w0Lt1, norm1, len, mulli, diffs, blockDiffAc);
+        }
+        else
+        {
+            const float len = 3.75f;
+            const float mulli = 0.611612573796f;
+
+            return MaltaDiffMap(false, lum0, lum1, w0Gt1, w0Lt1, norm1, len, mulli, diffs, blockDiffAc);
+        }
+    }
+
+    public static bool MaltaDiffMap(
+        bool isLf,
+        JxlPlane<float> lum0,
+        JxlPlane<float> lum1,
+        float w0Gt1,
+        float w0Lt1,
+        float norm1,
+        float len,
+        float mulli,
+        JxlPlane<float> diffs,
+        JxlPlane<float> blockDiffAc)
+    {
+        if (!JxlImageOperations.SameSize(lum0, lum1) || !JxlImageOperations.SameSize(lum0, diffs))
+        {
+            return false;
+        }
+
+        int width = lum0.XSize;
+        int height = lum0.YSize;
+
+        const float weight0 = 0.5f;
+        const float weight1 = 0.33f;
+
+        float norm2_0Gt1 =
+            (float)(mulli * MathF.Sqrt(weight0 * w0Gt1) / ((len * 2) + 1) * norm1);
+
+        float norm2_0Lt1 =
+            (float)(mulli * MathF.Sqrt(weight1 * w0Lt1) / ((len * 2) + 1) * norm1);
+
+        for (int y = 0; y < height; y++)
+        {
+            ReadOnlySpan<float> row0 = lum0.GetRow(y);
+            ReadOnlySpan<float> row1 = lum1.GetRow(y);
+            Span<float> rowDiffs = diffs.GetRow(y);
+
+            for (int x = 0; x < width; x++)
+            {
+                float absVal = 0.5f *
+                    (MathF.Abs(row0[x]) + MathF.Abs(row1[x]));
+
+                float diff = row0[x] - row1[x];
+
+                float scaler = norm2_0Gt1 / ((float)norm1 + absVal);
+
+                rowDiffs[x] = scaler * diff;
+
+                float scaler2 = norm2_0Lt1 / ((float)norm1 + absVal);
+
+                float fabs0 = MathF.Abs(row0[x]);
+
+                float tooSmall = 0.55f * fabs0;
+                float tooBig = 1.05f * fabs0;
+
+                if (row0[x] < 0)
+                {
+                    if (row1[x] > -tooSmall)
+                    {
+                        rowDiffs[x] -= scaler2 * (row1[x] + tooSmall);
+                    }
+                    else if (row1[x] < -tooBig)
+                    {
+                        rowDiffs[x] += scaler2 * (-row1[x] - tooBig);
+                    }
+                }
+                else
+                {
+                    if (row1[x] < tooSmall)
+                    {
+                        rowDiffs[x] += scaler2 * (tooSmall - row1[x]);
+                    }
+                    else if (row1[x] > tooBig)
+                    {
+                        rowDiffs[x] -= scaler2 * (row1[x] - tooBig);
+                    }
+                }
+            }
+        }
+
+        int y0 = 0;
+
+        for (; y0 < 4; y0++)
+        {
+            Span<float> row = blockDiffAc.GetRow(y0);
+
+            for (int x = 0; x < width; x++)
+            {
+                row[x] += PaddedMaltaUnit(diffs, x, y0, isLf);
+            }
+        }
+
+        int lanes = Vector<float>.Count;
+        int alignedX = Math.Max(4, lanes);
+
+        int stride = diffs.PixelsPerRow;
+
+        for (; y0 < height - 4; y0++)
+        {
+            ReadOnlySpan<float> input = diffs.GetRow(y0);
+            Span<float> output = blockDiffAc.GetRow(y0);
+            ref float outputReference = ref MemoryMarshal.GetReference(output);
+
+            int x = 0;
+
+            for (; x < alignedX; x++)
+            {
+                output[x] += PaddedMaltaUnit(diffs, x, y0, isLf);
+            }
+
+            for (; x + lanes + 4 <= width; x += lanes)
+            {
+                Vector<float> value = Vector.LoadUnsafe(ref Unsafe.Add(ref outputReference, x));
+
+                Vector<float> malta = isLf
+                    ? MaltaUnitLF(input, x, stride)
+                    : MaltaUnit(input, x, stride);
+
+                (value + malta).CopyTo(output[x..]);
+            }
+
+            for (; x < width; x++)
+            {
+                output[x] += PaddedMaltaUnit(diffs, x, y0, isLf);
+            }
+        }
+
+        for (; y0 < height; y0++)
+        {
+            Span<float> row = blockDiffAc.GetRow(y0);
+
+            for (int x = 0; x < width; x++)
+            {
+                row[x] += PaddedMaltaUnit(diffs, x, y0, isLf);
+            }
+        }
+
+        return true;
+    }
+
+    public static bool MaltaDiffMap(
+        JxlImageF lum0,
+        JxlImageF lum1,
+        float w0Gt1,
+        float w0Lt1,
+        float norm1,
+        JxlImageF diffs,
+        JxlImageF blockDiffAc)
+    {
+        const float len = 3.75f;
+        const float mulli = 0.39905817637f;
+
+        return MaltaDiffMap(
+            false,
+            lum0,
+            lum1,
+            w0Gt1,
+            w0Lt1,
+            norm1,
+            len,
+            mulli,
+            diffs,
+            blockDiffAc);
+    }
+
+    public static bool MaltaDiffMapLf(
+        JxlPlane<float> lum0,
+        JxlPlane<float> lum1,
+        float w0Gt1,
+        float w0Lt1,
+        float norm1,
+        JxlPlane<float> diffs,
+        JxlPlane<float> blockDiffAc)
+    {
+        const float len = 3.75f;
+        const float mulli = 0.611612573796f;
+
+        return MaltaDiffMap(
+            true,
+            lum0,
+            lum1,
+            w0Gt1,
+            w0Lt1,
+            norm1,
+            len,
+            mulli,
+            diffs,
+            blockDiffAc);
+    }
+
+    public static void CombineChannelsForMasking(
+        InlineArray2<JxlPlane<float>> hf,
+        InlineArray2<JxlPlane<float>> uhf,
+        JxlPlane<float> output)
+    {
+        // Only X and Y components are involved in masking.
+        ReadOnlySpan<float> muls =
+        [
+            2.5f,
+            0.4f,
+            0.4f
+        ];
+
+        int width = hf[0].XSize;
+        int height = hf[0].YSize;
+
+        for (int y = 0; y < height; y++)
+        {
+            ReadOnlySpan<float> rowYHf = hf[1].GetRow(y);
+            ReadOnlySpan<float> rowYUhf = uhf[1].GetRow(y);
+            ReadOnlySpan<float> rowXHf = hf[0].GetRow(y);
+            ReadOnlySpan<float> rowXUhf = uhf[0].GetRow(y);
+
+            Span<float> row = output.GetRow(y);
+
+            for (int x = 0; x < width; x++)
+            {
+                float xDiff = (rowXUhf[x] + rowXHf[x]) * muls[0];
+                float yDiff = (rowYUhf[x] * muls[1]) + (rowYHf[x] * muls[2]);
+
+                row[x] = MathF.Sqrt((xDiff * xDiff) + (yDiff * yDiff));
+            }
+        }
+    }
+
+    public static void DiffPrecompute(
+        JxlImageF xyb,
+        float mul,
+        float biasArg,
+        JxlImageF output)
+    {
+        int width = xyb.XSize;
+        int height = xyb.YSize;
+
+        float bias = mul * biasArg;
+        float sqrtBias = MathF.Sqrt(bias);
+
+        for (int y = 0; y < height; y++)
+        {
+            ReadOnlySpan<float> rowIn = xyb.GetRow(y);
+            Span<float> rowOut = output.GetRow(y);
+
+            for (int x = 0; x < width; x++)
+            {
+                rowOut[x] =
+                    MathF.Sqrt(
+                        (mul * MathF.Abs(rowIn[x])) + bias)
+                    - sqrtBias;
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void StoreMin3(
+        float value,
+        ref float min0,
+        ref float min1,
+        ref float min2)
+    {
+        if (value < min2)
+        {
+            if (value < min0)
+            {
+                min2 = min1;
+                min1 = min0;
+                min0 = value;
+            }
+            else if (value < min1)
+            {
+                min2 = min1;
+                min1 = value;
+            }
+            else
+            {
+                min2 = value;
+            }
+        }
+    }
+
+    public static void FuzzyErosion(JxlImageF from, JxlImageF to)
+    {
+        int width = from.XSize;
+        int height = from.YSize;
+
+        const int step = 3;
+
+        for (int y = 0; y < height; y++)
+        {
+            Span<float> output = to.GetRow(y);
+
+            for (int x = 0; x < width; x++)
+            {
+                float min0 = from.GetRow(y)[x];
+                float min1 = 2 * min0;
+                float min2 = min1;
+
+                if (x >= step)
+                {
+                    StoreMin3(
+                        from.GetRow(y)[x - step],
+                        ref min0,
+                        ref min1,
+                        ref min2);
+
+                    if (y >= step)
+                    {
+                        StoreMin3(
+                            from.GetRow(y - step)[x - step],
+                            ref min0,
+                            ref min1,
+                            ref min2);
+                    }
+
+                    if (y < height - step)
+                    {
+                        StoreMin3(
+                            from.GetRow(y + step)[x - step],
+                            ref min0,
+                            ref min1,
+                            ref min2);
+                    }
+                }
+
+                if (x < width - step)
+                {
+                    StoreMin3(
+                        from.GetRow(y)[x + step],
+                        ref min0,
+                        ref min1,
+                        ref min2);
+
+                    if (y >= step)
+                    {
+                        StoreMin3(
+                            from.GetRow(y - step)[x + step],
+                            ref min0,
+                            ref min1,
+                            ref min2);
+                    }
+
+                    if (y < height - step)
+                    {
+                        StoreMin3(
+                            from.GetRow(y + step)[x + step],
+                            ref min0,
+                            ref min1,
+                            ref min2);
+                    }
+                }
+
+                if (y >= step)
+                {
+                    StoreMin3(
+                        from.GetRow(y - step)[x],
+                        ref min0,
+                        ref min1,
+                        ref min2);
+                }
+
+                if (y < height - step)
+                {
+                    StoreMin3(
+                        from.GetRow(y + step)[x],
+                        ref min0,
+                        ref min1,
+                        ref min2);
+                }
+
+                output[x] =
+                    (0.45f * min0) +
+                    (0.3f * min1) +
+                    (0.25f * min2);
+            }
+        }
+    }
+
+    public static bool Mask(
+        Configuration configuration,
+        JxlImageF mask0,
+        JxlImageF mask1,
+        ButteraugliBlurTemp blurTemp,
+        JxlImageF? diffAc,
+        out JxlImageF mask)
+    {
+        int width = mask0.XSize;
+        int height = mask0.YSize;
+
+        mask = new(configuration, width, height);
+
+        const float mul = 6.19424080439f;
+        const float bias = 12.61050594197f;
+        const float radius = 2.7f;
+
+        JxlImageF diff0 = new(configuration, width, height);
+        JxlImageF diff1 = new(configuration, width, height);
+        JxlImageF blurred0 = new(configuration, width, height);
+        JxlImageF blurred1 = new(configuration, width, height);
+
+        DiffPrecompute(mask0, mul, bias, diff0);
+        DiffPrecompute(mask1, mul, bias, diff1);
+
+        if (!Blur(configuration, diff0, radius, blurTemp, blurred0))
+        {
+            return false;
+        }
+
+        FuzzyErosion(blurred0, diff0);
+
+        if (!Blur(configuration, diff1, radius, blurTemp, blurred1))
+        {
+            return false;
+        }
+
+        for (int y = 0; y < height; y++)
+        {
+            Span<float> maskRow = mask.GetRow(y);
+            Span<float> diffRow = diffAc is not null ? diffAc.GetRow(y) : [];
+
+            ReadOnlySpan<float> diff0Row = diff0.GetRow(y);
+            ReadOnlySpan<float> blur0Row = blurred0.GetRow(y);
+            ReadOnlySpan<float> blur1Row = blurred1.GetRow(y);
+
+            for (int x = 0; x < width; x++)
+            {
+                maskRow[x] = diff0Row[x];
+
+                if (diffRow.Length > 0)
+                {
+                    const float maskToErrorMul = 10.0f;
+                    float diff = blur0Row[x] - blur1Row[x];
+                    diffRow[x] += maskToErrorMul * diff * diff;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public static bool MaskButteraugliPsychoImage(
+        Configuration configuration,
+        ButteraugliPsychoImage pi0,
+        ButteraugliPsychoImage pi1,
+        int width,
+        int height,
+        ButteraugliBlurTemp blurTemp,
+        JxlImageF mask,
+        out JxlImageF? diffAc)
+    {
+        JxlImageF mask0 = new(configuration, width, height);
+        JxlImageF mask1 = new(configuration, width, height);
+
+        CombineChannelsForMasking(
+            pi0.Hf,
+            pi0.Uhf,
+            mask0);
+
+        CombineChannelsForMasking(
+            pi1.Hf,
+            pi1.Uhf,
+            mask1);
+
+        return Mask(
+            configuration,
+            mask0,
+            mask1,
+            blurTemp,
+            mask,
+            out diffAc);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float MaskY(float delta)
+    {
+        const float offset = 0.829591754942f;
+        const float scaler = 0.451936922203f;
+        const float mul = 2.5485944793f;
+
+        float c = mul / ((scaler * delta) + offset);
+        float result = GlobalScale * (1.0f + c);
+
+        return result * result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float MaskDcY(float delta)
+    {
+        const float offset = 0.20025578522f;
+        const float scaler = 3.87449418804f;
+        const float mul = 0.505054525019f;
+
+        float c = mul / ((scaler * delta) + offset);
+        float result = GlobalScale * (1.0f + c);
+
+        return result * result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float MaskColor(
+        ReadOnlySpan<float> color,
+        float mask)
+        => (color[0] * mask) + (color[1] * mask) + (color[2] * mask);
+
+    public static bool CombineChannelsToDiffmap(
+        JxlImageF mask,
+        JxlImage3F blockDiffDc,
+        JxlImage3<float> blockDiffAc,
+        float xmul,
+        JxlImageF result)
+    {
+        if (!JxlImageOperations.SameSize(mask, result))
+        {
+            return false;
+        }
+
+        Span<float> diffDc = stackalloc float[3];
+        Span<float> diffAc = stackalloc float[3];
+
+        int xsize = mask.XSize;
+        int ysize = mask.YSize;
+
+        for (int y = 0; y < ysize; ++y)
+        {
+            Span<float> rowOut = result.GetRow(y);
+
+            for (int x = 0; x < xsize; ++x)
+            {
+                float val = mask.GetRow(y)[x];
+
+                float maskVal = MaskY(val);
+                float dcMaskVal = MaskDcY(val);
+
+                for (int i = 0; i < 3; ++i)
+                {
+                    diffDc[i] = blockDiffDc.PlaneRow(i, y)[x];
+                    diffAc[i] = blockDiffAc.PlaneRow(i, y)[x];
+                }
+
+                diffAc[0] *= xmul;
+                diffDc[0] *= xmul;
+
+                rowOut[x] = MathF.Sqrt(
+                    MaskColor(diffDc, dcMaskVal) +
+                    MaskColor(diffAc, maskVal));
+            }
+        }
+
+        return true;
+    }
+
+    public static void L2Diff(
+        JxlPlane<float> i0,
+        JxlPlane<float> i1,
+        float w,
+        JxlPlane<float> diffmap)
+    {
+        if (w == 0)
+        {
+            return;
+        }
+
+        for (int y = 0; y < i0.YSize; ++y)
+        {
+            ReadOnlySpan<float> row0 = i0.GetRow(y);
+            ReadOnlySpan<float> row1 = i1.GetRow(y);
+            Span<float> rowDiff = diffmap.GetRow(y);
+
+            for (int x = 0; x < i0.XSize; ++x)
+            {
+                float diff = row0[x] - row1[x];
+                rowDiff[x] += diff * diff * w;
+            }
+        }
+    }
+
+    public static void SetL2Diff(
+        JxlPlane<float> i0,
+        JxlPlane<float> i1,
+        float w,
+        JxlPlane<float> diffmap)
+    {
+        if (w == 0)
+        {
+            return;
+        }
+
+        for (int y = 0; y < i0.YSize; ++y)
+        {
+            ReadOnlySpan<float> row0 = i0.GetRow(y);
+            ReadOnlySpan<float> row1 = i1.GetRow(y);
+            Span<float> rowDiff = diffmap.GetRow(y);
+
+            for (int x = 0; x < i0.XSize; ++x)
+            {
+                float diff = row0[x] - row1[x];
+                rowDiff[x] = diff * diff * w;
+            }
+        }
+    }
+
+    public static void L2DiffAsymmetric(
+        JxlPlane<float> i0,
+        JxlPlane<float> i1,
+        float w0gt1,
+        float w0lt1,
+        JxlPlane<float> diffmap)
+    {
+        if (w0gt1 == 0 && w0lt1 == 0)
+        {
+            return;
+        }
+
+        Vector<float> vw0gt1 = new(w0gt1 * 0.8f);
+        Vector<float> vw0lt1 = new(w0lt1 * 0.8f);
+
+        int lanes = Vector<float>.Count;
+
+        for (int y = 0; y < i0.YSize; ++y)
+        {
+            ReadOnlySpan<float> row0 = i0.GetRow(y);
+            ReadOnlySpan<float> row1 = i1.GetRow(y);
+            Span<float> rowDiff = diffmap.GetRow(y);
+
+            for (int x = 0; x < i0.XSize; x += lanes)
+            {
+                Vector<float> val0 = new(row0[x..]);
+                Vector<float> val1 = new(row1[x..]);
+
+                // Primary symmetric quadratic objective.
+                Vector<float> diff = val0 - val1;
+
+                Vector<float> total =
+                    (diff * diff * vw0gt1) + new Vector<float>(rowDiff[x..]);
+
+                Vector<float> fabs0 = Vector.Abs(val0);
+
+                Vector<float> tooSmall = fabs0 * new Vector<float>(0.4f);
+
+                Vector<float> tooBig = fabs0;
+
+                Vector<float> ifNeg =
+                    Vector.ConditionalSelect(
+                        Vector.GreaterThan(val1, -tooSmall),
+                        val1 + tooSmall,
+                        Vector.ConditionalSelect(
+                            Vector.LessThan(val1, -tooBig),
+                            -val1 - tooBig,
+                            Vector<float>.Zero));
+
+                Vector<float> ifPos =
+                    Vector.ConditionalSelect(
+                        Vector.LessThan(val1, tooSmall),
+                        tooSmall - val1,
+                        Vector.ConditionalSelect(
+                            Vector.GreaterThan(val1, tooBig),
+                            val1 - tooBig,
+                            Vector<float>.Zero));
+
+                Vector<float> v =
+                    Vector.ConditionalSelect(
+                        Vector.LessThan(val0, Vector<float>.Zero),
+                        ifNeg,
+                        ifPos);
+
+                total += vw0lt1 * v * v;
+
+                total.CopyTo(rowDiff[x..]);
+            }
+        }
+    }
+
+    public static void OpsinAbsorbance(
+        bool clamp,
+        Vector<float> in0,
+        Vector<float> in1,
+        Vector<float> in2,
+        out Vector<float> out0,
+        out Vector<float> out1,
+        out Vector<float> out2)
+    {
+        Vector<float> mix0 = new(0.29956550340058319f);
+        Vector<float> mix1 = new(0.63373087833825936f);
+        Vector<float> mix2 = new(0.077705617820981968f);
+        Vector<float> mix3 = new(1.7557483643287353f);
+
+        Vector<float> mix4 = new(0.22158691104574774f);
+        Vector<float> mix5 = new(0.69391388044116142f);
+        Vector<float> mix6 = new(0.0987313588422f);
+        Vector<float> mix7 = new(1.7557483643287353f);
+
+        Vector<float> mix8 = new(0.02f);
+        Vector<float> mix9 = new(0.02f);
+        Vector<float> mix10 = new(0.20480129041026129f);
+        Vector<float> mix11 = new(12.226454707163354f);
+
+        out0 = (mix0 * in0) + ((mix1 * in1) + ((mix2 * in2) + mix3));
+        out1 = (mix4 * in0) + ((mix5 * in1) + ((mix6 * in2) + mix7));
+        out2 = (mix8 * in0) + ((mix9 * in1) + ((mix10 * in2) + mix11));
+
+        if (clamp)
+        {
+            out0 = Vector.Max(out0, mix3);
+            out1 = Vector.Max(out1, mix7);
+            out2 = Vector.Max(out2, mix11);
+        }
+    }
+
+    // A simple HDR-compatible gamma function
+    private static Vector<float> Gamma(Vector<float> v)
+    {
+        Vector<float> kRetMul = Vector.Create(19.245013259874995f * JxlMath.InverseLog2E);
+        Vector<float> kRetAdd = Vector.Create(-23.16046239805755f);
+
+        // if (value < 0) value = 0;
+        v = Vector.ConditionalSelect(Vector.LessThan(v, Vector<float>.Zero), Vector<float>.Zero, v);
+
+        Vector<float> biased = v + Vector.Create(9.9710635769299145f);
+        Vector<float> log = Vector.Log2(biased);
+
+        return (kRetMul * log) + kRetAdd;
+    }
+
+    public static bool OpsinDynamicsImage(
+        Configuration configuration,
+        JxlImage3F rgb,
+        in ButteraugliParameters parameters,
+        JxlImage3F blurred,
+        ButteraugliBlurTemp blurTemp,
+        JxlImage3F xyb)
+    {
+        if (blurred == null)
+        {
+            return false;
+        }
+
+        const float sigma = 1.2f;
+
+        if (!Blur(configuration, rgb.Plane(0), sigma, blurTemp, blurred.Plane(0)))
+        {
+            return false;
+        }
+
+        if (!Blur(configuration, rgb.Plane(1), sigma, blurTemp, blurred.Plane(1)))
+        {
+            return false;
+        }
+
+        if (!Blur(configuration, rgb.Plane(2), sigma, blurTemp, blurred.Plane(2)))
+        {
+            return false;
+        }
+
+        Vector<float> intensityMultiplier = new((float)parameters.IntensityTarget);
+
+        int lanes = Vector<float>.Count;
+
+        Vector<float> minValue = new(1e-4f);
+
+        for (int y = 0; y < rgb.YSize; ++y)
+        {
+            ReadOnlySpan<float> rowR = rgb.PlaneRow(0, y);
+            ReadOnlySpan<float> rowG = rgb.PlaneRow(1, y);
+            ReadOnlySpan<float> rowB = rgb.PlaneRow(2, y);
+
+            ReadOnlySpan<float> blurredR = blurred.PlaneRow(0, y);
+            ReadOnlySpan<float> blurredG = blurred.PlaneRow(1, y);
+            ReadOnlySpan<float> blurredB = blurred.PlaneRow(2, y);
+
+            Span<float> outX = xyb.PlaneRow(0, y);
+            Span<float> outY = xyb.PlaneRow(1, y);
+            Span<float> outB = xyb.PlaneRow(2, y);
+
+            for (int x = 0; x < rgb.XSize; x += lanes)
+            {
+                Vector<float> sensitivity0;
+                Vector<float> sensitivity1;
+                Vector<float> sensitivity2;
+                {
+                    OpsinAbsorbance(
+                        true,
+                        new Vector<float>(blurredR[x..]) * intensityMultiplier,
+                        new Vector<float>(blurredG[x..]) * intensityMultiplier,
+                        new Vector<float>(blurredB[x..]) * intensityMultiplier,
+                        out Vector<float> pre0,
+                        out Vector<float> pre1,
+                        out Vector<float> pre2);
+
+                    pre0 = Vector.Max(pre0, minValue);
+                    pre1 = Vector.Max(pre1, minValue);
+                    pre2 = Vector.Max(pre2, minValue);
+
+                    sensitivity0 = Gamma(pre0) / pre0;
+                    sensitivity1 = Gamma(pre1) / pre1;
+                    sensitivity2 = Gamma(pre2) / pre2;
+
+                    sensitivity0 = Vector.Max(sensitivity0, minValue);
+                    sensitivity1 = Vector.Max(sensitivity1, minValue);
+                    sensitivity2 = Vector.Max(sensitivity2, minValue);
+                }
+
+                OpsinAbsorbance(
+                    false,
+                    new Vector<float>(rowR[x..]) * intensityMultiplier,
+                    new Vector<float>(rowG[x..]) * intensityMultiplier,
+                    new Vector<float>(rowB[x..]) * intensityMultiplier,
+                    out Vector<float> cur0,
+                    out Vector<float> cur1,
+                    out Vector<float> cur2);
+
+                cur0 *= sensitivity0;
+                cur1 *= sensitivity1;
+                cur2 *= sensitivity2;
+
+                Vector<float> min01 = new(1.7557483643287353f);
+                Vector<float> min2 = new(12.226454707163354f);
+
+                cur0 = Vector.Max(cur0, min01);
+                cur1 = Vector.Max(cur1, min01);
+                cur2 = Vector.Max(cur2, min2);
+
+                (cur0 - cur1).CopyTo(outX[x..]);
+                (cur0 + cur1).CopyTo(outY[x..]);
+                cur2.CopyTo(outB[x..]);
+            }
+        }
+
+        return true;
+    }
+
+    public static bool ButteraugliDiffmapInPlace(
+        Configuration configuration,
+        JxlImage3F image0,
+        JxlImage3F image1,
+        in ButteraugliParameters parameters,
+        JxlImageF diffmap)
+    {
+        int xSize = image0.XSize;
+        int ySize = image0.YSize;
+
+        using ButteraugliBlurTemp blurTemp = new();
+
+        using (JxlImage3F temp = new(configuration, xSize, ySize))
+        {
+            if (!OpsinDynamicsImage(configuration, image0, parameters, temp, blurTemp, image0))
+            {
+                return false;
+            }
+
+            if (!OpsinDynamicsImage(configuration, image1, parameters, temp, blurTemp, image1))
+            {
+                return false;
+            }
+        }
+
+        using JxlPlane<float> blockDiffDc = JxlImageF.Create(configuration, xSize, ySize);
+        blockDiffDc.Clear();
+
+        // LF/DC
+        using (JxlImage3F lf0 = new(configuration, xSize, ySize))
+        using (JxlImage3F lf1 = new(configuration, xSize, ySize))
+        {
+            if (!SeparateLFAndMF(configuration, image0, lf0, image0, blurTemp))
+            {
+                return false;
+            }
+
+            if (!SeparateLFAndMF(configuration, image1, lf1, image1, blurTemp))
+            {
+                return false;
+            }
+
+            for (int c = 0; c < 3; c++)
+            {
+                L2Diff(
+                    lf0.Plane(c),
+                    lf1.Plane(c),
+                    Wmul[6 + c],
+                    blockDiffDc);
+            }
+        }
+
+        InlineArray2<JxlPlane<float>> hf0 = default;
+        InlineArray2<JxlPlane<float>> hf1 = default;
+
+        if (!SeparateMfAndHf(configuration, image0, ref hf0, blurTemp))
+        {
+            return false;
+        }
+
+        if (!SeparateMfAndHf(configuration, image1, ref hf1, blurTemp))
+        {
+            return false;
+        }
+
+        using JxlImageF blockDiffAc = new(configuration, xSize, ySize);
+        blockDiffAc.Clear();
+
+        using (JxlImageF diffs = new(configuration, xSize, ySize))
+        {
+            if (!MaltaDiffMap(
+                    true,
+                    image0.Plane(1),
+                    image1.Plane(1),
+                    WMfMalta,
+                    WMfMalta,
+                    Norm1Mf,
+                    diffs,
+                    blockDiffAc))
+            {
+                return false;
+            }
+
+            if (!MaltaDiffMap(
+                    true,
+                    image0.Plane(0),
+                    image1.Plane(0),
+                    WMfMaltaX,
+                    WMfMaltaX,
+                    Norm1MfX,
+                    diffs,
+                    blockDiffAc))
+            {
+                return false;
+            }
+        }
+
+        for (int c = 0; c < 3; c++)
+        {
+            L2Diff(
+                image0.Plane(c),
+                image1.Plane(c),
+                Wmul[3 + c],
+                blockDiffAc);
+        }
+
+        // Free MF images
+        image0.Dispose();
+        image1.Dispose();
+
+        InlineArray2<JxlPlane<float>> uhf0 = default;
+        InlineArray2<JxlPlane<float>> uhf1 = default;
+
+        if (!SeparateHFAndUHF(configuration, hf0, uhf0, blurTemp))
+        {
+            return false;
+        }
+
+        if (!SeparateHFAndUHF(configuration, hf1, uhf1, blurTemp))
+        {
+            return false;
+        }
+
+        float hfAsymmetry = parameters.HfAsymmetry;
+
+        using (JxlImageF diffs = new(configuration, xSize, ySize))
+        {
+            _ = MaltaDiffMap(
+                false,
+                uhf0[1],
+                uhf1[1],
+                WUhfMalta * hfAsymmetry,
+                WUhfMalta / hfAsymmetry,
+                Norm1Uhf,
+                diffs,
+                blockDiffAc);
+
+            _ = MaltaDiffMap(
+                false,
+                uhf0[0],
+                uhf1[0],
+                WUhfMaltaX * hfAsymmetry,
+                WUhfMaltaX / hfAsymmetry,
+                Norm1UhfX,
+                diffs,
+                blockDiffAc);
+
+            float sqrtAsym = MathF.Sqrt(hfAsymmetry);
+
+            _ = MaltaDiffMap(
+                true,
+                hf0[1],
+                hf1[1],
+                WHfMalta * sqrtAsym,
+                WHfMalta / sqrtAsym,
+                Norm1Hf,
+                diffs,
+                blockDiffAc);
+
+            _ = MaltaDiffMap(
+                true,
+                hf0[0],
+                hf1[0],
+                WHfMaltaX * sqrtAsym,
+                WHfMaltaX / sqrtAsym,
+                Norm1HfX,
+                diffs,
+                blockDiffAc);
+        }
+
+        for (int c = 0; c < 2; c++)
+        {
+            L2DiffAsymmetric(
+                hf0[c],
+                hf1[c],
+                Wmul[c] * hfAsymmetry,
+                Wmul[c] / hfAsymmetry,
+                blockDiffAc);
+        }
+
+        // Mask
+        using JxlImageF mask = new(configuration, xSize, ySize);
+        using JxlImageF mask0 = new(configuration, xSize, ySize);
+        using JxlImageF mask1 = new(configuration, xSize, ySize);
+
+        CombineChannelsForMasking(hf0, uhf0, mask0);
+        CombineChannelsForMasking(hf1, uhf1, mask1);
+
+        DeallocateHFAndUHF(hf0, uhf0);
+        DeallocateHFAndUHF(hf1, uhf1);
+
+        if (!Mask(configuration, mask0, mask1, blurTemp, mask, out JxlImageF newBlockDiffAc))
+        {
+            return false;
+        }
+
+        for (int y = 0; y < ySize; y++)
+        {
+            ReadOnlySpan<float> dc = newBlockDiffAc.GetRow(y);
+            ReadOnlySpan<float> ac = newBlockDiffAc.GetRow(y);
+            Span<float> output = diffmap.GetRow(y);
+            ReadOnlySpan<float> maskRow = mask.GetRow(y);
+
+            for (int x = 0; x < xSize; x++)
+            {
+                float m = maskRow[x];
+
+                output[x] = MathF.Sqrt((dc[x] * (float)MaskDcY(m)) + (ac[x] * (float)MaskY(m)));
+            }
+        }
+
+        return true;
+    }
+
+    // Calculate a 2x2 subsampled image for purposes of recursive butteraugli at
+    // multiresolution.
+    public static JxlImage3F SubSample2x(Configuration configuration, JxlImage3F input)
+    {
+        int xs = (input.XSize + 1) / 2;
+        int ys = (input.YSize + 1) / 2;
+
+        JxlImage3F retval = new(configuration, xs, ys);
+
+        for (int c = 0; c < 3; ++c)
+        {
+            for (int y = 0; y < ys; ++y)
+            {
+                for (int x = 0; x < xs; ++x)
+                {
+                    retval.PlaneRow(c, y)[x] = 0.0f;
+                }
+            }
+        }
+
+        for (int c = 0; c < 3; ++c)
+        {
+            for (int y = 0; y < input.YSize; ++y)
+            {
+                ReadOnlySpan<float> srcRow = input.PlaneRow(c, y);
+
+                for (int x = 0; x < input.XSize; ++x)
+                {
+                    retval.PlaneRow(c, y / 2)[x / 2] += 0.25f * srcRow[x];
+                }
+            }
+
+            if ((input.XSize & 1) != 0)
+            {
+                for (int y = 0; y < retval.YSize; ++y)
+                {
+                    int lastColumn = retval.XSize - 1;
+                    retval.PlaneRow(c, y)[lastColumn] *= 2.0f;
+                }
+            }
+
+            if ((input.YSize & 1) != 0)
+            {
+                for (int x = 0; x < retval.XSize; ++x)
+                {
+                    int lastRow = retval.YSize - 1;
+                    retval.PlaneRow(c, lastRow)[x] *= 2.0f;
+                }
+            }
+        }
+
+        return retval;
+    }
+
+    public static void AddSupersampled2x(JxlImageF src, float w, JxlImageF dest)
+    {
+        const float heuristicMixingValue = 0.3f;
+
+        for (int y = 0; y < dest.YSize; ++y)
+        {
+            Span<float> destRow = dest.GetRow(y);
+
+            for (int x = 0; x < dest.XSize; ++x)
+            {
+                destRow[x] *= 1.0f - (heuristicMixingValue * w);
+                destRow[x] += w * src.GetRow(y / 2)[x / 2];
+            }
+        }
+    }
+
+    private static void ScoreToRgb(float score, float goodThreshold, float badThreshold, ref InlineArray3<float> rgb)
+    {
+        if (score < goodThreshold)
+        {
+            score = (score / goodThreshold) * 0.3f;
+        }
+        else if (score < badThreshold)
+        {
+            score = 0.3f + ((score - goodThreshold) / (badThreshold - goodThreshold) * 0.15f);
+        }
+        else
+        {
+            score = 0.45f + ((score - badThreshold) / (badThreshold * 12) * 0.5f);
+        }
+
+        int tableSize = HeatmapData.GetLength(0);
+        score = Math.Clamp(score * (tableSize - 1), 0f, tableSize - 2);
+
+        int ix = (int)score;
+        ix = Math.Clamp(ix, 0, tableSize - 2); // handle NaN
+        float mix = score - ix;
+
+        for (int i = 0; i < 3; ++i)
+        {
+            float v = (mix * Heatmap[ix + 1, i]) + ((1 - mix) * Heatmap[ix, i]);
+            rgb[i] = MathF.Pow(v, 0.5f);
+        }
+    }
+
+    public static JxlImage3F CreateHeatMapImage(Configuration configuration, JxlImageF distmap, float goodThreshold, float badThreshold)
+    {
+        // Do not dispose (this is the return value; it is caller's responsibility to dispose this
+        // or keep it)
+        JxlImage3F heatmap = new(configuration, distmap.XSize, distmap.YSize);
+
+        for (int y = 0; y < distmap.YSize; y++)
+        {
+            Span<float> row_distmap = distmap.GetRow(y);
+            Span<float> row_h0 = heatmap.PlaneRow(0, y);
+            Span<float> row_h1 = heatmap.PlaneRow(1, y);
+            Span<float> row_h2 = heatmap.PlaneRow(2, y);
+
+            for (int x = 0; x < distmap.XSize; ++x)
+            {
+                float d = row_distmap[x];
+                InlineArray3<float> rgb = default;
+                ScoreToRgb(d, goodThreshold, badThreshold, ref rgb);
+                row_h0[x] = rgb[0];
+                row_h1[x] = rgb[1];
+                row_h2[x] = rgb[2];
+            }
+        }
+
+        return heatmap;
+    }
+
+    public static float ButteraugliFuzzyInverse(float seek)
+    {
+        float pos = 0f;
+
+        for (float range = 1.0f; range >= 1e-10f; range *= 0.5f)
+        {
+            float cur = ButteraugliFuzzyClass(pos);
+
+            if (cur < seek)
+            {
+                pos -= range;
+            }
+            else
+            {
+                pos += range;
+            }
+        }
+
+        // Normalization (pos) can be printed if seek == 1.0, for example
+        // when debugging.
+        return pos;
+    }
+
+    public static float ButteraugliFuzzyClass(float score)
+    {
+        const float fuzzyWidthUp = 4.8f;
+        const float fuzzyWidthDown = 4.8f;
+        const float m0 = 2.0f;
+        const float scaler = 0.7777f;
+
+        float val;
+
+        if (score < 1.0)
+        {
+            val = m0 / (1.0f + MathF.Exp((score - 1.0f) * fuzzyWidthDown));
+            val -= 1.0f;
+            val *= 2.0f - scaler;
+            val += scaler;
+        }
+        else
+        {
+            val = m0 / (1.0f + MathF.Exp((score - 1.0f) * fuzzyWidthUp));
+            val *= scaler;
+        }
+
+        return val;
+    }
+
+    public static bool ButteraugliInterfaceInPlace(Configuration configuration, JxlImage3F rgb0, JxlImage3F rgb1, ButteraugliParameters parameters, JxlImageF diffmap, out double diffvalue)
+    {
+        diffvalue = 0;
+
+        int xsize = rgb0.XSize;
+        int ysize = rgb0.YSize;
+
+        if ((xsize & ysize) == 0) // equivalent to xsize == 0 || ysize == 0, minus one branch
+        {
+            throw new InvalidOperationException("Zero-sized image");
+        }
+
+        if (!JxlImageOperations.SameSize(rgb0, rgb1))
+        {
+            throw new InvalidOperationException("Size mismatch");
+        }
+
+        const int max = 8;
+
+        if (xsize < max || ysize < max)
+        {
+            bool ok = ButteraugliDiffmapSmall(configuration, max, rgb0, rgb1, parameters, out diffmap);
+            diffvalue = ButteraugliScoreFromDiffmap(diffmap, parameters);
+            return ok;
+        }
+
+        JxlImageF subDiffmap = new();
+
+        if (xsize >= 15 && ysize >= 15)
+        {
+            using JxlImage3F rgb0Sub = SubSample2x(configuration, rgb0);
+            using JxlImage3F rgb1Sub = SubSample2x(configuration, rgb1);
+
+            if (!ButteraugliDiffmapInPlace(configuration, rgb0Sub, rgb1Sub, parameters, diffmap))
+            {
+                return false;
+            }
+        }
+
+        if (!ButteraugliDiffmapInPlace(configuration, rgb0, rgb1, parameters, diffmap))
+        {
+            return false;
+        }
+
+        if (xsize >= 15 && ysize >= 15)
+        {
+            AddSupersampled2x(subDiffmap, 0.5f, diffmap);
+        }
+
+        diffvalue = ButteraugliScoreFromDiffmap(diffmap, parameters);
+        return true;
+    }
+
+    public static bool ButteraugliInterface(Configuration configuration, JxlImage3F rgb0, JxlImage3F rgb1, ButteraugliParameters parameters, JxlImageF diffmap, out double diffValue)
+    {
+        diffValue = 0;
+
+        if (!ButteraugliDiffmap(configuration, rgb0, rgb1, parameters, out diffmap))
+        {
+            return false;
+        }
+
+        diffValue = ButteraugliScoreFromDiffmap(diffmap, parameters);
+        return true;
+    }
+
+    public static bool ButteraugliInterface(Configuration configuration, JxlImage3F rgb0, JxlImage3F rgb1, float hfAsymmetry, float xmul, JxlImageF diffmap, out double diffValue)
+    {
+        ButteraugliParameters parameters = new()
+        {
+            HfAsymmetry = hfAsymmetry,
+            XMultiplier = xmul
+        };
+
+        return ButteraugliInterface(configuration, rgb0, rgb1, parameters, diffmap, out diffValue);
+    }
+
+    public static bool ButteraugliDiffmap(Configuration configuration, JxlImage3F rgb0, JxlImage3F rgb1, ButteraugliParameters parameters, out JxlImageF diffmap)
+    {
+        diffmap = new();
+
+        int xsize = rgb0.XSize;
+        int ysize = rgb0.YSize;
+
+        if ((xsize & ysize) == 0) // equivalent to xsize == 0 || ysize == 0, minus one branch
+        {
+            throw new InvalidOperationException("Zero-sized image");
+        }
+
+        if (!JxlImageOperations.SameSize(rgb0, rgb1))
+        {
+            throw new InvalidOperationException("Size mismatch");
+        }
+
+        const int max = 8;
+
+        if (xsize < max || ysize < max)
+        {
+            if (!ButteraugliDiffmapSmall(configuration, max, rgb0, rgb1, parameters, out diffmap))
+            {
+                return false;
+            }
+        }
+
+        ButteraugliComparator butteraugli = ButteraugliComparator.Make(configuration, rgb0, parameters);
+
+        return butteraugli.Diffmap(configuration, rgb1, diffmap);
+    }
+
+    public static bool ButteraugliDiffmapSmall(Configuration configuration, int max, JxlImage3F rgb0, JxlImage3F rgb1, ButteraugliParameters parameters, out JxlImageF diffmap)
+    {
+        int xsize = rgb0.XSize;
+        int ysize = rgb0.YSize;
+
+        int xborder = xsize < max ? (max - xsize) / 2 : 0;
+        int yborder = ysize < max ? (max - ysize) / 2 : 0;
+        int xscaled = Math.Max(max, xsize);
+        int yscaled = Math.Max(max, ysize);
+
+        using JxlImage3F scaled0 = new(configuration, xscaled, yscaled);
+        using JxlImage3F scaled1 = new(configuration, xscaled, yscaled);
+
+        for (int i = 0; i < 3; ++i)
+        {
+            for (int y = 0; y < yscaled; y++)
+            {
+                for (int x = 0; x < xscaled; x++)
+                {
+                    int x2 = Math.Min(xsize - 1, x > xborder ? x - xborder : 0);
+                    int y2 = Math.Min(ysize - 1, y > yborder ? y - yborder : 0);
+
+                    scaled0.PlaneRow(i, y)[x] = rgb0.PlaneRow(i, y2)[x2];
+                    scaled1.PlaneRow(i, y)[x] = rgb1.PlaneRow(i, y2)[x2];
+                }
+            }
+        }
+
+        JxlImageF diffmapScaled = new();
+        bool ok = ButteraugliDiffmap(configuration, scaled0, scaled1, parameters, out diffmapScaled);
+
+        diffmap = new(configuration, xsize, ysize);
+
+        for (int y = 0; y < ysize; y++)
+        {
+            Span<float> diffmapRow = diffmap.GetRow(y);
+            Span<float> diffmapScaledRow = diffmapScaled.GetRow(y + yborder);
+
+            for (int x = 0; x < xsize; x++)
+            {
+                diffmapRow[x] = diffmapScaledRow[x + xborder];
+            }
+        }
+
+        return ok;
+    }
+
+    public static float ButteraugliScoreFromDiffmap(JxlImageF diffmap, ButteraugliParameters parameters)
+    {
+        float retval = 0.0f;
+
+        for (int y = 0; y < diffmap.YSize; ++y)
+        {
+            Span<float> row = diffmap.GetRow(y);
+            for (int x = 0; x < diffmap.XSize; ++x)
+            {
+                retval = Math.Max(retval, row[x]);
+            }
+        }
+
+        return retval;
+    }
+
+    public static bool MaltaDiffMap(JxlPlane<float> lum0, JxlPlane<float> lum1, float w0Gt1, float w0Lt1, float norm1, JxlPlane<float> diffs, JxlImage3<float> blockDiffAc, int c)
+        => MaltaDiffMap(isLf: false, lum0, lum1, w0Gt1, w0Lt1, norm1, diffs, blockDiffAc.Plane(c));
+
+    public static bool MaltaDiffMapLf(JxlPlane<float> lum0, JxlPlane<float> lum1, float w0Gt1, float w0Lt1, float norm1, JxlPlane<float> diffs, JxlImage3<float> blockDiffAc, int c)
+        => MaltaDiffMap(isLf: true, lum0, lum1, w0Gt1, w0Lt1, norm1, diffs, blockDiffAc.Plane(c));
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliBlurTemp.cs b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliBlurTemp.cs
new file mode 100644
index 0000000000..26aa8372ce
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliBlurTemp.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Butteraugli;
+
+internal sealed class ButteraugliBlurTemp : IDisposable
+{
+    public JxlPlane<float> TransposedTemp { get; set; } = new();
+
+    public JxlPlane<float> GetTransposed(Configuration configuration, JxlPlane<float> input)
+    {
+        if (this.TransposedTemp.XSize == 0)
+        {
+            // Yes, YSize and XSize are swapped
+            this.TransposedTemp = JxlPlane<float>.Create(configuration, input.YSize, input.XSize);
+        }
+
+        return this.TransposedTemp;
+    }
+
+    public void Dispose() => this.TransposedTemp.Dispose();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliComparator.cs b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliComparator.cs
new file mode 100644
index 0000000000..d290268da6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliComparator.cs
@@ -0,0 +1,300 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Butteraugli;
+
+internal class ButteraugliComparator : IDisposable
+{
+    private readonly int xSize;
+    private readonly int ySize;
+    private ButteraugliParameters parameters;
+    private readonly ButteraugliPsychoImage pi0 = new();
+    private JxlImage3F? temp;
+    private readonly ButteraugliBlurTemp blurTemp = new();
+    private ButteraugliComparator? sub;
+
+    public ButteraugliComparator(int xsize, int ysize, ButteraugliParameters parameters)
+    {
+        this.xSize = xsize;
+        this.ySize = ysize;
+        this.parameters = parameters;
+    }
+
+    public JxlImage3F Temp => this.temp ??= new();
+
+    public static ButteraugliComparator Make(Configuration configuration, JxlImage3F rgb0, ButteraugliParameters parameters)
+    {
+        int xSize = rgb0.XSize;
+        int ySize = rgb0.YSize;
+
+        ButteraugliComparator result = new(xSize, ySize, parameters)
+        {
+            temp = new JxlImage3F(configuration, xSize, ySize)
+        };
+
+        if (xSize < 8 || ySize < 8)
+        {
+            return result;
+        }
+
+        JxlImage3F xyb0 = new(configuration, xSize, ySize);
+
+        if (!Butteraugli.OpsinDynamicsImage(configuration, rgb0, parameters, result.Temp, result.blurTemp, xyb0))
+        {
+            throw new InvalidOperationException("OpsinDynamicsImage failed");
+        }
+
+        result.ReleaseTemp();
+
+        if (!Butteraugli.SeparateFrequencies(configuration, result.blurTemp, xyb0, result.pi0))
+        {
+            throw new InvalidOperationException("Could not separate frequencies");
+        }
+
+        JxlImage3F subsampledRgb0 = Butteraugli.SubSample2x(configuration, rgb0);
+        result.sub = Make(configuration, subsampledRgb0, parameters);
+
+        return result;
+    }
+
+    public void ReleaseTemp()
+    {
+        this.temp?.Dispose();
+        this.temp = null;
+    }
+
+    /// <summary>
+    /// Computes the butteraugli map between the original image given in the constructor and the distorted image given here.
+    /// </summary>
+    public virtual bool Diffmap(Configuration configuration, JxlImage3F rgb1, JxlImageF result)
+    {
+        if (this.xSize < 8 || this.ySize < 8)
+        {
+            result.Clear();
+            return true;
+        }
+
+        JxlImage3F xyb1 = new(configuration, this.xSize, this.ySize);
+
+        if (!Butteraugli.OpsinDynamicsImage(configuration, rgb1, this.parameters, this.Temp, this.blurTemp, xyb1))
+        {
+            return false;
+        }
+
+        this.ReleaseTemp();
+
+        if (!this.DiffmapOpsinDynamicsImage(configuration, xyb1, out result))
+        {
+            return false;
+        }
+
+        if (this.sub is not null)
+        {
+            if (this.sub.xSize < 8 || this.sub.ySize < 8)
+            {
+                return true;
+            }
+
+            JxlImage3F subXyb = new(configuration, this.sub.xSize, this.sub.ySize);
+            JxlImage3F subsampledRgb1 = Butteraugli.SubSample2x(configuration, rgb1);
+
+            if (!Butteraugli.OpsinDynamicsImage(configuration, subsampledRgb1, this.parameters, this.sub.Temp, this.sub.blurTemp, subXyb))
+            {
+                return false;
+            }
+
+            this.sub.ReleaseTemp();
+
+            if (!this.DiffmapOpsinDynamicsImage(configuration, subXyb, out JxlImageF subResult))
+            {
+                return false;
+            }
+
+            Butteraugli.AddSupersampled2x(subResult, 0.5f, result);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Same as Diffmap but OpsinDynamicsImage() was already applied.
+    /// </summary>
+    public bool DiffmapOpsinDynamicsImage(Configuration configuration, JxlImage3F xyb1, out JxlImageF result)
+    {
+        result = new();
+
+        if (this.xSize < 8 || this.ySize < 8)
+        {
+            result.Clear();
+            return true;
+        }
+
+        ButteraugliPsychoImage pi1 = new();
+
+        if (!Butteraugli.SeparateFrequencies(configuration, this.blurTemp, xyb1, pi1))
+        {
+            return false;
+        }
+
+        result = new(configuration, this.xSize, this.ySize);
+        return this.DiffmapPsychoImage(configuration, pi1, result);
+    }
+
+    /// <summary>
+    /// Same as above but the frequency decomposition was already applied.
+    /// </summary>
+    public bool DiffmapPsychoImage(Configuration configuration, ButteraugliPsychoImage pi1, JxlImageF diffmap)
+    {
+        if (this.xSize < 8 || this.ySize < 8)
+        {
+            diffmap.Clear();
+            return true;
+        }
+
+        float hfAsymmetry = this.parameters.HfAsymmetry;
+        float xmul = this.parameters.XMultiplier;
+
+        JxlImageF diffs = new(configuration, this.xSize, this.ySize);
+        JxlImage3<float> blockDiffAc = new(configuration, this.xSize, this.ySize);
+
+        JxlImageOperations.ZeroFillImage(blockDiffAc);
+
+        if (!Butteraugli.MaltaDiffMap(
+            this.pi0.Uhf[1],
+            pi1.Uhf[1],
+            Butteraugli.WUhfMalta * hfAsymmetry,
+            Butteraugli.WUhfMalta / hfAsymmetry,
+            Butteraugli.Norm1Uhf,
+            diffs,
+            blockDiffAc,
+            1))
+        {
+            return false;
+        }
+
+        if (!Butteraugli.MaltaDiffMap(
+            this.pi0.Uhf[0],
+            pi1.Uhf[0],
+            Butteraugli.WUhfMaltaX * hfAsymmetry,
+            Butteraugli.WUhfMaltaX / hfAsymmetry,
+            Butteraugli.Norm1UhfX,
+            diffs,
+            blockDiffAc,
+            0))
+        {
+            return false;
+        }
+
+        if (!Butteraugli.MaltaDiffMapLf(
+            this.pi0.Hf[1],
+            pi1.Hf[1],
+            Butteraugli.WHfMalta * MathF.Sqrt(hfAsymmetry),
+            Butteraugli.WHfMalta / MathF.Sqrt(hfAsymmetry),
+            Butteraugli.Norm1Hf,
+            diffs,
+            blockDiffAc,
+            1))
+        {
+            return false;
+        }
+
+        if (!Butteraugli.MaltaDiffMapLf(
+            this.pi0.Hf[0],
+            pi1.Hf[0],
+            Butteraugli.WHfMaltaX * MathF.Sqrt(hfAsymmetry),
+            Butteraugli.WHfMaltaX / MathF.Sqrt(hfAsymmetry),
+            Butteraugli.Norm1HfX,
+            diffs,
+            blockDiffAc,
+            0))
+        {
+            return false;
+        }
+
+        if (!Butteraugli.MaltaDiffMapLf(
+            this.pi0.Mf!.Plane(1),
+            pi1.Mf!.Plane(1),
+            Butteraugli.WHfMalta,
+            Butteraugli.WMfMalta,
+            Butteraugli.Norm1Mf,
+            diffs,
+            blockDiffAc,
+            1))
+        {
+            return false;
+        }
+
+        if (!Butteraugli.MaltaDiffMapLf(
+            this.pi0.Mf!.Plane(0),
+            pi1.Mf!.Plane(0),
+            Butteraugli.WHfMaltaX,
+            Butteraugli.WMfMaltaX,
+            Butteraugli.Norm1MfX,
+            diffs,
+            blockDiffAc,
+            0))
+        {
+            return false;
+        }
+
+        JxlImage3F blockDiffDc = new(configuration, this.xSize, this.ySize);
+
+        for (int c = 0; c < 3; c++)
+        {
+            if (c < 2)
+            {
+                Butteraugli.L2DiffAsymmetric(
+                    this.pi0.Hf[c],
+                    pi1.Hf[c],
+                    Butteraugli.Wmul[c] * hfAsymmetry,
+                    Butteraugli.Wmul[c] / hfAsymmetry,
+                    blockDiffAc.Plane(c));
+            }
+
+            Butteraugli.L2Diff(
+                this.pi0.Mf.Plane(c),
+                pi1.Mf.Plane(c),
+                Butteraugli.Wmul[3 + c],
+                blockDiffAc.Plane(c));
+
+            Butteraugli.SetL2Diff(
+                this.pi0.Lf!.Plane(c),
+                pi1.Lf!.Plane(c),
+                Butteraugli.Wmul[6 + c],
+                blockDiffDc.Plane(c));
+        }
+
+        JxlImageF mask = new();
+
+        if (!Butteraugli.MaskButteraugliPsychoImage(
+            configuration,
+            this.pi0,
+            pi1,
+            this.xSize,
+            this.ySize,
+            this.blurTemp,
+            mask,
+            out JxlImageF? diffAc))
+        {
+            return false;
+        }
+
+        diffAc?.BytesSpan.CopyTo(blockDiffAc.Plane(1).BytesSpan);
+
+        return Butteraugli.CombineChannelsToDiffmap(mask, blockDiffDc, blockDiffAc, xmul, diffmap);
+    }
+
+    public virtual bool Mask(Configuration configuration, JxlImageF mask)
+        => Butteraugli.MaskButteraugliPsychoImage(configuration, this.pi0, this.pi0, this.xSize, this.ySize, this.blurTemp, mask, out _);
+
+    public void Dispose()
+    {
+        this.temp?.Dispose();
+        this.temp = null;
+        this.blurTemp.Dispose();
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliParameters.cs
new file mode 100644
index 0000000000..7af303c8ba
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliParameters.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Butteraugli;
+
+/// <summary>
+/// Parameters for Butteraugli.
+/// </summary>
+internal struct ButteraugliParameters()
+{
+    /// <summary>
+    /// Gets or sets the multiplier for penalizing new HF artifacts more than
+    /// blurring away features. Value of 1.0 represents neutral.
+    /// </summary>
+    public float HfAsymmetry { get; set; } = 1f;
+
+    /// <summary>
+    /// Gets or sets the multiplier for the psychovisual difference in the X channel.
+    /// </summary>
+    public float XMultiplier { get; set; } = 1f;
+
+    /// <summary>
+    /// Gets or sets the number of nits that correspond to 1.0f input values.
+    /// </summary>
+    public float IntensityTarget { get; set; } = 80f;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliPsychoImage.cs b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliPsychoImage.cs
new file mode 100644
index 0000000000..de1166cf8e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Butteraugli/ButteraugliPsychoImage.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Butteraugli;
+
+// Public fields because InlineArray2 values
+// cannot be mutated if it's a property
+#pragma warning disable SA1401 // Fields should be private
+
+internal sealed class ButteraugliPsychoImage
+{
+    public InlineArray2<JxlPlane<float>> Uhf; // XY
+
+    public InlineArray2<JxlPlane<float>> Hf; // XY
+
+    public JxlImage3F? Mf { get; set; } // XYB
+
+    public JxlImage3F? Lf { get; set; } // XYB
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDct.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDct.cs
new file mode 100644
index 0000000000..c498c3a6d7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDct.cs
@@ -0,0 +1,305 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+/// <summary>
+/// Discrete Cosine Transform with SIMD support.
+/// </summary>
+internal static class JxlDct
+{
+    /// <summary>
+    /// Creates a new coefficient bundle.
+    /// </summary>
+    /// <param name="n">Number of items.</param>
+    /// <param name="sz">Coefficient size.</param>
+    /// <returns>A new coefficient bundle.</returns>
+    public static CoefficientBundle CoeffBundle(int n, int sz) => new(n, sz);
+
+    public static void Dct1DCore(int n, int sz, Span<float> mem, Span<float> tmp)
+    {
+        if (n == 2)
+        {
+            Vector<float> in1 = new(mem);
+            Vector<float> in2 = new(mem[sz..]);
+            (in1 + in2).CopyTo(mem);
+            (in1 - in2).CopyTo(mem[sz..]);
+        }
+        else
+        {
+            CoefficientBundle cb = CoeffBundle(n / 2, sz);
+
+            cb.AddReverse(mem, mem[(n / 2 * sz)..], tmp);
+            Dct1DCore(n / 2, sz, tmp, tmp[(n * sz)..]);
+
+            cb.SubReverse(mem, mem[(n / 2 * sz)..], tmp[(n / 2 * sz)..]);
+            cb.Multiply(tmp);
+
+            Dct1DCore(n / 2, sz, tmp[(n / 2 * sz)..], tmp[(n * sz)..]);
+            cb.B(tmp[(n / 2 * sz)..]);
+
+            CoeffBundle(n, sz).InverseEvenOdd(tmp, mem);
+        }
+    }
+
+    public static void InverseDct1DCore(int n, int sz, Span<float> from, int fromStride, Span<float> to, int toStride, Span<float> tmp)
+    {
+        if (n == 1)
+        {
+            from.CopyTo(to);
+        }
+        else if (n == 2)
+        {
+            Vector<float> in1 = new(from);
+            Vector<float> in2 = new(from[fromStride..]);
+            (in1 + in2).CopyTo(to);
+            (in1 + in2).CopyTo(to[toStride..]);
+        }
+        else
+        {
+            CoefficientBundle cbDiv2 = CoeffBundle(n / 2, sz);
+            CoefficientBundle cb = CoeffBundle(n, sz);
+
+            cb.ForwardEvenOdd(from, fromStride, tmp);
+            InverseDct1DCore(n / 2, sz, tmp, sz, tmp, sz, tmp[(n * sz)..]);
+
+            cbDiv2.BTranspose(tmp[((n / 2) * sz)..]);
+            InverseDct1DCore(n / 2, sz, tmp[((n / 2) * sz)..], sz, tmp[((n / 2) * sz)..], sz, tmp[(n * sz)..]);
+
+            cb.MultiplyAndAdd(tmp, to, toStride);
+        }
+    }
+
+    public static void Dct1DWrapper(int n, int m, bool fit, JxlDctSource from, JxlDctOutput to, int mp, Span<float> tmp)
+    {
+        CoefficientBundle cb = CoeffBundle(n, m);
+
+        for (int i = 0; i < mp; i += m)
+        {
+            cb.LoadFromBlock(from, i, tmp);
+            Dct1DCore(n, m, tmp, tmp[(n * m)..]);
+            cb.StoreToBlockAndScale(tmp, ref to, i);
+
+            if (fit)
+            {
+                return;
+            }
+        }
+    }
+
+    public static void InverseDct1DWrapper(int n, int m, bool fit, JxlDctSource from, JxlDctOutput to, int mp, Span<float> tmp)
+    {
+        for (int i = 0; i < mp; i += m)
+        {
+            InverseDct1DCore(n, m, from.Address(0, i), from.Stride, to.Address(0, i), to.Stride, tmp);
+
+            if (fit)
+            {
+                return;
+            }
+        }
+    }
+
+    public static void Dct1DCapped(int n, int m, int l, JxlDctSource from, JxlDctOutput to, Span<float> tmp)
+    {
+        bool fit = m <= l;
+        Dct1DWrapper(n, m, fit, from, to, m, tmp);
+    }
+
+    public static void InverseDct1DCapped(int n, int m, int l, JxlDctSource from, JxlDctOutput to, Span<float> tmp)
+    {
+        bool fit = m <= l;
+        InverseDct1DWrapper(n, m, fit, from, to, m, tmp);
+    }
+
+    public static void Dct1D(int n, int m, JxlDctSource from, JxlDctOutput to, Span<float> tmp)
+    {
+        int lanes = Vector<float>.Count;
+        Dct1DCapped(n, m, lanes, from, to, tmp);
+    }
+
+    public static void InverseDct1D(int n, int m, JxlDctSource source, JxlDctOutput output, Span<float> tmp)
+    {
+        int lanes = Vector<float>.Count;
+        InverseDct1DCapped(n, m, lanes, source, output, tmp);
+    }
+
+    public static void ComputeScaledDct(int rows, int columns, JxlDctSource from, Span<float> to, Span<float> scratchSpace)
+    {
+        Span<float> block = scratchSpace;
+        Span<float> tmp = scratchSpace[(rows * columns)..];
+
+        if (rows < columns)
+        {
+            Dct1D(rows, columns, from, new JxlDctOutput(block, columns), tmp);
+            JxlTranspose.Transpose(rows, columns, new JxlDctSource(block, columns), new JxlDctOutput(to, rows));
+            Dct1D(columns, rows, new JxlDctSource(to, rows), new JxlDctOutput(block, rows), tmp);
+            JxlTranspose.Transpose(columns, rows, new JxlDctSource(block, rows), new JxlDctOutput(to, columns));
+        }
+        else
+        {
+            Dct1D(rows, columns, from, new JxlDctOutput(to, columns), tmp);
+            JxlTranspose.Transpose(rows, columns, new JxlDctSource(to, columns), new JxlDctOutput(block, rows));
+            Dct1D(columns, rows, new JxlDctSource(block, rows), new JxlDctOutput(to, rows), tmp);
+        }
+    }
+
+    public static void ComputeScaledInverseDct(int rows, int columns, Span<float> from, JxlDctOutput to, Span<float> scratchSpace)
+    {
+        Span<float> block = scratchSpace;
+        Span<float> tmp = scratchSpace[(rows * columns)..];
+
+        if (rows < columns)
+        {
+            JxlTranspose.Transpose(rows, columns, new JxlDctSource(from, columns), new JxlDctOutput(block, rows));
+            InverseDct1D(columns, rows, new JxlDctSource(block, rows), new JxlDctOutput(from, rows), tmp);
+            JxlTranspose.Transpose(columns, rows, new JxlDctSource(from, rows), new JxlDctOutput(block, columns));
+            InverseDct1D(rows, columns, new JxlDctSource(block, columns), to, tmp);
+        }
+        else
+        {
+            InverseDct1D(columns, rows, new JxlDctSource(from, rows), new JxlDctOutput(block, rows), tmp);
+            JxlTranspose.Transpose(columns, rows, new JxlDctSource(block, rows), new JxlDctOutput(from, columns));
+            InverseDct1D(rows, columns, new JxlDctSource(from, columns), to, tmp);
+        }
+    }
+
+    /// <summary>
+    /// Core methods for the Discrete Cosine Transform (DCT).
+    /// </summary>
+    public readonly struct CoefficientBundle(int n, int sz)
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AddReverse(Span<float> aIn1, Span<float> aIn2, Span<float> aOut)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                Vector<float> in1 = new(aIn1[(i * sz)..]);
+                Vector<float> in2 = new(aIn2[((n - i - 1) * sz)..]);
+                (in1 + in2).CopyTo(aOut[(i * sz)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SubReverse(Span<float> aIn1, Span<float> aIn2, Span<float> aOut)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                Vector<float> in1 = new(aIn1[(i * sz)..]);
+                Vector<float> in2 = new(aIn2[((n - i - 1) * sz)..]);
+                (in1 - in2).CopyTo(aOut[(i * sz)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void B(Span<float> coeff)
+        {
+            Vector<float> sqrt2 = new(JxlDctScales.Sqrt2);
+            Vector<float> in10 = new(coeff);
+            Vector<float> in20 = new(coeff[sz..]);
+            ((in10 * sqrt2) + in20).CopyTo(coeff);
+
+            for (int i = 1; i + 1 < n; i++)
+            {
+                Vector<float> in1 = new(coeff[(i * sz)..]);
+                Vector<float> in2 = new(coeff[((i + 1) * sz)..]);
+                (in1 + in2).CopyTo(coeff[(i * sz)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BTranspose(Span<float> coeff)
+        {
+            for (int i = n - 1; i > 0; i--)
+            {
+                Vector<float> in1 = new(coeff[(i * sz)..]);
+                Vector<float> in2 = new(coeff[((i - 1) * sz)..]);
+                (in1 + in2).CopyTo(coeff[(i * sz)..]);
+            }
+
+            Vector<float> sqrt2 = new(JxlDctScales.Sqrt2);
+            Vector<float> in1x = new(coeff);
+            (in1x * sqrt2).CopyTo(coeff);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InverseEvenOdd(Span<float> aIn, Span<float> aOut)
+        {
+            for (int i = 0; i < n / 2; i++)
+            {
+                new Vector<float>(aIn[(i * sz)..]).CopyTo(aOut[((2 * i) * sz)..]);
+            }
+
+            for (int i = n / 2; i < n; i++)
+            {
+                new Vector<float>(aIn[(i * sz)..]).CopyTo(aOut[(((2 * (i - (n / 2))) + 1) * sz)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ForwardEvenOdd(Span<float> aIn, int aInStride, Span<float> aOut)
+        {
+            for (int i = 0; i < n / 2; i++)
+            {
+                new Vector<float>(aIn[(2 * i * aInStride)..]).CopyTo(aOut[(i * sz)..]);
+            }
+
+            for (int i = n / 2; i < n; i++)
+            {
+                new Vector<float>(aIn[(((2 * (i - (n / 2))) + 1) * aInStride)..]).CopyTo(aOut[(i * sz)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Multiply(Span<float> coeff)
+        {
+            ReadOnlySpan<float> multipliers = JxlDctScales.GetMultipliers(n);
+
+            for (int i = 0; i < n / 2; i++)
+            {
+                Vector<float> in1 = new(coeff[(((n / 2) + i) * sz)..]);
+                Vector<float> mul = new(multipliers[i]);
+                (in1 * mul).CopyTo(coeff[((n / (2 + i)) * sz)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MultiplyAndAdd(Span<float> coeff, Span<float> output, int outStride)
+        {
+            ReadOnlySpan<float> multipliers = JxlDctScales.GetMultipliers(n);
+
+            for (int i = 0; i < n / 2; i++)
+            {
+                Vector<float> mul = new(multipliers[i]);
+                Vector<float> in1 = new(coeff[(i * sz)..]);
+                Vector<float> in2 = new(coeff[((n / (2 + i)) * sz)..]);
+                Vector<float> out1 = (mul * in2) * in1;
+                Vector<float> out2 = -(mul * in2) + in1;
+                out1.CopyTo(output[(i * outStride)..]);
+                out2.CopyTo(output[((n - i - 1) * outStride)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void LoadFromBlock(in JxlDctSource input, int offset, Span<float> coeff)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                input.LoadPart(i, offset).CopyTo(coeff[(i * sz)..]);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void StoreToBlockAndScale(Span<float> coeff, ref JxlDctOutput output, int offset)
+        {
+            Vector<float> mul = new(1.0f / n);
+            for (int i = 0; i < n; i++)
+            {
+                output.StorePart(mul * new Vector<float>(coeff[(i * sz)..]), i, offset);
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcImage{T}.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcImage{T}.cs
new file mode 100644
index 0000000000..002342ae57
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcImage{T}.cs
@@ -0,0 +1,61 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+internal sealed class JxlDctAcImage<T> : IJxlDctAcImage, IDisposable
+    where T : unmanaged
+{
+    private readonly JxlImage3<T> image;
+
+    public unsafe JxlDctAcImage(Configuration configuration, int width, int height)
+    {
+        DebugGuard.IsTrue(sizeof(T) is 2 or 4, "The type must be 2 or 4 bytes");
+
+        this.image = JxlImage3<T>.Create(configuration, width, height);
+    }
+
+    public unsafe JxlDctAcType Type => sizeof(T) == 4 ? JxlDctAcType.Ac32 : JxlDctAcType.Ac16;
+
+    public int PixelsPerRow => this.image.PixelsPerRow;
+
+    public bool IsEmpty => this.image.XSize == 0 || this.image.YSize == 0;
+
+    public void Clear() => JxlImageOperations.ZeroFillImage(this.image);
+
+    public void Clear(int plane = 0) => JxlImageOperations.ZeroFillImage(this.image);
+
+    public unsafe JxlDctAcPointer GetPlaneRow(int channel, int y, int xBase = 0)
+    {
+        if (sizeof(T) == 4)
+        {
+            Span<int> span = (this.image as JxlImage3<int>)!.PlaneRow(channel, y)[xBase..];
+            return new JxlDctAcPointer() { Pointer32 = span };
+        }
+        else
+        {
+            Span<short> span = (this.image as JxlImage3<short>)!.PlaneRow(channel, y)[xBase..];
+            return new JxlDctAcPointer() { Pointer16 = span };
+        }
+    }
+
+    public unsafe JxlDctReadOnlyAcPointer GetReadOnlyPlaneRow(int channel, int y, int xBase = 0)
+    {
+        if (sizeof(T) == 4)
+        {
+            ReadOnlySpan<int> span = (this.image as JxlImage3<int>)!.PlaneRow(channel, y)[xBase..];
+            return new JxlDctReadOnlyAcPointer(span);
+        }
+        else
+        {
+            ReadOnlySpan<short> span = (this.image as JxlImage3<short>)!.PlaneRow(channel, y)[xBase..];
+            return new JxlDctReadOnlyAcPointer(span);
+        }
+    }
+
+    public void Dispose() => this.image.Dispose();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcPointer.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcPointer.cs
new file mode 100644
index 0000000000..732e8f4a04
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcPointer.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+/// <summary>
+/// Pointer to DCT AC coefficients
+/// </summary>
+internal ref struct JxlDctAcPointer()
+{
+    /// <summary>
+    /// 16-bit pointer (if any)
+    /// </summary>
+    public Span<short> Pointer16 = [];
+
+    /// <summary>
+    /// 32-bit pointer (if any)
+    /// </summary>
+    public Span<int> Pointer32 = [];
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcType.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcType.cs
new file mode 100644
index 0000000000..35801b9192
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctAcType.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+/// <summary>
+/// Bit size for DCT AC coefficient
+/// </summary>
+internal enum JxlDctAcType : byte
+{
+    /// <summary>
+    /// 16-bit coefficient
+    /// </summary>
+    Ac16,
+
+    /// <summary>
+    /// 32-bit coefficient
+    /// </summary>
+    Ac32
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctOutput.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctOutput.cs
new file mode 100644
index 0000000000..5a1d5c9581
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctOutput.cs
@@ -0,0 +1,71 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+/// <summary>
+/// Output DCT block.
+/// </summary>
+internal ref struct JxlDctOutput(Span<float> data, int stride)
+{
+    /// <summary>
+    /// Raw block data.
+    /// </summary>
+    public Span<float> Data = data;
+
+    /// <summary>
+    /// Stride size.
+    /// </summary>
+    public readonly int Stride = stride;
+
+    /// <summary>
+    /// Returns the span to the start of a row and offset.
+    /// </summary>
+    /// <param name="row">The row index.</param>
+    /// <param name="i">The offset.</param>
+    /// <returns>
+    /// Span for that row &amp; offset.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Span<float> Address(int row, int i) => this.Data[((row * this.Stride) + i)..];
+
+    /// <summary>
+    /// Writes a single value to the block at the row and offset.
+    /// </summary>
+    /// <param name="value">The value to write.</param>
+    /// <param name="row">The row index.</param>
+    /// <param name="i">The offset.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Write(float value, int row, int i) => this.Data[(row * this.Stride) + i] = value;
+
+    /// <summary>
+    /// Stores the vector into the data at the specified row and offset.
+    /// </summary>
+    /// <param name="value">The vector to write.</param>
+    /// <param name="row">The row index.</param>
+    /// <param name="index">The offset.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void StorePart(Vector<float> value, int row, int index) => value.CopyTo(this.Address(row, index));
+
+    /// <summary>
+    /// Stores the vector into the data at the specified row and offset.
+    /// </summary>
+    /// <param name="value">The vector to write.</param>
+    /// <param name="row">The row index.</param>
+    /// <param name="index">The offset.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void StorePart256(Vector256<float> value, int row, int index) => value.CopyTo(this.Address(row, index));
+
+    /// <summary>
+    /// Stores the vector into the data at the specified row and offset.
+    /// </summary>
+    /// <param name="value">The vector to write.</param>
+    /// <param name="row">The row index.</param>
+    /// <param name="index">The offset.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void StorePart128(Vector128<float> value, int row, int index) => value.CopyTo(this.Address(row, index));
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctQuantWeightParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctQuantWeightParameters.cs
new file mode 100644
index 0000000000..2c0573668c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctQuantWeightParameters.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+internal sealed class JxlDctQuantWeightParameters
+{
+    private const int Log2MaxDistanceBands = 4;
+    private const int MaxDistanceBands = 1 + (1 << Log2MaxDistanceBands);
+
+    public JxlDctQuantWeightParameters()
+    {
+        this.DistanceBands = new float[3][];
+        for (int i = 0; i < 3; i++)
+        {
+            this.DistanceBands[i] = new float[MaxDistanceBands];
+        }
+    }
+
+    public JxlDctQuantWeightParameters(float[][] distanceBands, int numDistanceBands)
+    {
+        this.NumDistanceBands = numDistanceBands;
+        this.DistanceBands = distanceBands;
+    }
+
+    public int NumDistanceBands { get; set; }
+
+    public float[][] DistanceBands { get; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctReadOnlyAcPointer.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctReadOnlyAcPointer.cs
new file mode 100644
index 0000000000..cbedf64fe8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctReadOnlyAcPointer.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+/// <summary>
+/// Pointer to DCT AC coefficients. (Read-only)
+/// </summary>
+internal readonly ref struct JxlDctReadOnlyAcPointer
+{
+    /// <summary>
+    /// 16-bit pointer (if any)
+    /// </summary>
+    public readonly ReadOnlySpan<short> Pointer16;
+
+    /// <summary>
+    /// 32-bit pointer (if any)
+    /// </summary>
+    public readonly ReadOnlySpan<int> Pointer32;
+
+    internal JxlDctReadOnlyAcPointer(ReadOnlySpan<short> pointer16) => this.Pointer16 = pointer16;
+
+    internal JxlDctReadOnlyAcPointer(ReadOnlySpan<int> pointer32) => this.Pointer32 = pointer32;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctScales.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctScales.cs
new file mode 100644
index 0000000000..e6f4ecfa7e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctScales.cs
@@ -0,0 +1,445 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+/// <summary>
+/// Read-only cosine lookups for the Discrete Cosine Transform (DCT),
+/// a mathematical function used for quantization and coefficient reordering.
+/// </summary>
+internal static class JxlDctScales
+{
+    /// <summary>
+    /// Square root of 2.
+    /// </summary>
+    public const float Sqrt2 = 1.41421356237f;
+
+    /// <summary>
+    /// Square root of 0.5.
+    /// </summary>
+    public const float Sqrt05 = 0.70710678118f;
+
+    /// <summary>
+    /// Gets 8x1 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales8_1 =>
+    [
+        1.000000000000000000f
+    ];
+
+    /// <summary>
+    /// Gets 16x2 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales16_2 =>
+    [
+        1.000000000000000000f,
+        0.901764195028874394f,
+    ];
+
+    /// <summary>
+    /// Gets 32x4 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales32_4 =>
+    [
+        1.000000000000000000f,
+        0.974886821136879522f,
+        0.901764195028874394f,
+        0.787054918159101335f,
+    ];
+
+    /// <summary>
+    /// Gets 64x8 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales64_8 =>
+    [
+        1.0000000000000000f,
+        0.9936866130906366f,
+        0.9748868211368796f,
+        0.9440180941651672f,
+        0.9017641950288744f,
+        0.8490574973847023f,
+        0.7870549181591013f,
+        0.7171081282466044f,
+    ];
+
+    /// <summary>
+    /// Gets 128x16 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales128_16 =>
+    [
+        1.0f,
+        0.9984194528776054f,
+        0.9936866130906366f,
+        0.9858278282666936f,
+        0.9748868211368796f,
+        0.9609244059440204f,
+        0.9440180941651672f,
+        0.9242615922757944f,
+        0.9017641950288744f,
+        0.8766500784429904f,
+        0.8490574973847023f,
+        0.8191378932865928f,
+        0.7870549181591013f,
+        0.7529833816270532f,
+        0.7171081282466044f,
+        0.6796228528314651f,
+    ];
+
+    /// <summary>
+    /// Gets 256x32 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales256_32 =>
+    [
+        1.0f,
+        0.9996047255830407f,
+        0.9984194528776054f,
+        0.9964458326264695f,
+        0.9936866130906366f,
+        0.9901456355893141f,
+        0.9858278282666936f,
+        0.9807391980963174f,
+        0.9748868211368796f,
+        0.9682788310563117f,
+        0.9609244059440204f,
+        0.9528337534340876f,
+        0.9440180941651672f,
+        0.9344896436056892f,
+        0.9242615922757944f,
+        0.913348084400198f,
+        0.9017641950288744f,
+        0.8895259056651056f,
+        0.8766500784429904f,
+        0.8631544288990163f,
+        0.8490574973847023f,
+        0.8343786191696513f,
+        0.8191378932865928f,
+        0.8033561501721485f,
+        0.7870549181591013f,
+        0.7702563888779096f,
+        0.7529833816270532f,
+        0.7352593067735488f,
+        0.7171081282466044f,
+        0.6985543251889097f,
+        0.6796228528314651f,
+        0.6603391026591464f,
+    ];
+
+    /// <summary>
+    /// Gets 1x8 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales1_8 =>
+    [
+        1.000000000000000000f
+    ];
+
+    /// <summary>
+    /// Gets 2x16 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales2_16 =>
+    [
+        1.000000000000000000f,
+        1.108937353592731823f,
+    ];
+
+    /// <summary>
+    /// Gets 4x32 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales4_32 =>
+    [
+        1.000000000000000000f,
+        1.025760096781116015f,
+        1.108937353592731823f,
+        1.270559368765487251f,
+    ];
+
+    /// <summary>
+    /// Gets 8x64 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales8_64 =>
+    [
+        1.0000000000000000f,
+        1.0063534990068217f,
+        1.0257600967811158f,
+        1.0593017296817173f,
+        1.1089373535927318f,
+        1.1777765381970435f,
+        1.2705593687654873f,
+        1.3944898413647777f,
+    ];
+
+    /// <summary>
+    /// Gets 16x128 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales16_128 =>
+    [
+        1.0f,
+        1.0015830492062623f,
+        1.0063534990068217f,
+        1.0143759095928793f,
+        1.0257600967811158f,
+        1.0406645869480142f,
+        1.0593017296817173f,
+        1.0819447744633812f,
+        1.1089373535927318f,
+        1.1407059950032632f,
+        1.1777765381970435f,
+        1.2207956782315876f,
+        1.2705593687654873f,
+        1.3280505578213306f,
+        1.3944898413647777f,
+        1.4714043176061107f,
+    ];
+
+    /// <summary>
+    /// Gets 32x256 DCT resample scales.
+    /// </summary>
+    public static ReadOnlySpan<float> ResampleScales32_256 =>
+    [
+        1.0f,
+        1.0003954307206069f,
+        1.0015830492062623f,
+        1.0035668445360069f,
+        1.0063534990068217f,
+        1.009952439375063f,
+        1.0143759095928793f,
+        1.0196390660647288f,
+        1.0257600967811158f,
+        1.0327603660498115f,
+        1.0406645869480142f,
+        1.049501024072585f,
+        1.0593017296817173f,
+        1.0701028169146336f,
+        1.0819447744633812f,
+        1.0948728278734026f,
+        1.1089373535927318f,
+        1.124194353004584f,
+        1.1407059950032632f,
+        1.158541237256391f,
+        1.1777765381970435f,
+        1.1984966740820495f,
+        1.2207956782315876f,
+        1.244777922949508f,
+        1.2705593687654873f,
+        1.2982690107339132f,
+        1.3280505578213306f,
+        1.3600643892400104f,
+        1.3944898413647777f,
+        1.4315278911623237f,
+        1.4714043176061107f,
+        1.5143734423314616f,
+    ];
+
+    /// <summary>
+    /// Gets the DCT multiplier constants
+    /// </summary>
+    public static ReadOnlySpan<float> Multipliers4 =>
+    [
+        0.541196100146197f,
+        1.3065629648763764f,
+    ];
+
+    /// <summary>
+    /// Gets the DCT multiplier constants
+    /// </summary>
+    public static ReadOnlySpan<float> Multipliers8 =>
+    [
+        0.5097955791041592f,
+        0.6013448869350453f,
+        0.8999762231364156f,
+        2.5629154477415055f,
+    ];
+
+    /// <summary>
+    /// Gets the DCT multiplier constants
+    /// </summary>
+    public static ReadOnlySpan<float> Multipliers16 =>
+    [
+        0.5024192861881557f, 0.5224986149396889f, 0.5669440348163577f,
+        0.6468217833599901f, 0.7881546234512502f, 1.060677685990347f,
+        1.7224470982383342f, 5.101148618689155f,
+    ];
+
+    /// <summary>
+    /// Gets the DCT multiplier constants
+    /// </summary>
+    public static ReadOnlySpan<float> Multipliers32 =>
+    [
+        0.5006029982351963f, 0.5054709598975436f, 0.5154473099226246f,
+        0.5310425910897841f, 0.5531038960344445f, 0.5829349682061339f,
+        0.6225041230356648f, 0.6748083414550057f, 0.7445362710022986f,
+        0.8393496454155268f, 0.9725682378619608f, 1.1694399334328847f,
+        1.4841646163141662f, 2.057781009953411f,  3.407608418468719f,
+        10.190008123548033f,
+    ];
+
+    /// <summary>
+    /// Gets the DCT multiplier constants
+    /// </summary>
+    public static ReadOnlySpan<float> Multipliers64 =>
+    [
+        0.500150636020651f,  0.5013584524464084f, 0.5037887256810443f,
+        0.5074711720725553f, 0.5124514794082247f, 0.5187927131053328f,
+        0.52657731515427f,   0.535909816907992f,  0.5469204379855088f,
+        0.5597698129470802f, 0.57465518403266f,   0.5918185358574165f,
+        0.6115573478825099f, 0.6342389366884031f, 0.6603198078137061f,
+        0.6903721282002123f, 0.7251205223771985f, 0.7654941649730891f,
+        0.8127020908144905f, 0.8683447152233481f, 0.9345835970364075f,
+        1.0144082649970547f, 1.1120716205797176f, 1.233832737976571f,
+        1.3892939586328277f, 1.5939722833856311f, 1.8746759800084078f,
+        2.282050068005162f,  2.924628428158216f,  4.084611078129248f,
+        6.796750711673633f,  20.373878167231453f,
+    ];
+
+    /// <summary>
+    /// Gets the DCT multiplier constants
+    /// </summary>
+    public static ReadOnlySpan<float> Multipliers128 =>
+    [
+        0.5000376519155477f, 0.5003390374428216f, 0.5009427176380873f,
+        0.5018505174842379f, 0.5030651913013697f, 0.5045904432216454f,
+        0.5064309549285542f, 0.5085924210498143f, 0.5110815927066812f,
+        0.5139063298475396f, 0.5170756631334912f, 0.5205998663018917f,
+        0.524490540114724f,  0.5287607092074876f, 0.5334249333971333f,
+        0.538499435291984f,  0.5440022463817783f, 0.549953374183236f,
+        0.5563749934898856f, 0.5632916653417023f, 0.5707305880121454f,
+        0.5787218851348208f, 0.5872989370937893f, 0.5964987630244563f,
+        0.606362462272146f,  0.6169357260050706f, 0.6282694319707711f,
+        0.6404203382416639f, 0.6534518953751283f, 0.6674352009263413f,
+        0.6824501259764195f, 0.6985866506472291f, 0.7159464549705746f,
+        0.7346448236478627f, 0.7548129391165311f, 0.776600658233963f,
+        0.8001798956216941f, 0.8257487738627852f, 0.8535367510066064f,
+        0.8838110045596234f, 0.9168844461846523f, 0.9531258743921193f,
+        0.9929729612675466f, 1.036949040910389f,  1.0856850642580145f,
+        1.1399486751015042f, 1.2006832557294167f, 1.2690611716991191f,
+        1.346557628206286f,  1.4350550884414341f, 1.5369941008524954f,
+        1.6555965242641195f, 1.7952052190778898f, 1.961817848571166f,
+        2.163957818751979f,  2.4141600002500763f, 2.7316450287739396f,
+        3.147462191781909f,  3.7152427383269746f, 4.5362909369693565f,
+        5.827688377844654f,  8.153848602466814f,  13.58429025728446f,
+        40.744688103351834f,
+    ];
+
+    /// <summary>
+    /// Gets the DCT multiplier constants
+    /// </summary>
+    public static ReadOnlySpan<float> Multipliers256 =>
+    [
+        0.5000094125358878f, 0.500084723455784f,  0.5002354020255269f,
+        0.5004615618093246f, 0.5007633734146156f, 0.5011410648064231f,
+        0.5015949217281668f, 0.502125288230386f,  0.5027325673091954f,
+        0.5034172216566842f, 0.5041797745258774f, 0.5050208107132756f,
+        0.5059409776624396f, 0.5069409866925212f, 0.5080216143561264f,
+        0.509183703931388f,  0.5104281670536573f, 0.5117559854927805f,
+        0.5131682130825206f, 0.5146659778093218f, 0.516250484068288f,
+        0.5179230150949777f, 0.5196849355823947f, 0.5215376944933958f,
+        0.5234828280796439f, 0.52552196311921f,   0.5276568203859896f,
+        0.5298892183652453f, 0.5322210772308335f, 0.5346544231010253f,
+        0.537191392591309f,  0.5398342376841637f, 0.5425853309375497f,
+        0.545447171055775f,  0.5484223888484947f, 0.551513753605893f,
+        0.554724179920619f,  0.5580567349898085f, 0.5615146464335654f,
+        0.5651013106696203f, 0.5688203018875696f, 0.5726753816701664f,
+        0.5766705093136241f, 0.5808098529038624f, 0.5850978012111273f,
+        0.58953897647151f,   0.5941382481306648f, 0.5989007476325463f,
+        0.6038318843443582f, 0.6089373627182432f, 0.614223200800649f,
+        0.6196957502119484f, 0.6253617177319102f, 0.6312281886412079f,
+        0.6373026519855411f, 0.6435930279473415f, 0.6501076975307724f,
+        0.6568555347890955f, 0.6638459418498757f, 0.6710888870233562f,
+        0.6785949463131795f, 0.6863753486870501f, 0.6944420255086364f,
+        0.7028076645818034f, 0.7114857693151208f, 0.7204907235796304f,
+        0.7298378629074134f, 0.7395435527641373f, 0.749625274727372f,
+        0.7601017215162176f, 0.7709929019493761f, 0.7823202570613161f,
+        0.7941067887834509f, 0.8063772028037925f, 0.8191580674598145f,
+        0.83247799080191f,   0.8463678182968619f, 0.860860854031955f,
+        0.8759931087426972f, 0.8918035785352535f, 0.9083345588266809f,
+        0.9256319988042384f, 0.9437459026371479f, 0.962730784794803f,
+        0.9826461881778968f, 1.0035572754078206f, 1.0255355056139732f,
+        1.048659411496106f,  1.0730154944316674f, 1.0986992590905857f,
+        1.1258164135986009f, 1.1544842669978943f, 1.184833362908442f,
+        1.217009397314603f,  1.2511754798461228f, 1.287514812536712f,
+        1.326233878832723f,  1.3675662599582539f, 1.411777227500661f,
+        1.459169302866857f,  1.5100890297227016f, 1.5649352798258847f,
+        1.6241695131835794f, 1.6883285509131505f, 1.7580406092704062f,
+        1.8340456094306077f, 1.9172211551275689f, 2.0086161135167564f,
+        2.1094945286246385f, 2.22139377701127f,   2.346202662531156f,
+        2.486267909203593f,  2.644541877144861f,  2.824791402350551f,
+        3.0318994541759925f, 3.2723115884254845f, 3.5547153325075804f,
+        3.891107790700307f,  4.298537526449054f,  4.802076008665048f,
+        5.440166215091329f,  6.274908408039339f,  7.413566756422303f,
+        9.058751453879703f,  11.644627325175037f, 16.300023088031555f,
+        27.163977662448232f, 81.48784219222516f,
+    ];
+
+    /// <summary>
+    /// Returns DCT multipliers for size <paramref name="n"/>.
+    /// </summary>
+    /// <param name="n">The multiplier size</param>
+    /// <returns>DCT multipliers for the given size.</returns>
+    public static ReadOnlySpan<float> GetMultipliers(int n) => n switch
+    {
+        4 => Multipliers4,
+        8 => Multipliers8,
+        16 => Multipliers16,
+        32 => Multipliers32,
+        64 => Multipliers64,
+        128 => Multipliers128,
+        256 => Multipliers256,
+        _ => []
+    };
+
+    [MethodImpl(InliningOptions.HotPath | InliningOptions.AlwaysInline)]
+    public static ReadOnlySpan<float> GetResampleScales(int x, int y)
+    {
+        DebugGuard.IsTrue(x is 1 or 2 or 4 or 8 or 16 or 32 or 64 or 128 or 256, "x is invalid");
+        if (x == 1)
+        {
+            DebugGuard.IsTrue(y == 8, "Only y=8 resample scale for x=1 exists");
+            return ResampleScales1_8;
+        }
+        else if (x == 2)
+        {
+            DebugGuard.IsTrue(y == 16, "Only y=16 resample scale for x=2 exists");
+            return ResampleScales2_16;
+        }
+        else if (x == 4)
+        {
+            DebugGuard.IsTrue(y == 32, "Only y=32 resample scale for x=4 exists");
+            return ResampleScales4_32;
+        }
+        else if (x == 8)
+        {
+            DebugGuard.IsTrue(y is 1 or 64, "Only y=1,64 resample scale for x=8 exists");
+            return y == 1 ? ResampleScales8_1 : ResampleScales8_64;
+        }
+        else if (x == 16)
+        {
+            DebugGuard.IsTrue(y is 2 or 128, "Only y=2,128 resample scale for x=16 exists");
+            return y == 2 ? ResampleScales16_2 : ResampleScales16_128;
+        }
+        else if (x == 32)
+        {
+            DebugGuard.IsTrue(y is 4 or 256, "Only y=4,256 resample scale for x=32 exists");
+            return y == 4 ? ResampleScales32_4 : ResampleScales32_256;
+        }
+        else if (x == 64)
+        {
+            DebugGuard.IsTrue(y == 8, "Only y=8 resample scale for x=64 exists");
+            return ResampleScales64_8;
+        }
+        else if (x == 128)
+        {
+            DebugGuard.IsTrue(y == 16, "Only y=16 resample scale for x=128 exists");
+            return ResampleScales128_16;
+        }
+        else if (x == 256)
+        {
+            DebugGuard.IsTrue(y == 32, "Only y=32 resample scale for x=256 exists");
+            return ResampleScales256_32;
+        }
+        else
+        {
+            return [];
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctSource.cs b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctSource.cs
new file mode 100644
index 0000000000..ba99dd5f67
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Dct/JxlDctSource.cs
@@ -0,0 +1,76 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+/// <summary>
+/// Source DCT block.
+/// </summary>
+internal readonly ref struct JxlDctSource(Span<float> data, int stride)
+{
+    /// <summary>
+    /// Raw block data.
+    /// </summary>
+    public readonly Span<float> Data = data;
+
+    /// <summary>
+    /// Stride size.
+    /// </summary>
+    public readonly int Stride = stride;
+
+    /// <summary>
+    /// Returns the span to the start of a row and offset.
+    /// </summary>
+    /// <param name="row">The row index.</param>
+    /// <param name="i">The offset.</param>
+    /// <returns>
+    /// Span for that row &amp; offset.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Span<float> Address(int row, int i) => this.Data[((row * this.Stride) + i)..];
+
+    /// <summary>
+    /// Returns the coefficient at the row and offset.
+    /// </summary>
+    /// <param name="row">The row index.</param>
+    /// <param name="i">The offset.</param>
+    /// <returns>
+    /// Coefficient at that row and offset.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float Read(int row, int i) => this.Data[(row * this.Stride) + i];
+
+    /// <summary>
+    /// Loads a vector at the specified row and offset.
+    /// </summary>
+    /// <param name="row">The row index.</param>
+    /// <param name="i">The offset.</param>
+    /// <returns>
+    /// Vector at that row and offset.
+    /// </returns>
+    public Vector<float> LoadPart(int row, int i) => new(this.Address(row, i));
+
+    /// <summary>
+    /// Loads a vector at the specified row and offset.
+    /// </summary>
+    /// <param name="row">The row index.</param>
+    /// <param name="i">The offset.</param>
+    /// <returns>
+    /// Vector at that row and offset.
+    /// </returns>
+    public Vector256<float> LoadPart256(int row, int i) => Vector256.Create<float>(this.Address(row, i));
+
+    /// <summary>
+    /// Loads a vector at the specified row and offset.
+    /// </summary>
+    /// <param name="row">The row index.</param>
+    /// <param name="i">The offset.</param>
+    /// <returns>
+    /// Vector at that row and offset.
+    /// </returns>
+    public Vector128<float> LoadPart128(int row, int i) => Vector128.Create<float>(this.Address(row, i));
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsCode.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsCode.cs
new file mode 100644
index 0000000000..e5cd1f783b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsCode.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+
+internal sealed class JxlAnsCode
+{
+    public List<JxlHuffmanDecodingData> HuffmanData { get; set; } = [];
+
+    public List<JxlAnsHybridUIntConfiguration> UIntConfig { get; set; } = [];
+
+    public List<int> DegenerateSymbols { get; set; } = [];
+
+    public bool UsePrefixCode { get; set; }
+
+    public byte LogAlphaSize { get; set; }
+
+    public JxlAnsLz77Parameters Lz77 { get; set; } = new();
+
+    public int MaxNumBits { get; set; }
+
+    public void UpdateMaxNumBits(int ctx, int symbol)
+    {
+        Span<JxlAnsHybridUIntConfiguration> configs = CollectionsMarshal.AsSpan(this.UIntConfig);
+        ref JxlAnsHybridUIntConfiguration cfg = ref configs[ctx];
+        if (this.Lz77.Enabled && this.Lz77.NonserializedDistanceContext != ctx && symbol >= this.Lz77.MinimumSymbol)
+        {
+            symbol -= (int)this.Lz77.MinimumSymbol;
+            cfg = ref this.Lz77.GetLengthUIntConfigReference();
+        }
+
+        uint splitToken = cfg.SplitToken;
+        uint msbInToken = cfg.MsbInToken;
+        uint lsbInToken = cfg.LsbInToken;
+        uint splitExponent = cfg.SplitExponent;
+
+        if (symbol < splitToken)
+        {
+            this.MaxNumBits = Math.Max(this.MaxNumBits, (int)splitExponent);
+            return;
+        }
+
+        uint nExtra = splitExponent - (msbInToken + lsbInToken) + (((uint)symbol - splitToken) >> (int)(msbInToken + lsbInToken));
+        uint total = msbInToken + lsbInToken + nExtra + 1;
+        this.MaxNumBits = Math.Max(this.MaxNumBits, (int)total);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsReader.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsReader.cs
new file mode 100644
index 0000000000..683ee27835
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsReader.cs
@@ -0,0 +1,281 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+
+internal static class JxlAnsReader
+{
+    private const int WindowSize = 1 << 20;
+
+    private const int NumSpecialDistances = 120;
+
+    // Prefer jagged arrays over multidimensional arrays
+    // for performance. Collection expressions help represent
+    // jagged arrays easily.
+    private static readonly byte[][] HuffmanLookup =
+    [
+        [3, 10], [7, 12], [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+        [3, 10], [5, 0],  [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+        [3, 10], [6, 11], [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+        [3, 10], [5, 0],  [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+        [3, 10], [7, 13], [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+        [3, 10], [5, 0],  [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+        [3, 10], [6, 11], [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+        [3, 10], [5, 0],  [3, 7], [4, 3], [3, 6], [3, 8], [3, 9], [4, 5],
+        [3, 10], [4, 4],  [3, 7], [4, 1], [3, 6], [3, 8], [3, 9], [4, 2],
+    ];
+
+    private static readonly sbyte[][] SpecialDistances =
+    [
+        [0, 1],  [1, 0],  [1, 1],  [-1, 1], [0, 2],  [2, 0],  [1, 2],  [-1, 2],
+        [2, 1],  [-2, 1], [2, 2],  [-2, 2], [0, 3],  [3, 0],  [1, 3],  [-1, 3],
+        [3, 1],  [-3, 1], [2, 3],  [-2, 3], [3, 2],  [-3, 2], [0, 4],  [4, 0],
+        [1, 4],  [-1, 4], [4, 1],  [-4, 1], [3, 3],  [-3, 3], [2, 4],  [-2, 4],
+        [4, 2],  [-4, 2], [0, 5],  [3, 4],  [-3, 4], [4, 3],  [-4, 3], [5, 0],
+        [1, 5],  [-1, 5], [5, 1],  [-5, 1], [2, 5],  [-2, 5], [5, 2],  [-5, 2],
+        [4, 4],  [-4, 4], [3, 5],  [-3, 5], [5, 3],  [-5, 3], [0, 6],  [6, 0],
+        [1, 6],  [-1, 6], [6, 1],  [-6, 1], [2, 6],  [-2, 6], [6, 2],  [-6, 2],
+        [4, 5],  [-4, 5], [5, 4],  [-5, 4], [3, 6],  [-3, 6], [6, 3],  [-6, 3],
+        [0, 7],  [7, 0],  [1, 7],  [-1, 7], [5, 5],  [-5, 5], [7, 1],  [-7, 1],
+        [4, 6],  [-4, 6], [6, 4],  [-6, 4], [2, 7],  [-2, 7], [7, 2],  [-7, 2],
+        [3, 7],  [-3, 7], [7, 3],  [-7, 3], [5, 6],  [-5, 6], [6, 5],  [-6, 5],
+        [8, 0],  [4, 7],  [-4, 7], [7, 4],  [-7, 4], [8, 1],  [8, 2],  [6, 6],
+        [-6, 6], [8, 3],  [5, 7],  [-5, 7], [7, 5],  [-7, 5], [8, 4],  [6, 7],
+        [-6, 7], [7, 6],  [-7, 6], [8, 5],  [7, 7],  [-7, 7], [8, 6],  [8, 7]
+    ];
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int SpecialDistance(int index, int multiplier)
+    {
+        Span<sbyte> indexDistance = SpecialDistances[index];
+        int dist = indexDistance[0] + (multiplier * indexDistance[1]);
+        return dist > 1 ? dist : 1;
+    }
+
+    public static uint DecodeVariableLengthUint8(JxlBitReader reader)
+    {
+        if (reader.ReadBoolean())
+        {
+            uint bitCount = reader.ReadBits32(3u);
+
+            return bitCount == 0
+                ? 1u
+                : (reader.ReadBits32(bitCount) + (1u << (int)bitCount));
+        }
+
+        return 0u;
+    }
+
+    public static uint DecodeVariableLengthUint16(JxlBitReader reader)
+    {
+        if (reader.ReadBoolean())
+        {
+            uint bitCount = reader.ReadBits32(4u);
+
+            return bitCount == 0
+                ? 1u
+                : (reader.ReadBits32(bitCount) + (1u << (int)bitCount));
+        }
+
+        return 0u;
+    }
+
+    // NOTE: this method returns null on failure.
+    // If the return value is a valid IMemoryOwner object,
+    // then it succeeded.
+    public static IMemoryOwner<uint>? ReadHistogram(Configuration configuration, int precisionBits, JxlBitReader reader)
+    {
+        int range = 1 << precisionBits;
+        bool isSimpleCode = reader.ReadBoolean();
+
+        IMemoryOwner<uint> counts;
+
+        if (isSimpleCode)
+        {
+            Span<uint> symbols = [0, 0];
+
+            uint maxSymbol = 0u;
+            uint symCount = reader.ReadBits32(1u) + 1u;
+            for (uint i = 0; i < symCount; i++)
+            {
+                uint symbol = DecodeVariableLengthUint8(reader);
+                if (symbol > maxSymbol)
+                {
+                    maxSymbol = symbol;
+                }
+
+                symbols[(int)i] = symbol;
+            }
+
+            // Up to 256 items
+            counts = configuration.MemoryAllocator.Allocate<uint>((int)maxSymbol + 1);
+            Span<uint> countsSpan = counts.Memory.Span;
+
+            if (symCount == 1)
+            {
+                countsSpan[(int)symbols[0]] = (uint)range;
+            }
+            else
+            {
+                if (symbols[0] == symbols[1])
+                {
+                    counts.Dispose();
+                    throw new InvalidOperationException("The data is corrupt");
+                }
+
+                countsSpan[(int)symbols[0]] = reader.ReadBits32((uint)precisionBits);
+                countsSpan[(int)symbols[1]] = (uint)range - countsSpan[(int)symbols[0]];
+            }
+        }
+        else
+        {
+            bool isFlat = reader.ReadBoolean();
+
+            if (isFlat)
+            {
+                uint alphabetSize = DecodeVariableLengthUint8(reader) + 1u;
+                if (alphabetSize <= range)
+                {
+                    return null;
+                }
+
+                counts = JxlAnsHelper.CreateFlatHistogram(configuration, (int)alphabetSize, range);
+                return counts;
+            }
+
+            int upperBoundLog = JxlMath.FloorLog2Nonzero(JxlAnsConstants.AnsLogTableSize + 1);
+            int log = 0;
+
+            for (; log < upperBoundLog; log++)
+            {
+                bool logIncrementBit = reader.ReadBoolean();
+
+                if (!logIncrementBit)
+                {
+                    break;
+                }
+            }
+
+            uint shift = (reader.ReadBits32((uint)log) | (1u << log)) - 1u;
+
+            if (shift > JxlAnsConstants.AnsLogTableSize + 1)
+            {
+                throw new InvalidOperationException("Invalid shift");
+            }
+
+            uint length = DecodeVariableLengthUint8(reader) + 3u;
+
+            counts = configuration.MemoryAllocator.Allocate<uint>((int)length);
+            Span<uint> countsSpan = counts.Memory.Span;
+
+            uint totalCount = 0;
+
+            // The length variable can represent up to 258 elements,
+            // so it'd be more beneficial to allocate on the stack
+            // than pool an array.
+            Span<int> logCounts = stackalloc int[(int)length];
+
+            // stackalloc doesn't zero-init, so clear just in case.
+            logCounts.Clear();
+
+            int omitLog = -1;
+            int omitPos = -1;
+
+            // See comments for logCounts definition
+            Span<int> same = stackalloc int[(int)length];
+            same.Clear();
+
+            for (int i = 0; i < length; i++)
+            {
+                uint index = reader.PeekBits32(7);
+                reader.SkipBits32(HuffmanLookup[index][0]);
+                logCounts[i] = HuffmanLookup[index][1] - 1;
+
+                if (logCounts[i] == JxlAnsConstants.AnsLogTableSize)
+                {
+                    uint rleLength = DecodeVariableLengthUint8(reader);
+                    same[i] = (int)rleLength + 5;
+                    i += (int)rleLength + 3;
+                    continue;
+                }
+
+                if (logCounts[i] > omitLog)
+                {
+                    omitLog = logCounts[i];
+                    omitPos = i;
+                }
+            }
+
+            if (omitPos < 0)
+            {
+                counts.Dispose();
+                throw new InvalidOperationException("The histogram is corrupt or invalid.");
+            }
+
+            if (omitPos + 1 < length && logCounts[omitPos + 1] == JxlAnsConstants.AnsLogTableSize)
+            {
+                counts.Dispose();
+                throw new InvalidOperationException("The histogram is corrupt or invalid.");
+            }
+
+            int previous = 0;
+            int sameCount = 0;
+
+            for (int i = 0; i < length; i++)
+            {
+                if (same[i] > 0)
+                {
+                    sameCount = same[i] - 1;
+                    previous = i > 0 ? (int)countsSpan[i - 1] : 0;
+                }
+
+                if (sameCount > 0)
+                {
+                    countsSpan[i] = (uint)previous;
+                    sameCount--;
+                }
+                else
+                {
+                    int code = logCounts[i];
+
+                    if (i == omitPos || code < 0)
+                    {
+                        continue;
+                    }
+                    else if (shift == 0 || code == 0)
+                    {
+                        countsSpan[i] = 1u << code;
+                    }
+                    else
+                    {
+                        int bitCount = JxlAnsHelper.GetPopulationCountPrecision(code, (int)shift);
+                        countsSpan[i] = (1u << code) + (reader.ReadBits32((uint)bitCount) << (code - bitCount));
+                    }
+                }
+
+                totalCount += countsSpan[i];
+            }
+
+            countsSpan[omitPos] = (uint)range - totalCount;
+
+            if (countsSpan[omitPos] <= 0)
+            {
+                counts.Dispose();
+                throw new InvalidOperationException("The histogram count is incorrect.");
+            }
+        }
+
+        return counts;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsSymbolReader.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsSymbolReader.cs
new file mode 100644
index 0000000000..2de97c74f7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Ans/JxlAnsSymbolReader.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+
+internal sealed class JxlAnsSymbolReader
+{
+    private const int MaxCheckpointInterval = 512;
+
+    // Use class because the Lz77Window property uses 2KB memory
+    private sealed class Checkpoint
+    {
+        public uint State { get; set; }
+
+        public uint NumToCopy { get; set; }
+
+        public uint CopyPos { get; set; }
+
+        public uint NumDecoded { get; set; }
+
+        public uint[] Lz77Window { get; set; } = new uint[MaxCheckpointInterval];
+    }
+
+    private readonly JxlAnsEntry[] aliasTables = [];
+    private JxlHuffmanDecodingData huffmanData;
+    private bool usePrefixCode;
+    private uint state = AnsSignature << 16u;
+    private List<JxlAnsHybridUIntConfiguration> configs = [];
+    private int logAlphaSize;
+    private int logEntrySize;
+    private int entrySizeMinus1;
+
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBitReader.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBitReader.cs
new file mode 100644
index 0000000000..0f199f27cc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBitReader.cs
@@ -0,0 +1,170 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Represents a bitstream reader.
+/// </summary>
+internal class JxlBitReader(Stream stream)
+{
+    private ulong buffer;
+    private uint bufferRemainingBits;
+    private int pointer;
+
+    /// <summary>
+    /// Gets the total number of bits consumed.
+    /// </summary>
+    public long TotalBitsConsumed => ((long)this.pointer * 8) + (64 - this.bufferRemainingBits);
+
+    /// <summary>
+    /// Fetches a new buffer.
+    /// </summary>
+    private void RefillCore()
+    {
+        Span<byte> temp = stackalloc byte[8];
+        int bytesRead = stream.Read(temp);
+        if (bytesRead == 8)
+        {
+            this.buffer = BinaryPrimitives.ReadUInt64LittleEndian(temp);
+            this.bufferRemainingBits = 64u;
+            this.pointer += 8;
+        }
+        else
+        {
+            if (bytesRead == 0)
+            {
+                throw new EndOfStreamException();
+            }
+
+            ulong value = 0;
+            for (int i = 0; i < bytesRead; i++)
+            {
+                value |= (ulong)temp[i] << (8 * i);
+            }
+
+            this.buffer = value;
+            this.bufferRemainingBits = (uint)(bytesRead * 8);
+            this.pointer += bytesRead;
+        }
+    }
+
+    public void JumpToByteBoundary()
+    {
+        uint remainder = (uint)(this.TotalBitsConsumed % 8);
+
+        if (remainder == 0)
+        {
+            return;
+        }
+
+        if (this.ReadBits32(8u - remainder) != 0)
+        {
+            throw new InvalidDataException("Non-zero padding bits");
+        }
+    }
+
+    private void MaybeRefill()
+    {
+        if (this.bufferRemainingBits <= 0)
+        {
+            this.RefillCore();
+        }
+    }
+
+    private ulong ReadBits64Core(uint n, bool peek = false)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(n, 64u, nameof(n));
+        this.MaybeRefill();
+
+        if (n <= this.bufferRemainingBits)
+        {
+            ulong result = this.buffer & ((1UL << (int)n) - 1);
+
+            if (!peek)
+            {
+                this.buffer >>= (int)n;
+                this.bufferRemainingBits -= n;
+            }
+
+            return result;
+        }
+        else
+        {
+            uint bitsFromCurrent = this.bufferRemainingBits;
+            ulong part = this.buffer & ((1UL << (int)bitsFromCurrent) - 1);
+
+            this.buffer >>= (int)bitsFromCurrent;
+            this.bufferRemainingBits = 0;
+
+            this.RefillCore();
+
+            uint bitsFromNext = n - bitsFromCurrent;
+            ulong nextPart = this.buffer & ((1UL << (int)bitsFromNext) - 1);
+
+            if (!peek)
+            {
+                this.buffer >>= (int)bitsFromNext;
+                this.bufferRemainingBits -= bitsFromNext;
+            }
+
+            return part | (nextPart << (int)bitsFromCurrent);
+        }
+    }
+
+    private uint ReadBits32Core(uint n, bool peek = false)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(n, 32u, nameof(n));
+        this.MaybeRefill();
+
+        if (n <= this.bufferRemainingBits)
+        {
+            uint result = (uint)(this.buffer & ((1UL << (int)n) - 1));
+
+            if (!peek)
+            {
+                this.buffer >>= (int)n;
+                this.bufferRemainingBits -= n;
+            }
+
+            return result;
+        }
+        else
+        {
+            uint bitsFromCurrent = this.bufferRemainingBits;
+            uint part = (uint)(this.buffer & ((1UL << (int)bitsFromCurrent) - 1));
+
+            this.buffer >>= (int)bitsFromCurrent;
+            this.bufferRemainingBits = 0;
+
+            this.RefillCore();
+
+            uint bitsFromNext = n - bitsFromCurrent;
+            uint nextPart = (uint)(this.buffer & ((1UL << (int)bitsFromNext) - 1));
+
+            if (!peek)
+            {
+                this.buffer >>= (int)bitsFromNext;
+                this.bufferRemainingBits -= bitsFromNext;
+            }
+
+            return part | (nextPart << (int)bitsFromCurrent);
+        }
+    }
+
+    public virtual uint ReadBits32(uint bits) => this.ReadBits32Core(bits, peek: false);
+
+    public virtual uint PeekBits32(uint bits) => this.ReadBits32Core(bits, peek: true);
+
+    public virtual void SkipBits32(uint bits) => _ = this.ReadBits32(bits);
+
+    public virtual ulong ReadBits64(ulong bits) => this.ReadBits64Core((uint)bits, peek: false);
+
+    public virtual ulong PeekBits64(ulong bits) => this.ReadBits64Core((uint)bits, peek: true);
+
+    public virtual void SkipBits64(ulong bits) => _ = this.ReadBits64(bits);
+
+    public virtual bool ReadBoolean() => this.ReadBits32Core(1, peek: false) == 1;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxContentDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxContentDecoder.cs
new file mode 100644
index 0000000000..9d35ea85a9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxContentDecoder.cs
@@ -0,0 +1,104 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.IO.Compression;
+using SixLabors.ImageSharp.Formats.Jxl.IO;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Allows decoding and decompressing box data in JPEG XL
+/// container format.
+/// </summary>
+internal sealed class JxlBoxContentDecoder
+{
+    /// <summary>
+    /// Specifies how many bytes to read to fetch box data. This is ignored
+    /// if the box extends till EOF.
+    /// </summary>
+    private ulong boxSize;
+
+    /// <summary>
+    /// When true the box size is ignored and is unbounded - that is, keeps going
+    /// till the end of the file or stream.
+    /// </summary>
+    private bool boxExtendsTillEnd;
+
+    /// <summary>
+    /// This contains flags that determine whether the box is Brotli-compressed or
+    /// not.
+    /// </summary>
+    private JxlBoxCodingMode codingMode;
+
+    /// <summary>
+    /// Prepares parsing the box.
+    /// </summary>
+    /// <param name="codingMode">Specifies box compression.</param>
+    /// <param name="isUnbounded">Specifies whether or not the box size keeps going till the end of stream.</param>
+    /// <param name="size">Specifies the fixed size of the box when it is not unbounded.</param>
+    public void Initialize(JxlBoxCodingMode codingMode, bool isUnbounded, ulong size)
+    {
+        this.boxSize = size;
+        this.codingMode = codingMode;
+        this.boxExtendsTillEnd = isUnbounded;
+    }
+
+    /// <summary>
+    /// Prepares parsing the box.
+    /// </summary>
+    /// <param name="isBrotliCompressed">True if the box is compressed with Brotli. If uncompressed - false.</param>
+    /// <param name="isUnbounded">Specifies whether or not the box size keeps going till the end of stream.</param>
+    /// <param name="size">Specifies the fixed size of the box when it is not unbounded.</param>
+    public void Initialize(bool isBrotliCompressed, bool isUnbounded, ulong size)
+        => this.Initialize(
+            isBrotliCompressed ? JxlBoxCodingMode.Brotli : JxlBoxCodingMode.Uncompressed,
+            isUnbounded,
+            size);
+
+    public void Process(Stream stream, Stream writer)
+    {
+        byte[] cache = ArrayPool<byte>.Shared.Rent(16384);
+
+        if (this.codingMode == JxlBoxCodingMode.Brotli)
+        {
+            using BrotliStream brotli = new(stream, CompressionMode.Decompress, leaveOpen: true);
+
+            int bytesRead;
+            while ((bytesRead = brotli.Read(cache, 0, cache.Length)) > 0)
+            {
+                writer.Write(cache.AsSpan(0, bytesRead));
+            }
+        }
+        else
+        {
+            if (this.boxExtendsTillEnd)
+            {
+                int bytesRead;
+                while ((bytesRead = stream.Read(cache, 0, cache.Length)) > 0)
+                {
+                    writer.Write(cache.AsSpan(0, bytesRead));
+                }
+            }
+            else
+            {
+                ulong bytesLeft = this.boxSize;
+                while (bytesLeft > 0)
+                {
+                    int toRead = (int)Math.Min((ulong)cache.Length, bytesLeft);
+                    int bytesRead = stream.Read(cache, 0, toRead);
+
+                    if (bytesRead == 0)
+                    {
+                        throw new EndOfStreamException("Unexpected EOF while reading box content");
+                    }
+
+                    writer.Write(cache.AsSpan(0, bytesRead));
+                    bytesLeft -= (ulong)bytesRead;
+                }
+            }
+        }
+
+        ArrayPool<byte>.Shared.Return(cache);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxTypes.Generated.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxTypes.Generated.cs
new file mode 100644
index 0000000000..66bb65a4df
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxTypes.Generated.cs
@@ -0,0 +1,47 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Contains constants which represent JPEG XL container format
+/// box types as an integer.
+/// </summary>
+internal static class JxlBoxTypes
+{
+    /// <summary>
+    /// ftyp
+    /// </summary>
+    public const int FileType = 0x66747970;
+
+    /// <summary>
+    /// jxlc
+    /// </summary>
+    public const int JxlCodeStream = 0x6A786C63;
+
+    /// <summary>
+    /// jxlp
+    /// </summary>
+    public const int JxlPartialCodeStream = 0x6A786C70;
+
+    /// <summary>
+    /// brob
+    /// </summary>
+    public const int Brob = 0x62726F62;
+
+    /// <summary>
+    /// xml 
+    /// </summary>
+    public const int Xml = 0x786D6C20;
+
+    /// <summary>
+    /// Exif
+    /// </summary>
+    public const int Exif = 0x45786966;
+
+    /// <summary>
+    /// jxl 
+    /// </summary>
+    public const int Jxl = 0x6A786C20;
+
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxTypes.tt b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxTypes.tt
new file mode 100644
index 0000000000..92be8c00c1
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlBoxTypes.tt
@@ -0,0 +1,47 @@
+<#@ template language="C#" #>
+<#@ import namespace="System" #>
+<#@ import namespace="System.IO" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".Generated.cs" #>
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+<#
+    string[] boxTypes = new[]
+    {
+        "FileType=ftyp",
+        "JxlCodeStream=jxlc",
+        "JxlPartialCodeStream=jxlp",
+        "Brob=brob",
+        "Xml=xml ",
+        "Exif=Exif",
+        "Jxl=jxl "
+    };
+#>
+/// <summary>
+/// Contains constants which represent JPEG XL container format
+/// box types as an integer.
+/// </summary>
+internal static class JxlBoxTypes
+{
+<#
+    foreach (string boxType in boxTypes)
+    {
+        string[] split = boxType.Split('=');
+        string name = split[0];
+        string fourCC = split[1];
+        uint boxNum = ((uint)fourCC[0] << 24) |
+           ((uint)fourCC[1] << 16) |
+           ((uint)fourCC[2] << 8) |
+           fourCC[3];
+        string hex = $"0x{boxNum:X8}";
+#>
+    /// <summary>
+    /// <#= fourCC #>
+    /// </summary>
+    public const int <#= name #> = <#= hex #>;
+
+<# } #>
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlContextMapDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlContextMapDecoder.cs
new file mode 100644
index 0000000000..9695384b48
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlContextMapDecoder.cs
@@ -0,0 +1,109 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics.Tensors;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal static class JxlContextMapDecoder
+{
+    private const int MaxClusters = 256;
+
+    public static void VerifyContextMap(List<byte> contextMap, int numHTrees)
+    {
+        Span<bool> haveHTree = stackalloc bool[numHTrees];
+
+        int numFound = 0;
+
+        foreach (byte htree in contextMap)
+        {
+            if (htree >= numHTrees)
+            {
+                throw new InvalidOperationException("Invalid histogram index in context map");
+            }
+
+            if (!haveHTree[htree])
+            {
+                haveHTree[htree] = true;
+                numFound++;
+            }
+        }
+
+        if (numFound != numHTrees)
+        {
+            throw new InvalidOperationException("Incomplete context map");
+        }
+    }
+
+    public static void DecodeContextMap(Configuration configuration, List<byte> contextMap, ref int numHTrees, JxlBitReader input)
+    {
+        // True - simple context map, without any ANS entropy coding,
+        // false - the context map uses entropy coding and LZ77.
+        bool isSimpleContextMap = input.ReadBoolean();
+
+        Span<byte> cmSpan = CollectionsMarshal.AsSpan(contextMap);
+
+        if (isSimpleContextMap)
+        {
+            uint bitsPerEntry = input.ReadBits32(2);
+
+            if (bitsPerEntry != 0)
+            {
+                for (int i = 0; i < cmSpan.Length; i++)
+                {
+                    cmSpan[i] = (byte)input.ReadBits32(bitsPerEntry);
+                }
+            }
+            else
+            {
+                // No context map at all
+                cmSpan.Clear();
+            }
+        }
+        else
+        {
+            bool useMtf = input.ReadBoolean(); // use Move to Front transform?
+            JxlAnsCode ansCode = new();
+            List<byte> sinkContextMap = [];
+
+            if (!JxlAnsReader.DecodeHistograms(configuration, input, 1, ansCode, sinkContextMap, contextMap.Count <= 2))
+            {
+                throw new InvalidOperationException("Context map histogram couldn't be decoded");
+            }
+
+            JxlAnsSymbolReader ans = JxlAnsSymbolReader.Create(ansCode, input);
+
+            int i = 0;
+            int maxSymbols = 0;
+
+            while (i < cmSpan.Length)
+            {
+                uint sym = ans.ReadHybridUInt(true, 0, input, sinkContextMap);
+                maxSymbols = sym > maxSymbols ? (int)sym : maxSymbols;
+                cmSpan[i] = (byte)sym;
+                i++;
+            }
+
+            if (maxSymbols >= MaxClusters)
+            {
+                throw new InvalidOperationException("Invalid cluster ID");
+            }
+
+            if (!ans.CheckAnsFinalState())
+            {
+                throw new InvalidOperationException("Invalid context map");
+            }
+
+            if (useMtf)
+            {
+                JxlInverseMtf.InverseMoveToFrontTransform(cmSpan);
+            }
+        }
+
+        numHTrees = TensorPrimitives.Max((ReadOnlySpan<byte>)cmSpan) + 1;
+        VerifyContextMap(contextMap, numHTrees);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderCache.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderCache.cs
new file mode 100644
index 0000000000..8e50433369
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderCache.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Constants used by decoder cache.
+/// </summary>
+internal static class JxlDecoderCache
+{
+    public const int SigmaBorder = 1;
+
+    public const int SigmaPadding = 2;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderCore.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderCore.cs
new file mode 100644
index 0000000000..9fefcde018
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderCore.cs
@@ -0,0 +1,2723 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.IO;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Container;
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Internal decoder for JPEG XL.
+/// </summary>
+internal sealed class JxlDecoderCore : ImageDecoderCore, IDisposable
+{
+    private const long NumBuffersLimit = 1 << 20;
+
+    /// <summary>
+    /// Current stage of the decoding pipeline.
+    /// </summary>
+    private JxlDecoderStage decoderStage;
+
+    /// <summary>
+    /// Status of whether or not has the signature been parsed.
+    /// </summary>
+    private bool gotSignature;
+
+    /// <summary>
+    /// Did we parse the final code stream?
+    /// </summary>
+    private bool lastCodestreamSeen;
+
+    /// <summary>
+    /// Did we parse the signature of the code stream?
+    /// </summary>
+    private bool gotCodestreamSignature;
+
+    /// <summary>
+    /// Did we parse basic JXL information?
+    /// </summary>
+    private bool gotBasicInfo;
+
+    /// <summary>
+    /// Did we parse the transform data?
+    /// </summary>
+    private bool gotTransformData;
+
+    /// <summary>
+    /// Did we parse all the codestream metadata headers?
+    /// </summary>
+    private bool gotAllHeaders;
+
+    /// <summary>
+    /// Are we decoding pixels now?
+    /// </summary>
+    private bool postHeaders;
+
+    /// <summary>
+    /// ICC profile for JPEG XL metadata, if present.
+    /// </summary>
+    private IccProfile? iccProfile;
+
+    /// <summary>
+    /// The frame index box, if present.
+    /// </summary>
+    private JxlDecoderFrameIndexBox? frameIndexBox;
+
+    /// <summary>
+    /// Did we get the preview image, or determined we cannot get it or there isn't any?
+    /// </summary>
+    private bool gotPreviewImage;
+
+    /// <summary>
+    /// Is this a preview frame?
+    /// </summary>
+    private bool previewFrame;
+
+    private long filePosition;
+
+    /// <summary>
+    /// Offset where box contents start.
+    /// </summary>
+    private long boxContentsBegin;
+
+    /// <summary>
+    /// Offset where box contents end.
+    /// </summary>
+    private long boxContentsEnd;
+
+    /// <summary>
+    /// boxContentsEnd - boxContentsBegin
+    /// </summary>
+    private long boxContentsSize;
+
+    /// <summary>
+    /// Total size of the box in bytes.
+    /// </summary>
+    private long boxSize;
+
+    /// <summary>
+    /// Size of the headers in bytes.
+    /// </summary>
+    private long headerSize;
+
+    /// <summary>
+    /// Are box contents unbounded?
+    /// </summary>
+    private bool boxContentsUnbounded;
+
+    /// <summary>
+    /// Type of the box currently being decoded.
+    /// </summary>
+    private JxlBoxType boxType;
+
+    /// <summary>
+    /// Underlying type for brob boxes.
+    /// </summary>
+    private JxlBoxType boxDecodedType;
+
+    private bool boxEvent;
+
+    /// <summary>
+    /// Should box contents be decompressed (using Brotli)?
+    /// </summary>
+    private bool decompressBoxes;
+
+    /// <summary>
+    /// Should the output buffer for the box be set?
+    /// </summary>
+    private bool boxOutBufferSet;
+
+    /// <summary>
+    /// Should the output buffer for the current box be set?
+    /// </summary>
+    private bool boxOutBufferSetCurrentBox;
+
+    /// <summary>
+    /// Output buffer for the current box.
+    /// </summary>
+    private IMemoryOwner<byte>? boxOutputBuffer;
+
+    /// <summary>
+    /// Size of the output buffer.
+    /// </summary>
+    private long boxOutBufferSize;
+
+    /// <summary>
+    /// Offset of start of box output buffer.
+    /// </summary>
+    private long boxOutBufferBegin;
+
+    /// <summary>
+    /// Current offset of start of box output buffer.
+    /// </summary>
+    private long boxOutBufferPos;
+
+    /// <summary>
+    /// Should orientation be preserved?
+    /// </summary>
+    private bool keepOrientation;
+
+    /// <summary>
+    /// Should alpha channel be unpremultiplied?
+    /// </summary>
+    private bool unpremultiplyAlpha;
+
+    private bool renderSpotcolors;
+
+    private bool coalescing;
+
+    /// <summary>
+    /// Custom intensity target.
+    /// </summary>
+    private float desiredIntensityTarget;
+
+    private int eventsWanted;
+
+    private int originalEventsWanted;
+
+    private long basicInfoSizeHint;
+
+    /// <summary>
+    /// Is container format present?
+    /// </summary>
+    private bool haveContainer;
+
+    /// <summary>
+    /// Total number of boxes.
+    /// </summary>
+    private long boxCount;
+
+    /// <summary>
+    /// The level of progressive detail in frame coding.
+    /// </summary>
+    private JxlProgressiveDetail progressiveDetail = JxlProgressiveDetail.Dc;
+
+    /// <summary>
+    /// Progressive detail of current frame.
+    /// </summary>
+    private JxlProgressiveDetail frameProgressiveDetail;
+
+    /// <summary>
+    /// The intended downsampling ratio for the current progression step.
+    /// </summary>
+    private long downsamplingTarget;
+
+    /// <summary>
+    /// True if the image output buffer or callback was set.
+    /// </summary>
+    private bool imageOutBufferSet;
+
+    /// <summary>
+    /// Size of the image output buffer.
+    /// </summary>
+    private long imageOutputSize;
+
+    /// <summary>
+    /// Output data for extra channels.
+    /// </summary>
+    private readonly List<JxlExtraChannelOutput> extraChannelOutputs = [];
+
+    /// <summary>
+    /// Codec metadata if present.
+    /// </summary>
+    private JxlCodecMetadata? metadata;
+
+    /// <summary>
+    /// Image metadata if present.
+    /// </summary>
+    private JxlImageMetadata? imageMetadata;
+
+    /// <summary>
+    /// The image bundle.
+    /// </summary>
+    private JxlImageBundle? imageBundle;
+
+    /// <summary>
+    /// State for passes decoder.
+    /// </summary>
+    private JxlPassesDecoderState? passesState;
+
+    /// <summary>
+    /// State for frame decoder.
+    /// </summary>
+    private JxlFrameDecoder? frameDecoder;
+
+    /// <summary>
+    /// The next section.
+    /// </summary>
+    private long nextSection;
+
+    private readonly List<byte> sectionProcessed = [];
+
+    /// <summary>
+    /// The frame header, if present.
+    /// </summary>
+    private JxlFrameHeader? frameHeader;
+
+    /// <summary>
+    /// Remaining frame size.
+    /// </summary>
+    private long remainingFrameSize;
+
+    /// <summary>
+    /// Stage of the decoding pipeline.
+    /// </summary>
+    private JxlFrameStage frameStage;
+
+    /// <summary>
+    /// Has progression for DC frames been completed?
+    /// </summary>
+    private bool dcFrameProgressionDone;
+
+    private bool isLastOfStill;
+
+    /// <summary>
+    /// Is the currently processed frame the last of the codestream?
+    /// </summary>
+    private bool isLastTotal;
+
+    /// <summary>
+    /// How many frames should be skipped?
+    /// </summary>
+    private int skipFrames;
+
+    /// <summary>
+    /// Is active frame being skipped?
+    /// </summary>
+    private bool skippingFrame;
+
+    private int internalFrames;
+
+    private int externalFrames;
+
+    /// <summary>
+    /// All frame reference.s
+    /// </summary>
+    private readonly List<JxlFrameReference> frameReferences = [];
+
+    private readonly List<int> frameExternalToInternal = [];
+
+    private readonly List<byte> frameRequired = [];
+
+    /// <summary>
+    /// Codestream input data is temporarily copied here.
+    /// </summary>
+    private JxlMemoryWriter? codestreamCopy;
+
+    private long codestreamUnconsumed;
+
+    /// <summary>
+    /// Position in the codestreamCopy vector.
+    /// </summary>
+    private long codestreamPos;
+
+    /// <summary>
+    /// Number of remaining bits in the codestream copy.
+    /// </summary>
+    private long codestreamBitsAhead;
+
+    /// <summary>
+    /// Stage of the box parsing pipeline.
+    /// </summary>
+    private JxlBoxStage boxStage;
+
+    /// <summary>
+    /// FTYP minor-version.
+    /// <list type="bullet">
+    ///   <item>0 - jxlp must be in order</item>
+    ///   <item>1 - OOO jxlp allowed</item>
+    /// </list>
+    /// </summary>
+    private int jxlFileFormatVersion;
+
+    /// <summary>
+    /// Counter of next expected jxlp box.
+    /// </summary>
+    private int nextJxlpIndex;
+
+    /// <summary>
+    /// OOO jxlp payloads keyed by counter. Keys are: codestream bytes without
+    /// 4byte header, and is_last.
+    /// </summary>
+    private readonly Dictionary<int, JxlOooEntry> jxlpOooBuffer = [];
+
+    private long jxlpOooBufferTotal;
+
+    private int bufferingJxlpIndex;
+
+    private bool bufferingJxlpIsLast;
+
+    /// <summary>
+    /// Decompresses box contents.
+    /// </summary>
+    private readonly JxlBoxContentDecoder? boxContentDecoder;
+
+    private readonly JxlBoxContentDecoder? metadataDecoder;
+
+    /// <summary>
+    /// Raw bytes for EXIF metadata.
+    /// </summary>
+    private IMemoryOwner<byte>? exifMetadata;
+
+    /// <summary>
+    /// Raw bytes for XMP metadata.
+    /// </summary>
+    private IMemoryOwner<byte>? xmpMetadata;
+
+    /// <summary>
+    /// State of EXIF storage. 0 - not stored,
+    /// 1 - currently stored, 2 - finished.
+    /// </summary>
+    private int storeExif;
+
+    /// <summary>
+    /// State of XMP storage. 0 - not stored,
+    /// 1 - currently stored, 2 - finished.
+    /// </summary>
+    private int storeXmp;
+
+    /// <summary>
+    /// Position in the output buffer for JPEG
+    /// reconstruction.
+    /// </summary>
+    private long reconstructionOutputBufferPos;
+
+    /// <summary>
+    /// EXIF size for JPEG reconstruction.
+    /// </summary>
+    private long reconstructionExifSize;
+
+    /// <summary>
+    /// XMP size for JPEG reconstruction.
+    /// </summary>
+    private long reconstructionXmpSize;
+
+    /// <summary>
+    /// Stage of reconstruction pipeline.
+    /// </summary>
+    private JpegReconstructionStage reconstructionOutputJpeg;
+
+    /// <summary>
+    /// Next input data.
+    /// </summary>
+    private IMemoryOwner<byte>? nextInput;
+
+    private long availableInput;
+
+    private bool inputClosed;
+
+    /// <summary>
+    /// Output image buffer.
+    /// </summary>
+    private Stream? imageOutBuffer;
+
+    /// <summary>
+    /// Callback to initialize image output.
+    /// </summary>
+    private JxlImageOutputInitializerCallback? imageOutputInitCallback;
+
+    /// <summary>
+    /// Callback to run image output.
+    /// </summary>
+    private JxlImageOutputRunCallback? imageOutputRunCallback;
+
+    /// <summary>
+    /// Callback to dispose image output.
+    /// </summary>
+    private JxlImageOutputDestroyCallback? imageOutputDestroyCallback;
+
+    /// <summary>
+    /// Bit depth for image output.
+    /// </summary>
+    private JxlBitDepthMetadata imageOutputBitDepth = new();
+
+    public JxlDecoderCore(DecoderOptions options)
+        : base(options)
+        => this.Reset();
+
+    public long SizeHintBasicInfo => this.gotBasicInfo ? 0 : this.basicInfoSizeHint;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether orientation should be kept.
+    /// </summary>
+    public bool KeepOrientation
+    {
+        get => this.keepOrientation;
+        set
+        {
+            this.BeforeUpdateState(nameof(this.KeepOrientation));
+            this.keepOrientation = value;
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to unpremultiply RGB values
+    /// by the alpha channel.
+    /// </summary>
+    public bool UnpremultiplyAlpha
+    {
+        get => this.unpremultiplyAlpha;
+        set
+        {
+            this.BeforeUpdateState(nameof(this.UnpremultiplyAlpha));
+            this.unpremultiplyAlpha = value;
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether spotcolors (special inks used in printing)
+    /// are rendered in the output.
+    /// </summary>
+    public bool RenderSpotcolors
+    {
+        get => this.renderSpotcolors;
+        set
+        {
+            this.BeforeUpdateState(nameof(this.RenderSpotcolors));
+            this.renderSpotcolors = value;
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether multiple frames (especially zero-duration frames)
+    /// have to be merged into a single image.
+    /// </summary>
+    public bool Coalescing
+    {
+        get => this.coalescing;
+        set
+        {
+            this.BeforeUpdateState(nameof(this.Coalescing));
+            this.coalescing = value;
+        }
+    }
+
+    /// <summary>
+    /// Gets the dimensions of the current image buffer.
+    /// </summary>
+    public Size CurrentDimensions
+    {
+        get
+        {
+            int width;
+            int height;
+
+            if (this.frameHeader?.IsPreviewFrame == true)
+            {
+                width = this.metadata!.GetOrientedPreviewXSize(this.keepOrientation);
+                height = this.metadata!.GetOrientedPreviewYSize(this.keepOrientation);
+            }
+            else
+            {
+                width = this.metadata!.GetOrientedXSize(this.keepOrientation);
+                height = this.metadata!.GetOrientedYSize(this.keepOrientation);
+
+                if (!this.coalescing)
+                {
+                    JxlFrameDimensions dim = this.frameHeader!.FrameDimensions;
+
+                    width = dim.XSizeUpsampled;
+                    height = dim.YSizeUpsampled;
+
+                    if (!this.keepOrientation && this.metadata.ImageMetadata!.Orientation > 4)
+                    {
+                        RuntimeUtility.Swap(ref width, ref height);
+                    }
+                }
+            }
+
+            return new Size(width, height);
+        }
+    }
+
+    /// <summary>
+    /// Stage of the decoder pipeline.
+    /// </summary>
+    private enum JxlDecoderStage : byte
+    {
+        /// <summary>
+        /// Initialized but hasn't decoded yet.
+        /// </summary>
+        Initialized,
+
+        /// <summary>
+        /// Decoding right now.
+        /// </summary>
+        Started,
+
+        /// <summary>
+        /// Code stream done, but other boxes could still occur.
+        /// </summary>
+        CodeStreamFinished,
+
+        /// <summary>
+        /// Decoding failed and the decoder is no longer usable.
+        /// </summary>
+        Error
+    }
+
+    /// <summary>
+    /// Identifies the signature of the JPEG XL file.
+    /// </summary>
+    private enum JxlSignature : byte
+    {
+        /// <summary>
+        /// Error status indicating not enough bytes to detect the signature.
+        /// </summary>
+        NotEnoughBytes,
+
+        /// <summary>
+        /// A JPEG XL code stream.
+        /// </summary>
+        CodeStream,
+
+        /// <summary>
+        /// The signature is invalid.
+        /// </summary>
+        Invalid,
+
+        /// <summary>
+        /// Container format.
+        /// </summary>
+        Container
+    }
+
+    /// <summary>
+    /// Frame stage for this decoder.
+    /// </summary>
+    private enum JxlFrameStage : byte
+    {
+        /// <summary>
+        /// Frame header should be parsed.
+        /// </summary>
+        Header,
+
+        /// <summary>
+        /// TOC should be parsed.
+        /// </summary>
+        Toc,
+
+        /// <summary>
+        /// Full pixels should be parsed.
+        /// </summary>
+        Full
+    }
+
+    /// <summary>
+    /// Stage of the box parsing pipeline.
+    /// </summary>
+    private enum JxlBoxStage : byte
+    {
+        /// <summary>
+        /// Box header of the next box.
+        /// </summary>
+        Header,
+
+        /// <summary>
+        /// File type box.
+        /// </summary>
+        Ftyp,
+
+        /// <summary>
+        /// Box with skipped contents.
+        /// </summary>
+        Skip,
+
+        /// <summary>
+        /// Code stream boxes.
+        /// </summary>
+        CodeStream,
+
+        /// <summary>
+        /// Extra header of partial code stream box.
+        /// </summary>
+        PartialCodeStream,
+
+        /// <summary>
+        /// Out-of-order jxlp box payload.
+        /// </summary>
+        BufferingJxlp,
+
+        /// <summary>
+        /// Jpeg reconstruction box.
+        /// </summary>
+        JpegReconstruction
+    }
+
+    /// <summary>
+    /// Reconstruction stage for JPEG images.
+    /// </summary>
+    private enum JpegReconstructionStage : byte
+    {
+        /// <summary>
+        /// Don't output anything.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Set metadata to the JPEG data.
+        /// </summary>
+        SetMetadata,
+
+        /// <summary>
+        /// Outputting the JPEG bytes.
+        /// </summary>
+        Output
+    }
+
+    /// <summary>
+    /// A single frame index box entry. See <see cref="JxlDecoderFrameIndexBox"/>.
+    /// </summary>
+    private struct JxlDecoderFrameIndexBoxEntry
+    {
+        /// <summary>
+        /// Offset of start byte of this frame compared to start
+        /// byte of previous frame.
+        /// </summary>
+        public long Offset;
+
+        /// <summary>
+        /// Duration in ticks between the start of this frame and the start of the next frame.
+        /// </summary>
+        public int DurationInTicks;
+
+        /// <summary>
+        /// Amount of frames.
+        /// </summary>
+        public int AmountOfFrames;
+    }
+
+    // This is a class not a struct. This is so we can
+    // assign its values from an array access. Like this:
+    //  this.frameReferences[(int)internalIndex].Reference = ...
+    // where this.frameReferences = JxlFrameReference[].
+    private sealed class JxlFrameReference(int reference, int savedAs)
+    {
+        public int Reference { get; set; } = reference;
+
+        public int SavedAs { get; set; } = savedAs;
+    }
+
+    /// <summary>
+    /// A frame index box.
+    /// </summary>
+    private sealed class JxlDecoderFrameIndexBox
+    {
+        /// <summary>
+        /// Gets or sets all entries within this frame index box.
+        /// </summary>
+        public List<JxlDecoderFrameIndexBoxEntry> Entries { get; set; } = [];
+
+        /// <summary>
+        /// Gets the number of entries.
+        /// </summary>
+        public int Count => this.Entries.Count;
+
+        /// <summary>
+        /// Gets or sets the numerator. (Default: 1)
+        /// </summary>
+        public int Numerator { get; set; } = 1;
+
+        /// <summary>
+        /// Gets or sets the denominator. (Default: 1000)
+        /// </summary>
+        public int Denominator { get; set; } = 1000;
+
+        /// <summary>
+        /// Adds a new frame.
+        /// </summary>
+        /// <param name="offset">Offset to first byte.</param>
+        /// <param name="ticks">Duration in ticks.</param>
+        /// <param name="frames">Amount of frames.</param>
+        public void AddFrame(long offset, int ticks, int frames) => this.Entries.Add(new JxlDecoderFrameIndexBoxEntry()
+        {
+            Offset = offset,
+            AmountOfFrames = frames,
+            DurationInTicks = ticks
+        });
+    }
+
+    private sealed record JxlExtraChannelOutput(JxlPixelFormat Format, object? Buffer, long BufferSize);
+
+    private sealed record JxlOooEntry(byte[] CodestreamBytes, bool IsLast);
+
+    public void Dispose()
+    {
+        // RewindDecodingState resets everything,
+        // including disposal of streams.
+        this.RewindDecodingState();
+
+        // Streams like input and output streams may
+        // be unmanaged.
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Ensures that the coordinates are not out of bounds.
+    /// </summary>
+    /// <param name="a">First coordinate</param>
+    /// <param name="b">Second coordinate</param>
+    /// <param name="size">Image width</param>
+    /// <returns>Boolean indicating whether the coordinates are out of bounds</returns>
+    private static bool IsOutOfBounds(int a, int b, int size)
+    {
+        long position = a + b;
+
+        return position > size || position < a;
+    }
+
+    private static int InitialBasicInfoSizeHint()
+    {
+        const int containerHeaderSize = 48;
+        const int maxCodestreamBasicInfoSize = 50;
+        return containerHeaderSize + maxCodestreamBasicInfoSize;
+    }
+
+    private static JxlSignature DetectSignature(Stream buffer)
+    {
+        int firstByte = buffer.ReadByte();
+        if (firstByte == -1)
+        {
+            throw new EndOfStreamException();
+        }
+
+        if (firstByte == 0xFF)
+        {
+            int secondByte = buffer.ReadByte();
+            if (secondByte == -1)
+            {
+                throw new EndOfStreamException();
+            }
+
+            if (secondByte == JxlShared.CodestreamMarker)
+            {
+                return JxlSignature.CodeStream;
+            }
+            else
+            {
+                return JxlSignature.Invalid;
+            }
+        }
+
+        // Container?
+        if (firstByte == 0)
+        {
+            Span<byte> signatureBox = stackalloc byte[JxlShared.SignatureBox.Length];
+            buffer.ReadExactly(signatureBox);
+
+            if (signatureBox.SequenceEqual(JxlShared.SignatureBox))
+            {
+                return JxlSignature.Container;
+            }
+            else
+            {
+                return JxlSignature.Invalid;
+            }
+        }
+
+        // Signature is invalid
+        return JxlSignature.Invalid;
+    }
+
+    private static uint BitsPerChannel(JxlDataType dataType)
+        => dataType switch
+        {
+            JxlDataType.Byte => 8,
+            JxlDataType.UInt16 or JxlDataType.Half => 16,
+            JxlDataType.Single => 32,
+            _ => 0
+        };
+
+    private static uint GetBitDepth(JxlBitDepth bitDepth, JxlImageMetadata metadata, JxlPixelFormat pixelFormat)
+    {
+        if (bitDepth.Type == JxlBitDepthType.FromPixelFormat)
+        {
+            return BitsPerChannel(pixelFormat.DataType);
+        }
+        else if (bitDepth.Type == JxlBitDepthType.FromCodeStream)
+        {
+            return metadata.BitDepth!.BitsPerSample;
+        }
+        else if (bitDepth.Type == JxlBitDepthType.Custom)
+        {
+            return bitDepth.BitsPerSample;
+        }
+
+        return 0;
+    }
+
+    private List<int> GetFrameDependencies(int index, Span<JxlFrameReference> references)
+    {
+        DebugGuard.MustBeLessThan(index, references.Length, nameof(index));
+
+        const int storageNum = 8;
+
+        List<int> result = [];
+        int invalid = references.Length;
+        List<int>[] storage = new List<int>[storageNum];
+
+        for (int s = 0; s < storageNum; s++)
+        {
+            storage[s] = new List<int>(references.Length);
+            int mask = 1 << s;
+            int id = invalid;
+
+            for (int i = 0; i < references.Length; i++)
+            {
+                if ((references[i].SavedAs & mask) != 0)
+                {
+                    id = i;
+                }
+
+                storage[s][i] = id;
+            }
+        }
+
+        Span<byte> seen = stackalloc byte[index + 1];
+        seen.Clear();   // All values are explicitly cleared in reference source
+
+        Stack<int> stack = [];
+        stack.Push(index);
+        seen[index] = 1;
+
+        for (int s = 0; s < storageNum; s++)
+        {
+            int frameRef = storage[s][index];
+
+            if (frameRef == invalid)
+            {
+                continue;
+            }
+
+            if (seen[frameRef] != 0)
+            {
+                continue;
+            }
+
+            stack.Push(frameRef);
+            seen[frameRef] = 1;
+            result.Add(frameRef);
+        }
+
+        while (stack.Count > 0)
+        {
+            int frameIndex = stack.Pop();
+            if (frameIndex == 0)
+            {
+                continue;
+            }
+
+            for (int s = 0; s < storageNum; s++)
+            {
+                int mask = 1 << s;
+
+                if ((references[frameIndex].Reference & mask) == 0)
+                {
+                    continue;
+                }
+
+                int frameRef = storage[s][frameIndex - 1];
+                if (frameRef == invalid)
+                {
+                    continue;
+                }
+
+                if (seen[frameRef] != 0)
+                {
+                    continue;
+                }
+
+                stack.Push(frameRef);
+                seen[frameRef] = 1;
+                result.Add(frameRef);
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Checks if the buffer of specified length can be added.
+    /// </summary>
+    /// <param name="length">Length of the desired buffer.</param>
+    /// <returns>
+    /// True if buffers with such lengths can be added; false if they
+    /// exceed the size limit.
+    /// </returns>
+    public bool CanAddBuffer(long length)
+    {
+        const long bufferLimit = 1 << 48;
+        return length < bufferLimit &&
+            (length + this.jxlpOooBufferTotal + (this.codestreamCopy?.AsMemory().Length ?? 0)) < bufferLimit;
+    }
+
+    public bool TryInjectNextBufferedJxlpBox()
+    {
+        if (!this.jxlpOooBuffer.TryGetValue(this.nextJxlpIndex, out JxlOooEntry? value))
+        {
+            return false;
+        }
+
+        if (value == this.jxlpOooBuffer.Last().Value)
+        {
+            return true;
+        }
+
+        value.Deconstruct(out byte[] data, out bool isLast);
+        int length = data.Length;
+
+        this.codestreamCopy!.Write(data);
+
+        if (isLast)
+        {
+            this.lastCodestreamSeen = true;
+        }
+
+        _ = this.jxlpOooBuffer.Remove(this.nextJxlpIndex++);
+
+        this.jxlpOooBufferTotal -= length;
+
+        return true;
+    }
+
+    /// <summary>
+    /// Returns true if the jbrd box needs exif or xmp.
+    /// </summary>
+    /// <returns>JBRD needs more boxes - true, otherwise false.</returns>
+    public bool JbrdNeedsMoreBoxes() =>
+        (this.storeExif < 2 && this.reconstructionExifSize > 0)
+        || (this.storeXmp < 2 && this.reconstructionXmpSize > 0);
+
+    /// <summary>
+    /// Moves the input data forward by size bytes.
+    /// </summary>
+    /// <param name="size">Number of bytes to advance.</param>
+    /// <exception cref="InvalidOperationException">Thrown if advancing out of bounds.</exception>
+    public void AdvanceInput(long size)
+    {
+        if (this.availableInput < size)
+        {
+            throw new InvalidOperationException("Attempting to advance out of bounds");
+        }
+
+        this.nextInput += size;
+        this.filePosition += size;
+        this.availableInput -= size;
+    }
+
+    /// <summary>
+    /// Returns number of available bytes in the code stream.
+    /// </summary>
+    /// <returns>
+    /// Number of available code stream bytes.
+    /// </returns>
+    public long AvailableCodeStream()
+    {
+        long avail = this.availableInput;
+
+        if (!this.boxContentsUnbounded)
+        {
+            avail = Math.Min(avail, this.boxContentsEnd - this.filePosition);
+        }
+
+        return avail;
+    }
+
+    /// <summary>
+    /// Ensures that the copy of the code stream is present.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the copy is missing or null.
+    /// </exception>
+    private void EnsureCodeStreamCopy()
+    {
+        if (this.codestreamCopy is null)
+        {
+            throw new InvalidOperationException("Copy of the code stream is missing");
+        }
+    }
+
+    /// <summary>
+    /// Moves forward by 'size' bytes in the code stream.
+    /// </summary>
+    /// <param name="size">Number of bytes to advance.</param>
+    public void AdvanceCodeStream(long size)
+    {
+        this.EnsureCodeStreamCopy();
+        long avail = this.AvailableCodeStream();
+
+        if (this.codestreamCopy!.Length == 0)
+        {
+            if (size <= avail)
+            {
+                // We have >= size bytes available, so
+                // advancing won't be out of bounds.
+                this.AdvanceInput(size);
+            }
+            else
+            {
+                // We have a limited amount of bytes for the
+                // code stream, and advancing by size would be
+                // out of bounds. So limit the value.
+                this.codestreamPos = size - avail;
+                this.AdvanceInput(avail);
+            }
+        }
+        else
+        {
+            this.codestreamPos += size;
+            if (this.codestreamPos + this.codestreamUnconsumed >= this.codestreamCopy.Length)
+            {
+                long advance = Math.Min(
+                    this.codestreamUnconsumed,
+                    this.codestreamUnconsumed + this.codestreamPos - this.codestreamCopy.Length);
+
+                this.AdvanceInput(advance);
+
+                this.codestreamPos -= Math.Min(this.codestreamPos, this.codestreamCopy.Length);
+                this.codestreamUnconsumed = 0;
+
+                // Now we want to clear the code stream copy...
+                this.codestreamCopy.Dispose();
+                this.codestreamCopy = new(this.Options.Configuration.MemoryAllocator);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Attempts to expand the buffer.
+    /// </summary>
+    /// <returns>Status of requesting more input.</returns>
+    public bool TryRequestMoreInput()
+    {
+        this.EnsureCodeStreamCopy();
+
+        if (this.codestreamCopy!.Length > 0)
+        {
+            long avail = this.AvailableCodeStream();
+
+            if (!this.CanAddBuffer(avail))
+            {
+                return false;
+            }
+
+            using IMemoryOwner<byte> codestreamPending = this.Options.Configuration.MemoryAllocator.Allocate<byte>((int)avail);
+            this.codestreamCopy.Write(codestreamPending.Memory.Span);
+        }
+        else
+        {
+            this.AdvanceInput(this.codestreamUnconsumed);
+            this.codestreamUnconsumed = 0;
+        }
+
+        return true;
+    }
+
+    public Memory<byte>? TryGetCodestreamInput()
+    {
+        if (this.codestreamCopy is null)
+        {
+            return null;
+        }
+
+        if (this.codestreamCopy.Length == 0 && this.codestreamPos > 0)
+        {
+            long avail = this.AvailableCodeStream();
+            long skip = Math.Min(this.codestreamPos, avail);
+            this.Skip(skip);
+            this.codestreamPos -= skip;
+
+            if (this.codestreamPos > 0)
+            {
+                _ = this.TryRequestMoreInput();
+                return null;
+            }
+        }
+
+        if (this.codestreamPos > this.codestreamCopy.Length)
+        {
+            throw new InvalidOperationException("Codestream position > length of codestream copy");
+        }
+
+        if (this.codestreamUnconsumed > this.codestreamCopy.Length)
+        {
+            throw new InvalidOperationException("Codestream unconsumed > length of codestream copy");
+        }
+
+        long availCodestream = this.AvailableCodeStream();
+
+        if (this.codestreamCopy.Length == 0)
+        {
+            if (availCodestream == 0)
+            {
+                _ = this.TryRequestMoreInput();
+                return null;
+            }
+
+            return this.nextInput!.Memory[..(int)availCodestream];
+        }
+        else
+        {
+            if (!this.CanAddBuffer(availCodestream))
+            {
+                return null;
+            }
+
+            this.codestreamCopy.Write(this.nextInput!.Memory.Span.Slice((int)this.codestreamUnconsumed, (int)(availCodestream - this.codestreamUnconsumed)));
+
+            this.codestreamUnconsumed = availCodestream;
+
+            return this.codestreamCopy.AsMemory();
+        }
+    }
+
+    /// <summary>
+    /// Returns true if the decoder can continue using code stream input.
+    /// </summary>
+    /// <returns>True if the decoder can use code stream input. Otherwise false.</returns>
+    public bool CanUseMoreCodestreamInput() => this.decoderStage != JxlDecoderStage.CodeStreamFinished;
+
+    /// <summary>
+    /// Checks if width * height can be represented safely as a
+    /// positive integer after rounding the width up to the next
+    /// multiple of 32.
+    /// </summary>
+    /// <param name="width">Input width.</param>
+    /// <param name="height">Input height.</param>
+    /// <returns>
+    /// Boolean indicating whether the padded image dimensions fit
+    /// within a signed 32-bit integer when calculating the total
+    /// pixel count.
+    /// </returns>
+    /// <remarks>
+    /// Negative values aren't rejected, but will produce incorrect
+    /// results. This method is meant to be used with positive values only.
+    /// </remarks>
+    public static bool CheckSizeLimit(int width, int height)
+    {
+        if (width == 0 || height == 0)
+        {
+            return true;
+        }
+
+        int paddedWidth = JxlMath.DivCeil(width, 32) * 32;
+
+        if (paddedWidth < width)
+        {
+            // Overflow
+            return false;
+        }
+
+        int pixelCount = paddedWidth * height;
+
+        if (pixelCount / paddedWidth != height)
+        {
+            // Overflow
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Resets the decoder state to its default values, and,
+    /// additionally, releases memory used by buffers and replaces
+    /// them with new fresh copies.
+    /// </summary>
+    public void RewindDecodingState()
+    {
+        this.decoderStage = JxlDecoderStage.Initialized;
+
+        this.gotSignature = false;
+        this.lastCodestreamSeen = false;
+        this.gotCodestreamSignature = false;
+        this.gotBasicInfo = false;
+        this.gotTransformData = false;
+        this.gotAllHeaders = false;
+        this.postHeaders = false;
+
+        this.iccProfile = null;
+
+        this.gotPreviewImage = false;
+        this.previewFrame = false;
+        this.filePosition = 0;
+
+        this.boxContentsBegin = 0;
+        this.boxContentsEnd = 0;
+        this.boxContentsSize = 0;
+        this.boxSize = 0;
+        this.headerSize = 0;
+        this.boxContentsUnbounded = false;
+
+        this.boxType = null;
+        this.boxDecodedType = null;
+
+        this.boxEvent = false;
+        this.boxStage = JxlBoxStage.Header;
+
+        this.jxlFileFormatVersion = 0;
+        this.nextJxlpIndex = 0;
+        this.jxlpOooBuffer.Clear();
+        this.jxlpOooBufferTotal = 0;
+        this.bufferingJxlpIndex = 0;
+        this.bufferingJxlpIsLast = false;
+
+        this.boxOutBufferSet = false;
+        this.boxOutBufferSetCurrentBox = false;
+        this.boxOutputBuffer?.Dispose();
+        this.boxOutputBuffer = null;
+        this.boxOutBufferSize = 0;
+        this.boxOutBufferBegin = 0;
+        this.boxOutBufferPos = 0;
+
+        this.exifMetadata?.Dispose();
+        this.exifMetadata = null;
+        this.xmpMetadata?.Dispose();
+        this.xmpMetadata = null;
+        this.storeExif = 0;
+        this.storeXmp = 0;
+
+        this.reconstructionOutputBufferPos = 0;
+        this.reconstructionExifSize = 0;
+        this.reconstructionXmpSize = 0;
+        this.reconstructionOutputJpeg = JpegReconstructionStage.None;
+
+        this.eventsWanted = this.originalEventsWanted;
+        this.basicInfoSizeHint = InitialBasicInfoSizeHint();
+        this.haveContainer = false;
+        this.boxCount = 0;
+        this.downsamplingTarget = 8;
+
+        this.imageOutBufferSet = false;
+        this.imageOutBuffer?.Dispose();
+        this.imageOutBuffer = null;
+        this.imageOutputInitCallback = null;
+        this.imageOutputRunCallback = null;
+        this.imageOutputDestroyCallback = null;
+        this.imageOutputSize = 0;
+
+        this.imageOutputBitDepth = new()
+        {
+            Type = JxlBitDepthType.FromPixelFormat
+        };
+
+        this.extraChannelOutputs.Clear();
+
+        this.nextInput?.Dispose();
+        this.nextInput = null;
+
+        this.availableInput = 0;
+        this.inputClosed = false;
+
+        this.passesState?.Reset();
+        this.frameDecoder?.Reset();
+        this.nextSection = 0;
+        this.sectionProcessed.Clear();
+
+        this.imageBundle.Reset();
+        this.metadata = new JxlCodecMetadata();
+        this.imageMetadata = this.metadata.ImageMetadata;
+
+        this.frameHeader = new()
+        {
+            Metadata = this.metadata
+        };
+
+        this.codestreamCopy?.Dispose();
+        this.codestreamCopy = new(this.Options.Configuration.MemoryAllocator);
+        this.codestreamUnconsumed = 0;
+        this.codestreamPos = 0;
+        this.codestreamBitsAhead = 0;
+
+        this.frameStage = JxlFrameStage.Header;
+        this.remainingFrameSize = 0;
+        this.isLastOfStill = false;
+        this.isLastTotal = false;
+        this.skipFrames = 0;
+        this.skippingFrame = false;
+        this.internalFrames = 0;
+        this.externalFrames = 0;
+    }
+
+    /// <summary>
+    /// Resets the decoder to its default values.
+    /// </summary>
+    public void Reset()
+    {
+        this.RewindDecodingState();
+
+        this.keepOrientation = false;
+        this.unpremultiplyAlpha = false;
+        this.renderSpotcolors = true;
+        this.coalescing = true;
+        this.desiredIntensityTarget = 0f;
+        this.originalEventsWanted = 0;
+        this.eventsWanted = 0;
+
+        this.frameReferences.Clear();
+        this.frameExternalToInternal.Clear();
+        this.frameRequired.Clear();
+
+        this.decompressBoxes = false;
+    }
+
+    /// <summary>
+    /// Returns the code stream as a Span.
+    /// </summary>
+    /// <returns>A Span representing the code stream.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the code stream cannot be retrieved.</exception>
+    private Span<byte> GetCodeStreamSpan()
+    {
+        Memory<byte> codestreamInput = this.TryGetCodestreamInput()
+            ?? throw new InvalidOperationException("Cannot retrieve codestream input");
+
+        Span<byte> span = codestreamInput.Span;
+
+        return span;
+    }
+
+    /// <summary>
+    /// Skips frames without decoding them.
+    /// </summary>
+    /// <param name="amount">Number of frames to skip.</param>
+    public void SkipFrames(int amount)
+    {
+        this.skipFrames += amount;
+        this.frameRequired.Clear();
+
+        int nextFrame = this.externalFrames + this.skipFrames;
+
+        if (nextFrame < this.frameExternalToInternal.Count)
+        {
+            int internalIndex = this.frameExternalToInternal[nextFrame];
+            if (internalIndex < this.frameReferences.Count)
+            {
+                List<int> deps = this.GetFrameDependencies(internalIndex, CollectionsMarshal.AsSpan(this.frameReferences));
+                this.ResizeFrameRequired(internalIndex + 1);
+
+                foreach (int index in deps)
+                {
+                    if (index < this.frameRequired.Count)
+                    {
+                        this.frameRequired[index] = 1;
+                    }
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Ensures that frameRequired's count reaches <paramref name="upperBound"/>.
+    /// </summary>
+    /// <param name="upperBound">Max. number of items that frameRequired must have.</param>
+    private void ResizeFrameRequired(int upperBound)
+    {
+        while (this.frameRequired.Count < upperBound)
+        {
+            this.frameRequired.Add(0);
+        }
+    }
+
+    /// <summary>
+    /// Skips the current frame without having to decode it.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the frame cannot be skipped.
+    /// </exception>
+    public void SkipCurrentFrame()
+    {
+        if (this.frameStage == JxlFrameStage.Full)
+        {
+            throw new InvalidOperationException("The decoder is ready to parse the frame, so the frame cannot be skipped");
+        }
+
+        this.frameStage = JxlFrameStage.Header;
+        this.AdvanceCodeStream(this.remainingFrameSize);
+
+        if (this.isLastOfStill)
+        {
+            this.imageOutBufferSet = false;
+        }
+    }
+
+    /// <summary>
+    /// Ensures that the decoder state doesn't change while
+    /// it's busy decoding an image.
+    /// </summary>
+    /// <param name="propertyName">Name of the parameter that was changed/</param>
+    /// <exception cref="InvalidOperationException">Thrown if the state doesn't match initialization.</exception>
+    private void BeforeUpdateState(string propertyName)
+    {
+        if (this.decoderStage != JxlDecoderStage.Initialized)
+        {
+            throw new InvalidOperationException("The decoder is already processing the image, so " + propertyName + " cannot be changed");
+        }
+    }
+
+    /// <summary>
+    /// Reads a single bundle into <paramref name="bundle"/>.
+    /// </summary>
+    /// <typeparam name="T">Type of the bundle to read.</typeparam>
+    /// <param name="stream">Stream to read data from.</param>
+    /// <param name="br">Bit reader to continue from.</param>
+    /// <param name="bundle">The bundle to parse.</param>
+    /// <returns>Status of parsing the bundle.</returns>
+    private bool ReadBundle<T>(Stream stream, JxlBitReader br, T bundle)
+        where T : IJxlFields
+    {
+        JxlBitReader reader = new(stream);
+        reader.SkipBits64((ulong)br.TotalBitsConsumed);
+
+        bool canRead = JxlBundle.CanRead(reader, bundle);
+
+        if (!canRead)
+        {
+            return this.TryRequestMoreInput();
+        }
+
+        if (!JxlBundle.Read(reader, bundle))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Reads all basic metadata and headers.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if the data is incorrect.</exception>
+    /// <exception cref="InvalidDataException">Thrown if the data is malformed.</exception>
+    public void ReadBasicInfo(Stream stream)
+    {
+        if (!this.gotCodestreamSignature)
+        {
+            Span<byte> fileSignature = [0, 0];
+            stream.ReadExactly(fileSignature);
+
+            if (fileSignature[0] != 0xFF || fileSignature[1] != JxlShared.CodestreamMarker)
+            {
+                throw new InvalidOperationException("The file signature is invalid");
+            }
+
+            this.gotCodestreamSignature = true;
+        }
+
+        JxlBitReader bitReader = new(stream);
+
+        if (!this.ReadBundle(stream, bitReader, this.metadata!.Size!))
+        {
+            throw new InvalidDataException("Could not parse the size header");
+        }
+
+        if (!this.ReadBundle(stream, bitReader, this.metadata!.ImageMetadata!))
+        {
+            throw new InvalidDataException("Could not parse the image metadata");
+        }
+
+        long totalBits = bitReader.TotalBitsConsumed;
+
+        (long div, long rem) = Math.DivRem(totalBits, JxlMath.BitsPerByte);
+        this.AdvanceCodeStream(div);
+
+        this.codestreamBitsAhead = rem;
+        this.gotBasicInfo = true;
+        this.basicInfoSizeHint = 0;
+        this.imageMetadata = this.metadata.ImageMetadata;
+
+        if (!CheckSizeLimit(this.metadata.Size!.XSize, this.metadata.Size.YSize))
+        {
+            throw new InvalidOperationException("The image is too large");
+        }
+    }
+
+    /// <summary>
+    /// Parses all necessary headers.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if data is incorrect.</exception>
+    public void ReadAllHeaders()
+    {
+        if (!this.gotTransformData)
+        {
+            Span<byte> span = this.GetCodeStreamSpan();
+
+            JxlBitReader reader = new(this.stream);
+            reader.SkipBits64((ulong)this.codestreamBitsAhead);
+
+            this.metadata!.CustomTransformData!.NonserializedXybEncoded = this.metadata.ImageMetadata!.XybEncoded;
+
+            if (!this.ReadBundle(span, reader, this.metadata.CustomTransformData))
+            {
+                throw new InvalidOperationException("Cannot read custom transform data bundle");
+            }
+
+            long totalBits = reader.TotalBitsConsumed;
+            (long div, long rem) = Math.DivRem(totalBits, JxlMath.BitsPerByte);
+
+            this.AdvanceCodeStream(div);
+            this.codestreamBitsAhead = rem;
+            this.gotTransformData = true;
+        }
+
+        Span<byte> sp = this.GetCodeStreamSpan();
+
+        JxlBitReader bitReader = new(sp);
+        bitReader.SkipBits64((ulong)this.codestreamBitsAhead);
+
+        if (this.metadata!.ImageMetadata!.ColorEncoding!.NeedsIcc)
+        {
+            // TODO: optimize this? ImageSharp ICC doesn't support spans
+            // so we need to allocate an array.
+            IccDataReader reader = new(sp.ToArray());
+            IccProfileHeader header = IccReader.ReadHeader(reader);
+            IccTagDataEntry[] tagData = IccReader.ReadTagData(reader);
+
+            IccProfile icc = new(header, tagData);
+            this.iccProfile = icc;
+            sp = sp[reader.Index..];
+
+            byte[] iccRawData = icc.ToByteArray();
+            this.metadata.ImageMetadata.ColorEncoding.SetIccRaw(iccRawData);
+        }
+
+        this.gotAllHeaders = true;
+        bitReader.JumpToByteBoundary();
+
+        this.AdvanceCodeStream(bitReader.TotalBitsConsumed / JxlMath.BitsPerByte);
+        this.codestreamBitsAhead = 0;
+
+        this.passesState ??= new(this.frameHeader!, this.Options.Configuration);
+        this.passesState.OutputEncodingInfo.SetFromMetadata(this.metadata);
+
+        if (this.desiredIntensityTarget > 0f)
+        {
+            this.passesState.OutputEncodingInfo.DesiredIntensityTarget = this.desiredIntensityTarget;
+        }
+
+        this.imageMetadata = this.metadata.ImageMetadata;
+    }
+
+    /// <summary>
+    /// Processes all sections in this JPEG XL images and invokes
+    /// the frame decoder.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if the data is invalid or malformed.</exception>
+    public void ProcessSections()
+    {
+        Span<byte> span = this.GetCodeStreamSpan();
+
+        var toc = this.frameDecoder!.Toc;
+
+        long pos = 0;
+        List<JxlSectionInfo> sectionInfo = [];
+        List<JxlSectionStatus> sectionStatus = [];
+
+        for (long i = this.nextSection; i < toc.Size; i++)
+        {
+            if (this.sectionProcessed[(int)i] != 0)
+            {
+                pos += toc[i].Size;
+                continue;
+            }
+
+            long id = toc[i].Id;
+            long size = toc[i].Size;
+
+            if (IsOutOfBounds((int)pos, (int)size, span.Length))
+            {
+                break;
+            }
+
+            JxlBitReader br = new(span.Slice((int)pos, (int)size));
+            sectionInfo.Add(new(br, (int)id, (int)i));
+            sectionStatus.Add(default);
+            pos += size;
+        }
+
+        this.frameDecoder.ProcessSections(sectionInfo, sectionStatus);
+
+        for (int i = 0; i < sectionStatus.Count; i++)
+        {
+            JxlSectionStatus ss = sectionStatus[i];
+
+            if (ss == JxlSectionStatus.Done)
+            {
+                this.sectionProcessed[sectionInfo[i].Index] = 1;
+            }
+            else if (ss != JxlSectionStatus.Skipped)
+            {
+                throw new InvalidOperationException("Unexpected section status");
+            }
+        }
+
+        long completedPrefixBytes = 0;
+
+        while (this.nextSection < this.sectionProcessed.Count && this.sectionProcessed[(int)this.nextSection] == 1)
+        {
+            completedPrefixBytes += toc[(int)this.nextSection].Size;
+            this.nextSection++;
+        }
+
+        this.remainingFrameSize -= completedPrefixBytes;
+        this.AdvanceCodeStream(completedPrefixBytes);
+    }
+
+    /// <summary>
+    /// Processes all codestream contents.
+    /// </summary>
+    /// <returns>Status of codestream processing.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when data is corrupt, malformed, or incorrect.</exception>
+    public int ProcessCodestream()
+    {
+        if (!this.gotBasicInfo)
+        {
+            this.ReadBasicInfo();
+        }
+
+        if ((this.eventsWanted & JxlDecoderStatus.BasicInfo) != 0)
+        {
+            this.eventsWanted &= ~JxlDecoderStatus.BasicInfo;
+            return JxlDecoderStatus.BasicInfo;
+        }
+
+        if (this.eventsWanted == 0)
+        {
+            this.decoderStage = JxlDecoderStage.CodeStreamFinished;
+            return JxlDecoderStatus.Success;
+        }
+
+        if (!this.gotAllHeaders)
+        {
+            this.ReadAllHeaders();
+        }
+
+        if ((this.eventsWanted & JxlDecoderStatus.ColorEncoding) != 0)
+        {
+            this.eventsWanted &= ~JxlDecoderStatus.ColorEncoding;
+            return JxlDecoderStatus.ColorEncoding;
+        }
+
+        if (this.eventsWanted == 0)
+        {
+            this.decoderStage = JxlDecoderStage.CodeStreamFinished;
+            return JxlDecoderStatus.Success;
+        }
+
+        this.postHeaders = true;
+
+        if (!this.gotPreviewImage && this.metadata!.ImageMetadata!.HavePreview)
+        {
+            this.previewFrame = true;
+        }
+
+        while (true)
+        {
+            bool parseFrames = (this.eventsWanted & (JxlDecoderStatus.PreviewImage | JxlDecoderStatus.Frame | JxlDecoderStatus.FullImage)) != 0;
+            if (!parseFrames || (this.frameStage == JxlFrameStage.Header && this.isLastTotal))
+            {
+                break;
+            }
+
+            if (this.frameStage == JxlFrameStage.Header)
+            {
+                if (this.reconstructionOutputJpeg is JpegReconstructionStage.SetMetadata or JpegReconstructionStage.Output)
+                {
+                    throw new InvalidOperationException("Cannot decode frames following a JPEG reconstruction frame");
+                }
+
+                this.imageBundle ??= new(this.imageMetadata!);
+
+                if (!this.jpegDecoder.SetImageBundleJpegData(this.imageBundle!))
+                {
+                    throw new InvalidOperationException("Cannot set JXL->JPEG decoder image bundle");
+                }
+
+                this.frameDecoder = new(this.passesState!, this.metadata!, useSlowRenderingPipeline: false);
+                this.frameHeader = new()
+                {
+                    Metadata = this.metadata
+                };
+
+                Span<byte> span = this.GetCodeStreamSpan();
+                JxlBitReader reader = new(span);
+
+                this.frameDecoder.InitializeFrame(reader, this.imageBundle!, this.previewFrame);
+
+                this.AdvanceCodeStream(reader.TotalBitsConsumed / JxlMath.BitsPerByte);
+                this.frameHeader = this.frameDecoder.GetFrameHeader();
+
+                JxlFrameDimensions dim = this.frameHeader.FrameDimensions;
+
+                if (!CheckSizeLimit(dim.XSizeUpsampledPadded, dim.YSizeUpsampledPadded))
+                {
+                    throw new InvalidOperationException("Frame is too large");
+                }
+
+                int outputType = this.previewFrame ? JxlDecoderStatus.PreviewImage : JxlDecoderStatus.FullImage;
+                bool outputNeeded = (this.eventsWanted & outputType) != 0;
+
+                if (outputNeeded)
+                {
+                    this.frameDecoder.InitializeFrameOutput();
+                }
+
+                this.remainingFrameSize = this.frameDecoder.SumSectionSizes();
+
+                this.frameStage = JxlFrameStage.Toc;
+                if (this.previewFrame)
+                {
+                    if ((this.eventsWanted & JxlDecoderStatus.PreviewImage) == 0)
+                    {
+                        this.frameStage = JxlFrameStage.Header;
+                        this.AdvanceCodeStream(this.remainingFrameSize);
+                        this.gotPreviewImage = true;
+                        this.previewFrame = false;
+                    }
+
+                    continue;
+                }
+
+                int savedAs = JxlFrameDecoder.SavedAs(this.frameHeader);
+                this.isLastTotal = this.frameHeader.IsLast;
+                this.isLastOfStill = this.isLastTotal || this.frameHeader.AnimationFrame!.Duration > 0;
+                this.isLastOfStill |= !this.coalescing && this.frameHeader.FrameType == JxlFrameType.RegularFrame;
+
+                int internalFrameIndex = this.internalFrames;
+                int externalFrameIndex = this.externalFrames;
+
+                if (this.isLastOfStill)
+                {
+                    this.externalFrames++;
+                }
+
+                this.internalFrames++;
+
+                if (this.skipFrames > 0)
+                {
+                    this.skippingFrame = true;
+
+                    if (this.isLastOfStill)
+                    {
+                        this.skipFrames--;
+                    }
+                }
+                else
+                {
+                    this.skippingFrame = false;
+                }
+
+                if (externalFrameIndex >= this.frameExternalToInternal.Count)
+                {
+                    this.frameExternalToInternal.Add(internalFrameIndex);
+
+                    if (this.frameExternalToInternal.Count != externalFrameIndex + 1)
+                    {
+                        throw new InvalidOperationException("Internal error");
+                    }
+                }
+
+                if (internalFrameIndex >= this.frameReferences.Count)
+                {
+                    this.frameReferences.Add(new JxlFrameReference(0xFF, savedAs));
+
+                    if (this.frameReferences.Count != internalFrameIndex + 1)
+                    {
+                        throw new InvalidOperationException("Internal error");
+                    }
+                }
+
+                if (this.skippingFrame)
+                {
+                    bool referenceable = this.frameHeader.CanBeReferenced || this.frameHeader.FrameType == JxlFrameType.DcFrame;
+
+                    if (internalFrameIndex < this.frameRequired.Count && this.frameRequired[internalFrameIndex] == 0)
+                    {
+                        referenceable = false;
+                    }
+
+                    if (!referenceable)
+                    {
+                        this.frameStage = JxlFrameStage.Header;
+                        this.AdvanceCodeStream(this.remainingFrameSize);
+                        continue;
+                    }
+                }
+
+                if ((this.eventsWanted & JxlDecoderStatus.Frame) != 0 && this.isLastOfStill)
+                {
+                    if (!this.skippingFrame)
+                    {
+                        return JxlDecoderStatus.Frame;
+                    }
+                }
+
+                if (this.frameStage == JxlFrameStage.Toc)
+                {
+                    this.frameDecoder.SetRenderSpotcolors(this.renderSpotcolors);
+                    this.frameDecoder.SetCoalescing(this.coalescing);
+
+                    if (!this.previewFrame && (this.eventsWanted & JxlDecoderStatus.Progression) != 0)
+                    {
+                        this.frameProgressiveDetail = this.frameDecoder.SetPauseAtProgressive(this.progressiveDetail);
+                    }
+                    else
+                    {
+                        this.frameProgressiveDetail = JxlProgressiveDetail.Frames;
+                    }
+
+                    this.dcFrameProgressionDone = false;
+                    this.nextSection = 0;
+                    this.sectionProcessed.Clear();
+                    ResizeSectionProcessed(this.frameDecoder.Toc.Size);
+
+                    if (this.previewFrame || (this.eventsWanted & JxlDecoderStatus.FullImage) != 0)
+                    {
+                        this.frameStage = JxlFrameStage.Full;
+                    }
+                    else if (!this.isLastTotal)
+                    {
+                        this.frameStage = JxlFrameStage.Header;
+                        this.AdvanceCodeStream(this.remainingFrameSize);
+                        continue;
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+
+                if (this.frameStage == JxlFrameStage.Full)
+                {
+                    if (!this.imageOutBufferSet)
+                    {
+                        if (this.previewFrame)
+                        {
+                            return JxlDecoderStatus.NeedPreviewOutBuffer;
+                        }
+
+                        if ((!this.jpegDecoder.IsOutputSet || this.imageBundle!.JpegData is null)
+                            && this.isLastOfStill
+                            && !this.skippingFrame)
+                        {
+                            throw new InvalidOperationException("Image output buffer is too small");
+                        }
+                    }
+
+                    if (this.imageOutBufferSet)
+                    {
+                        Size dimensions = this.CurrentDimensions;
+                        int bitsPerSample = GetBitDepth(this.imageOutputBitDepth, this.metadata!.ImageMetadata!, this.imageOutputFormat);
+
+                        this.frameDecoder.SetImageOutput(
+                            new PixelCallback(
+                                this.imageOutputInitCallback,
+                                this.imageOutputRunCallback,
+                                this.imageOutputDestroyCallback),
+                            this.imageOutBuffer,
+                            this.imageOutputSize,
+                            dimensions.Width,
+                            dimensions.Height,
+                            this.imageOutputFormat,
+                            bitsPerSample,
+                            this.unpremultiplyAlpha,
+                            !this.keepOrientation);
+
+                        for (int i = 0; i < this.extraChannelOutputs.Count; i++)
+                        {
+                            JxlExtraChannelOutput extra = this.extraChannelOutputs[i];
+                            int ecBitsPerSample = GetBitDepth(this.imageOutputBitDepth, this.metadata.ImageMetadata!.ExtraChannels[i], extra.Format);
+
+                            this.frameDecoder.AddExtraChannelOutput(
+                                extra.Buffer,
+                                extra.BufferSize,
+                                dimensions.Width,
+                                extra.Format,
+                                ecBitsPerSample);
+                        }
+                    }
+
+                    long nextNumPassesToPause = this.frameDecoder.NextNumPassesToPause;
+
+                    this.ProcessSections();
+
+                    bool allSectionsDone = this.frameDecoder.DecodedAll;
+                    bool gotDcOnly = !allSectionsDone && this.frameDecoder.HasDecodedDc;
+
+                    if (this.frameProgressiveDetail >= JxlProgressiveDetail.Dc &&
+                        !this.dcFrameProgressionDone &&
+                        gotDcOnly)
+                    {
+                        this.dcFrameProgressionDone = true;
+                        this.downsamplingTarget = 8;
+                        return JxlDecoderStatus.Progression;
+                    }
+
+                    bool newProgressionStepDone = this.frameDecoder.NumCompletePasses >= nextNumPassesToPause;
+
+                    if (!allSectionsDone &&
+                        this.frameProgressiveDetail >= JxlProgressiveDetail.LastPasses &&
+                        newProgressionStepDone)
+                    {
+                        this.downsamplingTarget = this.frameHeader.Passes.GetDownsamplingTargetForCompletedPasses(this.frameDecoder.NumCompletePasses);
+                        return JxlDecoderStatus.Progression;
+                    }
+
+                    if (!allSectionsDone)
+                    {
+                        return this.TryRequestMoreInput() ? 1 : 0;
+                    }
+
+                    if (!this.previewFrame)
+                    {
+                        long internalIndex = this.internalFrames - 1;
+                        if (this.frameReferences.Count <= internalIndex)
+                        {
+                            throw new InvalidOperationException("Internal error");
+                        }
+
+                        this.frameReferences[(int)internalIndex].Reference = this.frameDecoder.References;
+                    }
+
+                    this.frameDecoder.FinalizeFrame();
+
+                    if (this.jpegDecoder.IsOutputSet && this.imageBundle!.JpegData is not null)
+                    {
+                        this.frameStage = JxlFrameStage.Header;
+                        this.reconstructionOutputJpeg = JpegReconstructionStage.SetMetadata;
+
+                        return JxlDecoderStatus.FullImage;
+                    }
+
+                    if (this.previewFrame || this.isLastOfStill)
+                    {
+                        this.imageOutBufferSet = false;
+                        this.extraChannelOutputs.Clear();
+                    }
+                }
+
+                this.frameStage = JxlFrameStage.Header;
+                this.imageBundle.Reset();
+
+                if (this.previewFrame)
+                {
+                    this.gotPreviewImage = true;
+                    this.previewFrame = false;
+                    this.eventsWanted &= ~JxlDecoderStatus.PreviewImage;
+                    return JxlDecoderStatus.PreviewImage;
+                }
+                else if (this.isLastOfStill && (this.eventsWanted & JxlDecoderStatus.FullImage) != 0 && !this.skippingFrame)
+                {
+                    return JxlDecoderStatus.FullImage;
+                }
+            }
+        }
+
+        this.decoderStage = JxlDecoderStage.CodeStreamFinished;
+        return 1;
+    }
+
+    /// <summary>
+    /// Sets the input JPEG XL data to <paramref name="data"/>.
+    /// </summary>
+    /// <param name="data">The input data to parse JPEG XL.</param>
+    /// <exception cref="InvalidOperationException">Thrown if the input data cannot be changed at this moment.</exception>
+    public void SetInput(IMemoryOwner<byte> data)
+    {
+        if (this.nextInput is not null)
+        {
+            throw new InvalidOperationException("Input is already present. Use DisposeInput first");
+        }
+
+        if (this.inputClosed)
+        {
+            throw new InvalidOperationException("Input is closed");
+        }
+
+        this.nextInput = data;
+        this.availableInput = data.Memory.Length;
+    }
+
+    /// <summary>
+    /// Disposes the input data.
+    /// </summary>
+    /// <returns>
+    /// Number of available bytes left in the input data before disposal.
+    /// </returns>
+    public long DisposeInput()
+    {
+        long previousAvailableBytes = this.availableInput;
+
+        this.nextInput?.Dispose();
+        this.nextInput = null;
+        this.availableInput = 0;
+
+        return previousAvailableBytes;
+    }
+
+    /// <summary>
+    /// Closes the input stream so it can't be read anymore.
+    /// </summary>
+    public void CloseInput() => this.inputClosed = true;
+
+    /// <summary>
+    /// Sets the output buffer for JPEG reconstruction.
+    /// </summary>
+    /// <param name="data">Buffer for JPEG reconstruction.</param>
+    /// <exception cref="InvalidOperationException">Thrown when the buffer can't be set.</exception>
+    public void SetJpegBuffer(Memory<byte> data)
+    {
+        if (this.internalFrames > 1)
+        {
+            throw new InvalidOperationException("JPEG reconstruction only works for first frames");
+        }
+
+        if (this.jpegDecoder.IsOutputSet)
+        {
+            throw new InvalidOperationException("Already set JPEG buffer");
+        }
+
+        this.jpegDecoder.SetOutputBuffer(data);
+    }
+
+    /// <summary>
+    /// Parses the start of a box.
+    /// </summary>
+    /// <param name="input">Input bytes to parse from.</param>
+    /// <param name="type">Type of the box</param>
+    /// <param name="boxSize">Output box size.</param>
+    /// <param name="headerSize">Output header size.</param>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when data is invalid.
+    /// </exception>
+    private static void ParseBoxHeader(Stream input, out int type, out long boxSize, out long headerSize)
+    {
+        JxlBoxHeader header = JxlBoxHeader.ReadHeader(input);
+        boxSize = (long)header.Size;
+        headerSize = (header.ContainsLargeSize ? 12 : 4) + 4;
+        type = (int)header.Type;
+    }
+
+    /// <summary>
+    /// Processes all boxes and their contents if this is a container format.
+    /// </summary>
+    /// <param name="stream">Stream to decode from.</param>
+    /// <returns>Status of processing.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when data is invalid.</exception>
+    public int ProcessBoxes(Stream stream)
+    {
+        // We have a box handling loop here.
+        while (true)
+        {
+            if (this.boxStage != JxlBoxStage.Header)
+            {
+                // this.AdvanceInput(this.headerSize);
+                this.headerSize = 0;
+
+                if ((this.eventsWanted & JxlDecoderStatus.Box) != 0 && this.boxEvent && !this.boxOutBufferSetCurrentBox)
+                {
+                    this.boxEvent = false;
+                }
+
+                if ((this.eventsWanted & JxlDecoderStatus.Box) != 0 && this.boxOutBufferSetCurrentBox)
+                {
+                    Memory<byte> nextOut = this.boxOutputBuffer!.Memory[(int)this.boxOutBufferPos..];
+                    long availOut = this.boxOutBufferSize - this.boxOutBufferPos;
+
+                    Span<byte> bufferSpan = this.boxOutputBuffer.Memory.Span;
+                    Span<byte> startSlice = bufferSpan[(int)this.boxOutBufferPos..];
+
+                    int status = this.boxContentDecoder!.Process(
+                        stream,
+                        this.boxOutputBuffer);
+
+                    long produced = startSlice.Length - availOut;
+                    this.boxOutBufferPos += produced;
+
+                    if (status == JxlDecoderStatus.Complete && (this.eventsWanted & JxlDecoderStatus.Complete) == 0)
+                    {
+                        status = JxlDecoderStatus.Success;
+                    }
+
+                    if (status is not (JxlDecoderStatus.Success or JxlDecoderStatus.NeedMoreInput))
+                    {
+                        return status;
+                    }
+                }
+
+                if (this.storeExif == 1 || this.storeXmp == 1)
+                {
+                    IMemoryOwner<byte> metadata = (this.storeExif == 1 ? this.exifMetadata : this.xmpMetadata)
+                        ?? throw new InvalidOperationException("Metadata is missing, but should be present");
+
+                    // Boxes should not contain more than 64MiB data.
+                    const long blockSizeLimit = 64L << 20;
+
+                    // Use array version of metadata so we
+                    // can resize the array.
+                    byte[] md = metadata.Memory.ToArray();
+
+                    while (true)
+                    {
+                        if (md.Length == 0)
+                        {
+                            Array.Resize(ref md, 64);
+                        }
+
+                        Span<byte> originalNextOutput = md.AsSpan()[(int)this.reconstructionOutputBufferPos..];
+                        Span<byte> nextOutput = originalNextOutput;
+                        long availableOutput = md.Length - this.reconstructionOutputBufferPos;
+
+                        int boxResult = this.metadataDecoder.Decode(
+                            this.nextInput,
+                            this.availableInput,
+                            this.filePosition - this.boxContentsBegin,
+                            ref nextOutput,
+                            ref availableOutput);
+
+                        long produced = originalNextOutput.Length - nextOutput.Length;
+                        this.reconstructionOutputBufferPos += produced;
+
+                        if (boxResult == JxlDecoderStatus.NeedMoreOutput)
+                        {
+                            if (md.Length >= blockSizeLimit)
+                            {
+                                throw new InvalidOperationException("Box with EXIF or XMP metadata is too large");
+                            }
+
+                            Array.Resize(ref md, md.Length * 2);
+                        }
+                        else if (boxResult == JxlDecoderStatus.NeedMoreInput)
+                        {
+                            break;
+                        }
+                        else if (boxResult == JxlDecoderStatus.Complete)
+                        {
+                            long neededSize = this.storeExif == 1 ? this.reconstructionExifSize : this.reconstructionXmpSize;
+
+                            if (this.boxContentsUnbounded && this.reconstructionOutputBufferPos < neededSize)
+                            {
+                                break;
+                            }
+                            else
+                            {
+                                Array.Resize(ref md, (int)this.reconstructionOutputBufferPos);
+
+                                if (this.storeExif == 1)
+                                {
+                                    this.storeExif = 2;
+                                }
+
+                                if (this.storeXmp == 1)
+                                {
+                                    this.storeXmp = 2;
+                                }
+
+                                break;
+                            }
+                        }
+                        else
+                        {
+                            // Error
+                            return boxResult;
+                        }
+                    }
+                }
+            }
+
+            if (this.reconstructionOutputJpeg == JpegReconstructionStage.SetMetadata && this.JbrdNeedsMoreBoxes())
+            {
+                JpegData jpegData = this.imageBundle!.JpegData.GetData();
+
+                if (this.reconstructionExifSize > 0)
+                {
+                    JxlToJpegDecoder.TrySetExif(this.exifMetadata!.Memory.Span, jpegData);
+                }
+
+                if (this.reconstructionXmpSize > 0)
+                {
+                    JxlToJpegDecoder.TrySetXmp(this.xmpMetadata!.Memory.Span, jpegData);
+                }
+
+                this.reconstructionOutputJpeg = JpegReconstructionStage.Output;
+            }
+
+            if (this.reconstructionOutputJpeg == JpegReconstructionStage.Output && !this.JbrdNeedsMoreBoxes())
+            {
+                this.jpegDecoder!.WriteOutput(this.imageBundle!.JpegData);
+
+                this.reconstructionOutputJpeg = JpegReconstructionStage.None;
+                this.imageBundle.Reset();
+
+                if ((this.eventsWanted & JxlDecoderStatus.FullImage) != 0)
+                {
+                    return JxlDecoderStatus.FullImage;
+                }
+            }
+
+            if (this.boxStage == JxlBoxStage.Header)
+            {
+                if (!this.haveContainer)
+                {
+                    if (this.decoderStage == JxlDecoderStage.CodeStreamFinished)
+                    {
+                        return JxlDecoderStatus.Success;
+                    }
+
+                    this.boxStage = JxlBoxStage.CodeStream;
+                    this.boxContentsUnbounded = true;
+
+                    continue;
+                }
+
+                if (this.availableInput == 0)
+                {
+                    if (this.decoderStage != JxlDecoderStage.CodeStreamFinished || this.JbrdNeedsMoreBoxes())
+                    {
+                        ThrowNotEnoughData();
+                    }
+
+                    if (this.inputClosed || (this.eventsWanted & JxlDecoderStatus.Box) != 0)
+                    {
+                        return JxlDecoderStatus.Success;
+                    }
+
+                    ThrowNotEnoughData();
+                }
+
+                bool boxedCodestreamDone = ((this.eventsWanted & JxlDecoderStatus.Box) != 0)
+                    && this.decoderStage == JxlDecoderStage.CodeStreamFinished
+                    && !this.JbrdNeedsMoreBoxes()
+                    && this.lastCodestreamSeen;
+
+                if (boxedCodestreamDone &&
+                    this.availableInput >= 2 &&
+                    this.nextInput!.Memory.Span[0] == 0xFF &&
+                    this.nextInput.Memory.Span[1] == JxlShared.CodestreamMarker)
+                {
+                    return JxlDecoderStatus.Success;
+                }
+
+                int status = ParseBoxHeader(this.nextInput, this.availableInput, 0, this.filePosition, this.boxType, out long boxSize, out long headerSize);
+
+                if (this.boxType == JxlBoxTypes.Brob)
+                {
+                    this.boxDecodedType = BitConverter.ToInt32(this.nextInput!.Memory.Span[(int)headerSize..]);
+                }
+                else
+                {
+                    this.boxDecodedType = this.boxType;
+                }
+
+                this.boxCount++;
+
+                if (boxedCodestreamDone && this.boxType == JxlBoxTypes.Jxl)
+                {
+                    return JxlDecoderStatus.Success;
+                }
+
+                if (this.boxCount == 2 && this.boxType != JxlBoxTypes.FileType)
+                {
+                    throw new InvalidOperationException("The second box must be a ftyp (File Type) box");
+                }
+
+                if (this.boxType == JxlBoxTypes.FileType && this.boxCount != 2)
+                {
+                    throw new InvalidOperationException("The ftyp (File Type) box must be a second box");
+                }
+
+                this.boxContentsUnbounded = boxSize == 0;
+                this.boxContentsBegin = this.filePosition + headerSize;
+                this.boxContentsEnd = this.boxContentsUnbounded ? 0 : (this.filePosition + boxSize);
+                this.boxContentsSize = this.boxContentsUnbounded ? 0 : (boxSize - headerSize);
+                this.boxSize = boxSize;
+                this.headerSize = headerSize;
+
+                if ((this.originalEventsWanted & JxlDecoderStatus.JpegReconstruction) != 0)
+                {
+                    if (this.storeExif == 0 && this.boxDecodedType == JxlBoxTypes.Exif)
+                    {
+                        this.storeExif = 1;
+                        this.reconstructionOutputBufferPos = 0;
+                    }
+
+                    if (this.storeXmp == 0 && this.boxDecodedType == JxlBoxTypes.Xml)
+                    {
+                        this.storeXmp = 1;
+                        this.reconstructionOutputBufferPos = 0;
+                    }
+                }
+
+                if ((this.eventsWanted & JxlDecoderStatus.Box) != 0)
+                {
+                    bool decompress = this.decompressBoxes && this.boxType == JxlBoxTypes.Brob;
+                    this.boxContentDecoder!.Initialize(decompress, this.boxContentsUnbounded, (ulong)this.boxContentsSize);
+                }
+
+                if (this.storeExif == 1 || this.storeXmp == 1)
+                {
+                    bool brob = this.boxType == JxlBoxTypes.Brob;
+                    this.metadataDecoder!.Initialize(brob, this.boxContentsUnbounded, (ulong)this.boxContentsSize);
+                }
+
+                if (this.boxType == JxlBoxTypes.FileType)
+                {
+                    this.boxStage = JxlBoxStage.Ftyp;
+                }
+                else if (this.boxType == JxlBoxTypes.JxlCodeStream)
+                {
+                    if (this.lastCodestreamSeen)
+                    {
+                        throw new InvalidOperationException("Only one jxlc (JPEG XL codestream) box can be present");
+                    }
+
+                    this.lastCodestreamSeen = true;
+                    this.boxStage = JxlBoxStage.CodeStream;
+                }
+                else if (this.boxType == JxlBoxTypes.JxlPartialCodeStream)
+                {
+                    this.boxStage = JxlBoxStage.PartialCodeStream;
+                }
+                else if ((this.originalEventsWanted & JxlDecoderStatus.JpegReconstruction) != 0 && this.boxType == JxlBoxTypes.JpegReconstructionData)
+                {
+                    if ((this.eventsWanted & JxlDecoderStatus.JpegReconstruction) == 0)
+                    {
+                        throw new InvalidOperationException("Multiple JPEG reconstruction boxes detected");
+                    }
+
+                    this.boxStage = JxlBoxStage.JpegReconstruction;
+                }
+                else
+                {
+                    this.boxStage = JxlBoxStage.Skip;
+                }
+
+                if ((this.eventsWanted & JxlDecoderStatus.Box) != 0)
+                {
+                    this.boxEvent = true;
+                    this.boxOutBufferSetCurrentBox = false;
+                    return JxlDecoderStatus.Box;
+                }
+            }
+            else if (this.boxStage == JxlBoxStage.Ftyp)
+            {
+                if (this.boxContentsSize < 12)
+                {
+                    throw new InvalidOperationException("The file type box is too small");
+                }
+
+                if (BinaryUtils.ReadInt32BigEndian(stream) != 0x6A786C20) // Bytes "jxl " in Big Endian
+                {
+                    throw new InvalidOperationException("File type box major brand must be \"jxl \"");
+                }
+
+                uint version = BinaryUtils.ReadUInt32BigEndian(stream);
+                if (version > 1)
+                {
+                    throw new InvalidOperationException("Unknown JXL file format version " + version + ", known versions are 0 and 1");
+                }
+
+                this.jxlFileFormatVersion = (int)version;
+                this.boxStage = JxlBoxStage.Skip;
+            }
+            else if (this.boxStage == JxlBoxStage.PartialCodeStream)
+            {
+                if (this.lastCodestreamSeen)
+                {
+                    throw new InvalidOperationException("Cannot have jxlp box after last jxlp box");
+                }
+
+                if (!this.boxContentsUnbounded && this.boxContentsSize < 4)
+                {
+                    throw new InvalidOperationException("jxlp box is too small to contain an index");
+                }
+
+                uint jxlpIndex = BinaryUtils.ReadUInt32BigEndian(stream);
+                uint counter = jxlpIndex & 0x7FFFFFFFu;
+                bool isLast = (jxlpIndex & 0x80000000u) != 0;
+
+                if (counter < this.nextJxlpIndex)
+                {
+                    throw new InvalidOperationException("jxlp box index " + counter + " is a duplicate (already processed)");
+                }
+
+                if (counter == this.nextJxlpIndex)
+                {
+                    this.nextJxlpIndex++;
+
+                    if (isLast)
+                    {
+                        this.lastCodestreamSeen = true;
+                    }
+
+                    this.boxStage = JxlBoxStage.CodeStream;
+                }
+                else if (this.jxlFileFormatVersion >= 1)
+                {
+                    if (this.jxlpOooBuffer.Count >= NumBuffersLimit)
+                    {
+                        return JxlDecoderStatus.Error;
+                    }
+
+                    // When creating a new OOO (Out-of-order) entry,
+                    // the data is initially empty.
+                    byte[] buffer = [];
+                    JxlOooEntry entry = new(buffer, isLast);
+                    this.jxlpOooBuffer.Add((int)counter, entry);
+
+                    this.bufferingJxlpIndex = (int)counter;
+                    this.bufferingJxlpIsLast = isLast;
+                    this.boxStage = JxlBoxStage.BufferingJxlp;
+                }
+                else
+                {
+                    throw new InvalidOperationException("JXLP box with index " + counter + " is out of order (index " + this.nextJxlpIndex + " was expected). Out-of-order jxlp boxes require file format version 1 in the file type (ftyp) box.");
+                }
+            }
+            else if (this.boxStage == JxlBoxStage.CodeStream)
+            {
+                int status = this.ProcessCodestream();
+
+                if (status == JxlDecoderStatus.FullImage)
+                {
+                    if (this.reconstructionOutputJpeg != JpegReconstructionStage.None)
+                    {
+                        continue;
+                    }
+                }
+
+                if (status == JxlDecoderStatus.NeedMoreInput)
+                {
+                    if (this.filePosition == this.boxContentsEnd && !this.boxContentsUnbounded)
+                    {
+                        bool hasMoreData = this.TryInjectNextBufferedJxlpBox();
+
+                        if (!hasMoreData)
+                        {
+                            this.boxStage = JxlBoxStage.Header;
+                        }
+
+                        continue;
+                    }
+                }
+
+                if (status == JxlDecoderStatus.Success)
+                {
+                    if (this.JbrdNeedsMoreBoxes())
+                    {
+                        this.boxStage = JxlBoxStage.Skip;
+                        continue;
+                    }
+
+                    if (this.boxContentsUnbounded)
+                    {
+                        break;
+                    }
+
+                    if ((this.eventsWanted & JxlDecoderStatus.Box) != 0)
+                    {
+                        this.boxStage = JxlBoxStage.Skip;
+                        continue;
+                    }
+                }
+
+                return status;
+            }
+            else if (this.boxStage == JxlBoxStage.BufferingJxlp)
+            {
+                long remaining = this.boxContentsUnbounded
+                    ? this.availableInput
+                    : Math.Min(this.availableInput, this.boxContentsEnd - this.filePosition);
+
+                if (!this.CanAddBuffer(remaining) || !this.jxlpOooBuffer.TryGetValue(this.bufferingJxlpIndex, out JxlOooEntry? entry))
+                {
+                    return JxlDecoderStatus.Error;
+                }
+
+                // Now we want to write the 'remaining' number of bytes
+                // from input into the codestream.
+                using IMemoryOwner<byte> buffer = this.Options.Configuration.MemoryAllocator.Allocate<byte>((int)remaining);
+                entry!.CodestreamBytes.Write(buffer.Memory.Span);
+                this.jxlpOooBufferTotal += remaining;
+
+                bool boxDone = !this.boxContentsUnbounded && this.filePosition >= this.boxContentsEnd;
+
+                if (!boxDone)
+                {
+                    ThrowNotEnoughData();
+                }
+
+                this.boxStage = JxlBoxStage.Header;
+            }
+            else if (this.boxStage == JxlBoxStage.JpegReconstruction)
+            {
+                if (!this.jpegDecoder.IsParsingBox)
+                {
+                    this.jpegDecoder.StartBox(this.boxContentsUnbounded, this.boxContentsSize);
+                }
+
+                Span<byte> nextInput = this.nextInput!.Memory.Span;
+                long availableInput = this.availableInput;
+
+                int reconstructionResult = this.jpegDecoder.Process(ref nextInput, ref availableInput);
+
+                long consumed = this.nextInput.Memory.Length - nextInput.Length;
+                this.AdvanceInput(consumed);
+
+                if (reconstructionResult == JxlDecoderStatus.JpegReconstruction)
+                {
+                    JpegData jpegData = this.jpegDecoder!.GetJpegData();
+                    long numExif = JxlToJpegDecoder.NumExifMarkers(jpegData);
+                    long numXmp = JxlToJpegDecoder.NumXmpMarkers(jpegData);
+
+                    if (numExif > 0)
+                    {
+                        if (numExif > 1)
+                        {
+                            throw new InvalidOperationException("Only one EXIF marker for JPEG reconstruction can be present");
+                        }
+
+                        if (!JxlToJpegDecoder.ExifBoxContentSize(jpegData, ref this.reconstructionExifSize))
+                        {
+                            throw new InvalidOperationException("Invalid jbrd EXIF size");
+                        }
+                    }
+
+                    if (numXmp > 0)
+                    {
+                        if (numXmp > 1)
+                        {
+                            throw new InvalidOperationException("Only one XMP marker for JPEG reconstruction can be present");
+                        }
+
+                        if (!JxlToJpegDecoder.XmpBoxContentSize(jpegData, ref this.reconstructionXmpSize))
+                        {
+                            throw new InvalidOperationException("Invalid jbrd XMP size");
+                        }
+                    }
+
+                    this.boxStage = JxlBoxStage.Header;
+
+                    if ((this.eventsWanted & JxlDecoderStatus.JpegReconstruction) != 0)
+                    {
+                        this.eventsWanted &= ~JxlDecoderStatus.JpegReconstruction;
+                        return JxlDecoderStatus.JpegReconstruction;
+                    }
+                }
+                else
+                {
+                    return reconstructionResult;
+                }
+            }
+            else if (this.boxStage == JxlBoxStage.Skip)
+            {
+                if (this.boxContentsUnbounded)
+                {
+                    if (this.inputClosed || !this.boxOutBufferSet)
+                    {
+                        return JxlDecoderStatus.Success;
+                    }
+
+                    this.AdvanceInput(this.availableInput);
+                    ThrowNotEnoughData();
+                }
+
+                long remaining = this.boxContentsEnd - this.filePosition;
+                if (this.availableInput < remaining)
+                {
+                    this.basicInfoSizeHint = InitialBasicInfoSizeHint() + this.boxContentsEnd - this.filePosition;
+                    this.AdvanceInput(this.availableInput);
+                    ThrowNotEnoughData();
+                }
+                else
+                {
+                    this.AdvanceInput(remaining);
+                    this.boxStage = JxlBoxStage.Header;
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException("Unreachable");
+            }
+        }
+
+        return JxlDecoderStatus.Success;
+    }
+
+    /// <summary>
+    /// Releases memory used by the JPEG output buffer.
+    /// </summary>
+    public void DisposeJpegBuffer() => this.jpegDecoder.DisposeOutputBuffer();
+
+    /// <summary>
+    /// Main core decoding routine.
+    /// </summary>
+    /// <param name="stream">Stream to decode from.</param>
+    /// <exception cref="InvalidOperationException">Thrown when data or input parameters are invalid.</exception>
+    public void DecodeInput(Stream stream)
+    {
+        this.Reset();
+        this.decoderStage = JxlDecoderStage.Started;
+
+        if (!this.gotSignature)
+        {
+            JxlSignature signature = DetectSignature(stream);
+            if (signature == JxlSignature.Invalid)
+            {
+                throw new InvalidOperationException("The signature is invalid.");
+            }
+
+            if (signature == JxlSignature.NotEnoughBytes)
+            {
+                if (this.inputClosed)
+                {
+                    throw new InvalidOperationException("The input is closed");
+                }
+
+                ThrowNotEnoughData();
+            }
+
+            this.gotSignature = true;
+
+            if (signature == JxlSignature.Container)
+            {
+                this.haveContainer = true;
+            }
+            else
+            {
+                this.lastCodestreamSeen = true;
+            }
+        }
+
+        int status = this.ProcessBoxes(stream);
+
+        if (status == JxlDecoderStatus.Success)
+        {
+            if (this.CanUseMoreCodestreamInput())
+            {
+                throw new InvalidOperationException("The code stream did not finish");
+            }
+
+            if (this.JbrdNeedsMoreBoxes())
+            {
+                throw new InvalidOperationException("Missing metadata boxes for JPEG reconstruction");
+            }
+        }
+    }
+
+    private static void ThrowNotEnoughData() => throw new InvalidOperationException("Not enough data");
+
+    protected override Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken) => throw new NotImplementedException();
+
+    protected override ImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken) => throw new NotImplementedException();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderStatus.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderStatus.cs
new file mode 100644
index 0000000000..93a4e0b365
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlDecoderStatus.cs
@@ -0,0 +1,87 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Pending event masks and procedure statuses used by the JPEG XL decoder.
+/// </summary>
+internal static class JxlDecoderStatus
+{
+    /// <summary>
+    /// Everything went smoothly.
+    /// </summary>
+    public const int Success = 0;
+
+    /// <summary>
+    /// An error occurred.
+    /// </summary>
+    public const int Error = 1;
+
+    /// <summary>
+    /// Not enough bytes left to continue.
+    /// </summary>
+    public const int NeedMoreInput = 2;
+
+    /// <summary>
+    /// The decoder can decode a preview image and requests setting
+    /// a preview output buffer.
+    /// </summary>
+    public const int NeedPreviewOutBuffer = 3;
+
+    /// <summary>
+    /// Not enough memory allocated for the output image buffer.
+    /// </summary>
+    public const int NeedMoreOutput = 6;
+
+    /// <summary>
+    /// Specifies an event mask for parsing the JXL basic info.
+    /// </summary>
+    public const int BasicInfo = 0x40;
+
+    /// <summary>
+    /// Specifies an event mask for parsing and decoding the ICC color profile.
+    /// </summary>
+    public const int ColorEncoding = 0x100;
+
+    /// <summary>
+    /// Specifies decoding a preview image or a small frame.
+    /// </summary>
+    public const int PreviewImage = 0x200;
+
+    /// <summary>
+    /// Specifies an event mask for decoding a single frame. This
+    /// event is called once for a still image and multiple times for
+    /// animated JPEG XLs.
+    /// </summary>
+    public const int Frame = 0x400;
+
+    /// <summary>
+    /// Specifies an event mask for decoding a full frame (or layer in case coalescing
+    /// is disabled).
+    /// </summary>
+    public const int FullImage = 0x1000;
+
+    /// <summary>
+    /// Specifies pending JXL->JPEG decoding.
+    /// </summary>
+    public const int JpegReconstruction = 0x2000;
+
+    /// <summary>
+    /// Specifies pending decompression of box data.
+    /// See <see cref="JxlBoxContentDecoder" />.
+    /// </summary>
+    public const int Box = 0x4000;
+
+    /// <summary>
+    /// Specifies an event mask for a progressive step in decoding
+    /// the frame.
+    /// </summary>
+    public const int Progression = 0x8000;
+
+    /// <summary>
+    /// Specifies an event mask that specifies a box being decoded is
+    /// now complete.
+    /// </summary>
+    public const int Complete = 0x10000;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlFrameDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlFrameDecoder.cs
new file mode 100644
index 0000000000..5e0eefc9ef
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlFrameDecoder.cs
@@ -0,0 +1,161 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO;
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal sealed class JxlFrameDecoder
+{
+    private JxlPassesDecoderState decoderState;
+    private List<JxlTocEntry> toc = [];
+    private ulong sectionSizesSum;
+    private JxlFrameHeader frameHeader;
+    private JxlFrameDimensions frameDimensions;
+    private JxlImageBundle decoded;
+    private JxlModularFrameDecoder modularFrameDecoder;
+    private bool renderSpotcolors = true;
+    private bool coalescing = true;
+    private List<byte> processedSection = [];
+    private List<byte> decodedPassesPerAcGroup = [];
+    private List<byte> decodedDcGroups = [];
+    private bool decodedDcGlobal;
+    private bool decodedAcGlobal;
+    private bool finalizedDc = true;
+    private long numSectionsDone;
+    private bool isFinalized = true;
+    private bool allocated;
+    private List<JxlGroupDecoderCache> groupDecoderCaches = [];
+    private bool useTaskId;
+    private bool useSlowRenderingPipeline;
+    private JxlProgressiveDetail progressiveDetail = JxlProgressiveDetail.Frames;
+    private List<int> passesToPause = [];
+
+    /// <summary>
+    /// Gets a value indicating whether there are any DC groups left to decode.
+    /// </summary>
+    private bool ContainsDcGroupToDecode => this.decodedDcGroups.Any(x => x == 0);
+
+    private static int GetStride(int width, JxlPixelFormat format)
+    {
+        if (!JxlMath.SafeMultiply(BytesPerChannel(format.DataType), format.Channels, out int xStride))
+        {
+            throw new InvalidOperationException("Image too large");
+        }
+
+        if (!JxlMath.SafeMultiply(xStride, width, out int yStride))
+        {
+            throw new InvalidOperationException("Image too large");
+        }
+
+        if (!JxlMath.SafeRoundUpTo(yStride, format.Align, yStride))
+        {
+            throw new InvalidOperationException("Image too large");
+        }
+
+        return yStride;
+    }
+
+    public static void DecodeGlobalDcInfo(Configuration configuration, JxlBitReader reader, bool isJpeg, JxlPassesDecoderState state)
+    {
+        state.SharedStorage.Quantizer.Decode(reader);
+
+        if (!JxlEntropyCoder.DecodeBlockContextMap(configuration, reader, ref state.SharedStorage.BlockContextMap))
+        {
+            throw new InvalidOperationException("Could not decode block context map");
+        }
+
+        if (!state.SharedStorage.ColorMap.DecodeDc(reader))
+        {
+            throw new InvalidOperationException("Could not decode DC color correlation map");
+        }
+
+        if (isJpeg)
+        {
+            state.SharedStorage.Quantizer.ClearDcMultipliers();
+        }
+
+        state.SharedStorage.AcStrategy.FillInvalid();
+    }
+
+    public static void DecodeFrame(JxlPassesDecoderState decoderState, Stream stream, ref JxlFrameHeader header, JxlImageBundle decoded, JxlCodecMetadata metadata, bool useSlowRenderingPipeline)
+    {
+        JxlFrameDecoder frameDecoder = new(decoderState, metadata, useSlowRenderingPipeline);
+        JxlBitReader reader = new(stream);
+
+        if (!frameDecoder.InitializeFrame(reader, decoded, isPreview: false))
+        {
+            throw new InvalidOperationException("Frame initialization failed");
+        }
+
+        if (!frameDecoder.InitializeFrameOutput())
+        {
+            throw new InvalidOperationException("Could not initialize frame output");
+        }
+
+        if (header is not null)
+        {
+            header = frameDecoder.frameHeader;
+        }
+
+        bool closeOk = true;
+        List<JxlBitReader> sectionReaders = [];
+        List<JxlBitReaderScopedCloser> sectionClosers = [];
+        List<JxlSectionInfo> sectionInfos = [];
+        List<JxlSectionStatus> sectionStatuses = [];
+
+        int index = 0;
+
+        foreach (JxlTocEntry toc in frameDecoder.toc)
+        {
+            JxlBitReader br = new(stream);
+            sectionInfos.Add(new JxlSectionInfo(br, toc.Id, index++));
+            sectionClosers.Add(new JxlBitReaderScopedCloser(reader, closeOk));
+            sectionReaders.Add(br);
+        }
+
+        frameDecoder.ProcessSections(sectionInfos, sectionStatuses);
+        for (int i = 0; i < sectionStatuses.Count; i++)
+        {
+            if (sectionStatuses[i] != JxlSectionStatus.Done)
+            {
+                throw new InvalidOperationException("Section incomplete");
+            }
+        }
+
+        if (!closeOk)
+        {
+            throw new InvalidDataException("Stream cannot be closed");
+        }
+
+        frameDecoder.FinalizeFrame();
+    }
+
+    private static int BytesPerChannel(JxlDataType dataType) =>
+        dataType == JxlDataType.Byte ? 1
+           : dataType == JxlDataType.Single
+              ? 4
+              : 2;
+
+    private int GetStorageLocation(int thread, int task) => this.useTaskId ? task : thread;
+
+    private void PrepareStorage(int numThreads, int numTasks)
+    {
+        int storageSize = Math.Min(numThreads, numTasks);
+        if (storageSize > this.groupDecoderCaches.Count)
+        {
+            this.groupDecoderCaches = [.. this.groupDecoderCaches.Take(storageSize)];
+        }
+
+        this.useTaskId = numThreads > numTasks;
+        bool useNoise = (this.frameHeader.Flags & (int)JxlFrameHeaderFlags.Noise) != 0;
+        bool useGroupIds = this.modularFrameDecoder.UsesFullImage && (this.frameHeader.Encoding == JxlFrameEncoding.VarDct || useNoise);
+
+        this.decoderState.RenderPipeline?.PrepareForThreads(storageSize, useGroupIds);
+        this.decoderState.Upsampler8x.PrepareForThreads(numThreads);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlGroupBorderAssigner.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlGroupBorderAssigner.cs
new file mode 100644
index 0000000000..3833c5ede2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlGroupBorderAssigner.cs
@@ -0,0 +1,330 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal sealed class JxlGroupBorderAssigner
+{
+    public const int MaxToFinalize = 3;
+
+    private readonly JxlFrameDimensions frameDim;
+    private readonly Buffer2D<int> counters;
+
+    private const byte TopLeft = 0x01;
+    private const byte TopRight = 0x02;
+    private const byte BottomRight = 0x04;
+    private const byte BottomLeft = 0x08;
+
+    public JxlGroupBorderAssigner(Configuration configuration, JxlFrameDimensions frameDim)
+    {
+        this.frameDim = frameDim;
+
+        int xSize = frameDim.XSizeGroups;
+        int ySize = frameDim.YSizeGroups;
+
+        int counterCount = (xSize + 1 + 7) / 8;
+        this.counters = configuration.MemoryAllocator.Allocate2D<int>(ySize + 1, counterCount);
+
+        void Set(int x, int y, uint corners)
+        {
+            int shift = 4 * (x & 7);
+            int bits = (int)(corners << shift);
+            this.counters[y, x / 8] |= bits;
+        }
+
+        for (int x = 0; x < xSize + 1; x++)
+        {
+            Set(x, 0, TopLeft | TopRight);
+            Set(x, ySize, BottomLeft | BottomRight);
+        }
+
+        for (int y = 0; y < ySize + 1; y++)
+        {
+            Set(0, y, TopLeft | BottomLeft);
+            Set(xSize, y, TopRight | BottomRight);
+        }
+    }
+
+    public void ClearDone(int groupId)
+    {
+        void Clear(int x, int y, uint corners)
+        {
+            int shift = 4 * (x & 7);
+            int mask = ~(int)(corners << shift);
+
+            ref int counter = ref this.counters[y, x / 8];
+            _ = Interlocked.And(ref counter, mask);
+        }
+
+        (int x, int y) = Math.DivRem(groupId, this.frameDim.XSizeGroups);
+
+        Clear(x, y, BottomRight);
+        Clear(x + 1, y, BottomLeft);
+        Clear(x, y + 1, TopRight);
+        Clear(x + 1, y + 1, TopLeft);
+    }
+
+    public void GroupDone(int groupId, int padx, int pady, Span<Rectangle> rectsToFinalize, out int numToFinalize)
+    {
+        (int x, int y) = Math.DivRem(groupId, this.frameDim.XSizeGroups);
+
+        Rectangle blockRect = RectangleUtils.CreateRectangle(
+            x * this.frameDim.GroupDimension / JxlFrameDimensions.BlockDimensions,
+            y * this.frameDim.GroupDimension / JxlFrameDimensions.BlockDimensions,
+            this.frameDim.GroupDimension / JxlFrameDimensions.BlockDimensions,
+            this.frameDim.GroupDimension / JxlFrameDimensions.BlockDimensions,
+            this.frameDim.XSizeBlocks,
+            this.frameDim.YSizeBlocks);
+
+        int FetchStatus(int cx, int cy, uint bit)
+        {
+            int shift = 4 * (cx & 7);
+            int bits = (int)(bit << shift);
+
+            ref int counter = ref this.counters[cy, cx / 8];
+
+            int status = Interlocked.Or(ref counter, bits);
+            status >>= shift;
+
+            return (int)((bit | (uint)status) & 0xF);
+        }
+
+        int topLeftStatus = FetchStatus(x, y, BottomRight);
+        int topRightStatus = FetchStatus(x + 1, y, BottomLeft);
+        int bottomRightStatus = FetchStatus(x + 1, y + 1, TopLeft);
+        int bottomLeftStatus = FetchStatus(x, y + 1, TopRight);
+
+        int x1 = blockRect.X + blockRect.Width;
+        int y1 = blockRect.Y + blockRect.Height;
+
+        bool isLastGroupX = this.frameDim.XSizeGroups == x + 1;
+        bool isLastGroupY = this.frameDim.YSizeGroups == y + 1;
+
+        Span<int> xpos =
+        [
+            blockRect.X == 0
+                ? 0
+                : (blockRect.X * JxlFrameDimensions.BlockDimensions) - padx,
+
+            blockRect.X == 0
+                ? 0
+                : Math.Min(
+                    this.frameDim.XSize,
+                    (blockRect.X * JxlFrameDimensions.BlockDimensions) + padx),
+
+            isLastGroupX
+                ? this.frameDim.XSize
+                : (x1 * JxlFrameDimensions.BlockDimensions) - padx,
+
+            Math.Min(
+                this.frameDim.XSize,
+                (x1 * JxlFrameDimensions.BlockDimensions) + padx)
+        ];
+
+        Span<int> ypos =
+        [
+            blockRect.Y == 0
+                ? 0
+                : (blockRect.Y * JxlFrameDimensions.BlockDimensions) - pady,
+
+            blockRect.Y == 0
+                ? 0
+                : Math.Min(
+                     this.frameDim.YSize,
+                     (blockRect.Y * JxlFrameDimensions.BlockDimensions) + pady),
+
+            isLastGroupY
+                ? this.frameDim.YSize
+                : (y1 * JxlFrameDimensions.BlockDimensions) - pady,
+
+            Math.Min(
+                 this.frameDim.YSize,
+                 (y1 * JxlFrameDimensions.BlockDimensions) + pady)
+        ];
+
+        numToFinalize = 0;
+
+        void AppendRect(int x0, int x1, int y0, int y1, ref int numToFinalize, Span<Rectangle> rectsToFinalize, Span<int> xpos, Span<int> ypos)
+        {
+            Rectangle rect = new(
+                xpos[x0],
+                ypos[y0],
+                xpos[x1] - xpos[x0],
+                ypos[y1] - ypos[y0]);
+
+            if (rect.Width == 0 || rect.Height == 0)
+            {
+                return;
+            }
+
+            rectsToFinalize[numToFinalize++] = rect;
+        }
+
+        bool[,] availablePartsMask = new bool[3, 3];
+
+        // Center
+        availablePartsMask[1, 1] = true;
+
+        // Corners
+        if (topLeftStatus == 0xF)
+        {
+            availablePartsMask[0, 0] = true;
+        }
+
+        if (topRightStatus == 0xF)
+        {
+            availablePartsMask[2, 0] = true;
+        }
+
+        if (bottomRightStatus == 0xF)
+        {
+            availablePartsMask[2, 2] = true;
+        }
+
+        if (bottomLeftStatus == 0xF)
+        {
+            availablePartsMask[0, 2] = true;
+        }
+
+        // Other borders
+        if ((topLeftStatus & TopRight) != 0)
+        {
+            availablePartsMask[1, 0] = true;
+        }
+
+        if ((topLeftStatus & BottomLeft) != 0)
+        {
+            availablePartsMask[0, 1] = true;
+        }
+
+        if ((topRightStatus & BottomRight) != 0)
+        {
+            availablePartsMask[2, 1] = true;
+        }
+
+        if ((bottomLeftStatus & BottomRight) != 0)
+        {
+            availablePartsMask[1, 2] = true;
+        }
+
+        const int noSegment = 3;
+
+        Span<(int First, int Last)> horizontalSegments =
+        [
+            (noSegment, noSegment),
+            (noSegment, noSegment),
+            (noSegment, noSegment)
+        ];
+
+        for (int py = 0; py < 3; py++)
+        {
+            for (int px = 0; px < 3; px++)
+            {
+                if (!availablePartsMask[px, py])
+                {
+                    continue;
+                }
+
+                if (horizontalSegments[py].First == noSegment)
+                {
+                    horizontalSegments[py] = (px, horizontalSegments[py].Last);
+                }
+
+                horizontalSegments[py] = (horizontalSegments[py].First, px + 1);
+            }
+        }
+
+        if (horizontalSegments[0] == horizontalSegments[1] &&
+            horizontalSegments[0] == horizontalSegments[2])
+        {
+            AppendRect(
+                horizontalSegments[0].First,
+                horizontalSegments[0].Last,
+                0,
+                3,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+        }
+        else if (horizontalSegments[0] == horizontalSegments[1])
+        {
+            AppendRect(
+                horizontalSegments[0].First,
+                horizontalSegments[0].Last,
+                0,
+                2,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+
+            AppendRect(
+                horizontalSegments[2].First,
+                horizontalSegments[2].Last,
+                2,
+                3,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+        }
+        else if (horizontalSegments[1] == horizontalSegments[2])
+        {
+            AppendRect(
+                horizontalSegments[0].First,
+                horizontalSegments[0].Last,
+                0,
+                1,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+
+            AppendRect(
+                horizontalSegments[1].First,
+                horizontalSegments[1].Last,
+                1,
+                3,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+        }
+        else
+        {
+            AppendRect(
+                horizontalSegments[0].First,
+                horizontalSegments[0].Last,
+                0,
+                1,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+
+            AppendRect(
+                horizontalSegments[1].First,
+                horizontalSegments[1].Last,
+                1,
+                2,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+
+            AppendRect(
+                horizontalSegments[2].First,
+                horizontalSegments[2].Last,
+                2,
+                3,
+                ref numToFinalize,
+                rectsToFinalize,
+                xpos,
+                ypos);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlGroupDecoderCache.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlGroupDecoderCache.cs
new file mode 100644
index 0000000000..f82e332d8d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlGroupDecoderCache.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Cache for the JPEG XL Group Decoder.
+/// </summary>
+internal sealed class JxlGroupDecoderCache
+{
+
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlHuffmanDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlHuffmanDecoder.cs
new file mode 100644
index 0000000000..7201a511aa
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlHuffmanDecoder.cs
@@ -0,0 +1,332 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Formats.Jxl.IO;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Decodes Huffman codes.
+/// </summary>
+internal sealed class JxlHuffmanDecoder
+{
+    /// <summary>
+    /// Number of bits that a huffman table uses.
+    /// </summary>
+    private const int HuffmanTableBits = 8;
+
+    private const int GoalSize = 1 << HuffmanTableBits;
+
+    public const int CodeLengthCodes = 18;
+
+    public const int DefaultCodeLength = 8;
+
+    public const int CodeLengthRepeatCode = 16;
+
+    /// <summary>
+    /// Static Huffman codes for code length code lengths.
+    /// </summary>
+    private static readonly JxlHuffmanCode[] CodeLengthCodeLengthsCodes =
+    [
+        new(2, 0), new(2, 4), new(2, 3), new(3, 2), new(2, 0), new(2, 4), new(2, 3), new(4, 1),
+        new(2, 0), new(2, 4), new(2, 3), new(3, 2), new(2, 0), new(2, 4), new(2, 3), new(4, 5),
+    ];
+
+    private static ReadOnlySpan<byte> CodeLengthCodeOrder =>
+    [
+        1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    ];
+
+    /// <summary>
+    /// Gets or sets the list of huffman codes.
+    /// </summary>
+    public JxlHuffmanCode[] Table { get; set; } = [];
+
+    public static bool ReadHuffmanCodeLengths(Span<byte> codeLengthCodeLengths, int numSymbols, Span<byte> codeLengths, JxlBitReader br)
+    {
+        int symbol = 0;
+        int prevCodeLen = DefaultCodeLength;
+        int repeat = 0;
+        int repeatCodeLen = 0;
+        int space = 32768;
+
+        Span<JxlHuffmanCode> table = stackalloc JxlHuffmanCode[32];
+        Span<ushort> counts = stackalloc ushort[16];
+        table.Clear();
+        counts.Clear();
+
+        for (int i = 0; i < CodeLengthCodes; i++)
+        {
+            counts[codeLengthCodeLengths[i]]++;
+        }
+
+        if (JxlHuffman.BuildHuffmanTable(table, 5, codeLengthCodeLengths, counts) == 0)
+        {
+            return false;
+        }
+
+        while (symbol < numSymbols && space > 0)
+        {
+            JxlHuffmanCode code = table[(int)br.PeekBits32(5u)];
+            br.SkipBits32(code.Bits);
+            byte codeLength = (byte)code.Value;     // It is indeed converted from ushort to byte
+
+            if (codeLength < CodeLengthRepeatCode)
+            {
+                repeat = 0;
+                codeLengths[symbol++] = codeLength;
+                if (codeLength != 0)
+                {
+                    prevCodeLen = codeLength;
+                    space -= 32768 >> codeLength;
+                }
+            }
+            else
+            {
+                int extraBits = codeLength - 14;
+                byte newLength = 0;
+                if (codeLength == CodeLengthRepeatCode)
+                {
+                    newLength = (byte)prevCodeLen;
+                }
+
+                if (repeatCodeLen != newLength)
+                {
+                    repeat = 0;
+                    repeatCodeLen = newLength;
+                }
+
+                int oldRepeat = repeat;
+
+                if (repeat > 0)
+                {
+                    repeat -= 2;
+                    repeat <<= extraBits;
+                }
+
+                repeat += (int)br.ReadBits32((uint)extraBits) + 3;
+                int repeatDelta = repeat - oldRepeat;
+
+                if (symbol + repeatDelta > numSymbols)
+                {
+                    return false;
+                }
+
+                codeLengths.Slice(symbol, repeatDelta).Fill((byte)repeatCodeLen);
+                symbol += repeatDelta;
+                if (repeatCodeLen != 0)
+                {
+                    space -= repeatDelta << (15 - repeatCodeLen);
+                }
+            }
+        }
+
+        if (space != 0)
+        {
+            return false;
+        }
+
+        codeLengths[symbol..].Clear();
+        return true;
+    }
+
+    /// <summary>
+    /// Reads a simple Huffman code.
+    /// </summary>
+    /// <param name="alphabetSize">Alphabet size (256 at most)</param>
+    /// <param name="br">Bit-stream reader</param>
+    /// <param name="table">Output table (must have at most 8 items)</param>
+    /// <returns>Status of the operation</returns>
+    public static bool ReadSimpleCode(int alphabetSize, JxlBitReader br, Span<JxlHuffmanCode> table)
+    {
+        int maxBits = (alphabetSize > 1) ? JxlMath.FloorLog2Nonzero(alphabetSize - 1) + 1 : 0;
+        uint symbolCount = br.ReadBits32(2u) + 1u;
+
+        scoped Span<ushort> symbols = stackalloc ushort[4];
+        symbols.Clear();    // Clearing is necessary. Not every value will be initialized.
+
+        for (int i = 0; i < symbolCount; i++)
+        {
+            uint symbol = br.ReadBits32((uint)maxBits);
+            if (symbol >= alphabetSize)
+            {
+                return false;
+            }
+
+            symbols[i] = (ushort)symbol;
+        }
+
+        for (int i = 0; i < symbolCount - 1; i++)
+        {
+            for (int j = i + 1; j < symbolCount; j++)
+            {
+                if (symbols[i] == symbols[j])
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (symbolCount == 4)
+        {
+            symbolCount += br.ReadBits32(1u);
+        }
+
+        int tableSize = 1;
+        switch (symbolCount)
+        {
+            case 1:
+                table[0] = new(0, symbols[0]);
+                break;
+
+            case 2:
+                if (symbols[0] > symbols[1])
+                {
+                    SwapSymbols(0, 1, symbols);
+                }
+
+                table[0] = new(1, symbols[0]);
+                table[1] = new(1, symbols[1]);
+                tableSize = 2;
+                break;
+
+            case 3:
+                if (symbols[1] > symbols[2])
+                {
+                    SwapSymbols(1, 2, symbols);
+                }
+
+                table[0] = new(1, symbols[0]);
+                table[2] = new(1, symbols[0]);
+                table[1] = new(2, symbols[1]);
+                table[3] = new(2, symbols[2]);
+                tableSize = 4;
+                break;
+
+            case 4:
+                for (int i = 0; i < 3; i++)
+                {
+                    for (int j = i + 1; j < 4; j++)
+                    {
+                        if (symbols[i] > symbols[j])
+                        {
+                            SwapSymbols(i, j, symbols);
+                        }
+                    }
+                }
+
+                table[0] = new(2, symbols[0]);
+                table[2] = new(2, symbols[1]);
+                table[1] = new(2, symbols[2]);
+                table[3] = new(2, symbols[3]);
+                tableSize = 4;
+                break;
+
+            case 5:
+                if (symbols[2] > symbols[3])
+                {
+                    SwapSymbols(2, 3, symbols);
+                }
+
+                table[0] = new(1, symbols[0]);
+                table[1] = new(2, symbols[1]);
+                table[2] = new(1, symbols[0]);
+                table[3] = new(3, symbols[2]);
+                table[4] = new(1, symbols[0]);
+                table[5] = new(2, symbols[1]);
+                table[6] = new(1, symbols[0]);
+                table[7] = new(3, symbols[3]);
+                tableSize = 8;
+                break;
+
+            default:
+                // This should be unreachable.
+                return false;
+        }
+
+        while (tableSize != GoalSize)
+        {
+            table[tableSize..].CopyTo(table);
+            tableSize <<= 1;
+        }
+
+        return true;
+    }
+
+    public bool ReadFromBitStream(int alphabetSize, JxlBitReader br)
+    {
+        if (alphabetSize > (1 << JxlAnsConstants.PrefixMaxBits))
+        {
+            return false;
+        }
+
+        uint simpleCodeOrSkip = br.ReadBits32(2u);
+        if (simpleCodeOrSkip == 1u)
+        {
+            this.Table = new JxlHuffmanCode[GoalSize];
+            return ReadSimpleCode(alphabetSize, br, this.Table);
+        }
+
+        DebugGuard.MustBeLessThanOrEqualTo(alphabetSize, 256, nameof(alphabetSize));
+
+        Span<byte> codeLengths = stackalloc byte[256].Slice(0, alphabetSize);
+        codeLengths.Clear();    // Zero-initialized in reference software
+
+        Span<byte> codeLengthCodeLengths = stackalloc byte[CodeLengthCodes];
+        codeLengthCodeLengths.Clear();  // Zero-initialized in reference software
+
+        int space = 32;
+        int numCodes = 0;
+
+        for (uint i = simpleCodeOrSkip; i < CodeLengthCodes && space > 0; i++)
+        {
+            int codeLengthIndex = CodeLengthCodeOrder[(int)i];
+            JxlHuffmanCode huff = CodeLengthCodeLengthsCodes[(int)br.PeekBits32(4u)];
+            br.SkipBits32(huff.Bits);
+            byte value = (byte)huff.Value;  // It's indeed converted from ushort to byte
+            codeLengthCodeLengths[codeLengthIndex] = value;
+
+            if (value != 0)
+            {
+                space -= 32 >> value;
+                numCodes++;
+            }
+        }
+
+        bool ok = (numCodes == 1 || space == 0) && ReadHuffmanCodeLengths(codeLengthCodeLengths, alphabetSize, codeLengths, br);
+
+        if (!ok)
+        {
+            return false;
+        }
+
+        Span<ushort> counts = stackalloc ushort[16];
+        counts.Clear();     // Zero-initialized
+
+        this.Table = new JxlHuffmanCode[alphabetSize + 376];
+        uint tableSize = JxlHuffman.BuildHuffmanTable(this.Table, HuffmanTableBits, codeLengths, counts);
+
+        this.Table = this.Table[..(int)tableSize];
+
+        return tableSize > 0;
+    }
+
+    public ushort ReadSymbol(JxlBitReader br)
+    {
+        Span<JxlHuffmanCode> table = this.Table.AsSpan()[(int)br.PeekBits32(HuffmanTableBits)..];
+        int bitCount = table[0].Bits;
+        if (bitCount > HuffmanTableBits)
+        {
+            br.SkipBits32(HuffmanTableBits);
+            bitCount -= HuffmanTableBits;
+            table = table[(int)(table[0].Value + br.PeekBits32((uint)bitCount))..];
+        }
+
+        br.SkipBits32(table[0].Bits);
+        return table[0].Value;
+    }
+
+    private static void SwapSymbols(int i, int j, Span<ushort> symbols) => RuntimeUtility.Swap(ref symbols[i], ref symbols[j]);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlNoiseDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlNoiseDecoder.cs
new file mode 100644
index 0000000000..47e685bdfc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlNoiseDecoder.cs
@@ -0,0 +1,150 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Net.NetworkInformation;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.Formats.Tiff.Utils;
+using static System.Net.Mime.MediaTypeNames;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal static class JxlNoiseDecoder
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void BitsToFloatingPoint(ReadOnlySpan<uint> randomBits, Span<float> floats)
+    {
+        Vector<uint> bits = new(randomBits);
+        Vector<float> rand12 = ((bits >> 9) | new Vector<uint>(0x3F800000u)).As<uint, float>();
+        rand12.StoreUnsafe(ref MemoryMarshal.GetReference(floats));
+    }
+
+    public static void GenerateRandomImage(JxlXorShift rng, Rectangle rectangle, JxlImageF noise)
+    {
+        const int floatsPerBatch = JxlXorShift.Generators * sizeof(ulong) / sizeof(float);
+
+        int xSize = rectangle.Width;
+        int ySize = rectangle.Height;
+
+        Span<ulong> batch64 = stackalloc ulong[JxlXorShift.Generators];
+        Span<uint> batch32 = stackalloc uint[JxlXorShift.Generators * 2];
+
+        // stackalloc doesn't zero-initialize, so clear values
+        batch64.Clear();
+        batch32.Clear();
+
+        int n = Vector<float>.Count;
+
+        for (int y = 0; y < ySize; y++)
+        {
+            Span<float> row = noise.GetRow(rectangle, y);
+            int x = 0;
+            for (; x + floatsPerBatch < xSize; x += floatsPerBatch)
+            {
+                rng.Fill(batch64);
+                MemoryMarshal.Cast<uint, ulong>(batch32).CopyTo(batch64);
+                for (int i = 0; i < floatsPerBatch; i += n)
+                {
+                    BitsToFloatingPoint(batch32[i..], row[(x + i)..]);
+                }
+            }
+
+            rng.Fill(batch64);
+            MemoryMarshal.Cast<uint, ulong>(batch32).CopyTo(batch64);
+
+            int batchPos = 0;
+
+            for (; x < xSize; x += n)
+            {
+                BitsToFloatingPoint(batch32[batchPos..], row[x..]);
+                batchPos += n;
+            }
+        }
+    }
+
+    public static void Random3Planes(
+        int visibleFrameIndex,
+        int nonVisibleFrameIndex,
+        int x0,
+        int y0,
+        (JxlImageF Image, Rectangle Bounds) plane0,
+        (JxlImageF Image, Rectangle Bounds) plane1,
+        (JxlImageF Image, Rectangle Bounds) plane2)
+    {
+        JxlXorShift rng = new((uint)visibleFrameIndex, (uint)nonVisibleFrameIndex, (uint)x0, (uint)y0);
+
+        GenerateRandomImage(rng, plane0.Bounds, plane0.Image);
+        GenerateRandomImage(rng, plane1.Bounds, plane1.Image);
+        GenerateRandomImage(rng, plane2.Bounds, plane2.Image);
+    }
+
+    private static void PrepareNoiseInput(
+        JxlPassesDecoderState decState,
+        JxlFrameDimensions frameDim,
+        JxlFrameHeader frameHeader,
+        int groupIndex,
+        int thread)
+    {
+        int groupDim = frameDim.GroupDimension;
+
+        int gx = groupIndex % frameDim.XSizeGroups;
+        int gy = groupIndex / frameDim.XSizeGroups;
+
+        JxlRenderPipelineInput input = decState.RenderPipeline.GetInputBuffers(groupIndex, thread);
+        int noiseCStart = 3 + frameHeader.Metadata!.ImageMetadata!.ExtraChannelCount;
+
+        InlineArray3<(JxlImageF Image, Rectangle Rect)> rects = default;
+
+        for (int iy = 0; iy < frameHeader.Upsampling; iy++)
+        {
+            for (int ix = 0; ix < frameHeader.Upsampling; ix++)
+            {
+                for (int c = 0; c < 3; c++)
+                {
+                    var r = input.GetBuffer(noiseCStart + c);
+
+                    int x1 = r.Rect.X0 + r.Rect.XSize;
+                    int y1 = r.Rect.Y0 + r.Rect.YSize;
+
+                    rects[c] = (
+                        r.Image,
+                        RectangleUtils.CreateRectangle(
+                            r.Rect.X0 + (ix * groupDim),
+                            r.Rect.Y0 + (iy * groupDim),
+                            groupDim,
+                            groupDim,
+                            x1,
+                            y1));
+                }
+
+                Random3Planes(
+                    decState.VisibleFrameIndex,
+                    decState.NonvisibleFrameIndex,
+                    (int)((gx * frameHeader.Upsampling) + ix) * groupDim,
+                    (int)((gy * frameHeader.Upsampling) + iy) * groupDim,
+                    rects[0],
+                    rects[1],
+                    rects[2]);
+            }
+        }
+    }
+
+    public static float DecodeFloatParam(float precision, JxlBitReader br)
+    {
+        int absValQuant = (int)br.ReadBits32(10);
+        return absValQuant / precision;
+    }
+
+    public static void DecodeNoise(JxlBitReader br, JxlNoiseParameters noiseParams)
+    {
+        for (int i = 0; i < noiseParams.Lookup.Length; i++)
+        {
+            noiseParams.Lookup[i] = DecodeFloatParam(JxlNoiseConstants.Precision, br);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlOpsinParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlOpsinParameters.cs
new file mode 100644
index 0000000000..6fdfa28f9f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlOpsinParameters.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#pragma warning disable SA1401 // Fields should be private
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal sealed class JxlOpsinParameters
+{
+    public InlineArray36<float> InverseOpsinMatrix;
+
+    public InlineArray4<float> OpsinBiases;
+
+    public InlineArray4<float> OpsinBiasesCbrt;
+
+    public InlineArray4<float> QuantBiases;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlOutputEncodingInfo.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlOutputEncodingInfo.cs
new file mode 100644
index 0000000000..616d7ceeb8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlOutputEncodingInfo.cs
@@ -0,0 +1,79 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+// Prefer class instead of struct because it's too large for a struct
+// Note that this struct wasn't well documented, so it's not that easy to add
+// XML documentation here.
+internal sealed class JxlOutputEncodingInfo
+{
+    public JxlColorEncoding? OriginalColorEncoding { get; set; }
+
+    public float OriginalIntensityTarget { get; set; }
+
+    public JxlMatrix3x3F OriginalInverseMatrix { get; set; }
+
+    public bool DefaultTransform { get; set; }
+
+    public bool XybEncoded { get; set; }
+
+    /// <summary>
+    /// Gets or sets the requested color encoding.
+    /// </summary>
+    public JxlColorEncoding ColorEncoding { get; set; } = new();
+
+    public JxlColorEncoding LinearColorEncoding { get; set; } = new();
+
+    public bool ColorEncodingIsOriginal { get; set; }
+
+    public JxlOpsinParameters OpsinParameters { get; set; } = new();
+
+    public bool AllDefaultOpsin { get; set; }
+
+    public float InverseGamma { get; set; }
+
+    public Vector3 Luminances { get; set; }
+
+    public float DesiredIntensityTarget { get; set; }
+
+    public bool CmsSet { get; set; }
+
+    public JxlCmsInterface Cms { get; set; }
+
+    public void SetFromMetadata(JxlCodecMetadata metadata)
+    {
+        JxlImageMetadata imageMetadata = metadata.ImageMetadata ?? throw new InvalidOperationException("Missing image metadata");
+
+        this.OriginalColorEncoding = imageMetadata.ColorEncoding;
+        this.OriginalIntensityTarget = imageMetadata.IntensityTarget;
+        this.DesiredIntensityTarget = this.OriginalIntensityTarget;
+
+        JxlOpsinInverseMatrix inverseMatrix = metadata.CustomTransformData?.OpsinInverseMatrix ?? throw new InvalidOperationException("Missing Opsin inverse matrix or transform data");
+        this.OriginalInverseMatrix = inverseMatrix.InverseMatrix;
+        this.DefaultTransform = inverseMatrix.AllDefault;
+        this.XybEncoded = imageMetadata.XybEncoded;
+
+        JxlOpsinParameters parameters = this.OpsinParameters;
+
+        imageMetadata.OpsinBiases.CopyTo(parameters.OpsinBiases);
+        parameters.OpsinBiasesCbrt[0] = MathF.Cbrt(parameters.OpsinBiases[0]);
+        parameters.OpsinBiasesCbrt[1] = MathF.Cbrt(parameters.OpsinBiases[1]);
+        parameters.OpsinBiasesCbrt[2] = MathF.Cbrt(parameters.OpsinBiases[2]);
+
+        parameters.OpsinBiasesCbrt[3] = 1;
+        parameters.OpsinBiases[3] = 1;
+
+        inverseMatrix.QuantBiases.AsSpan().CopyTo(parameters.QuantBiases);
+
+        bool origOK = JxlXybDecoder.CanOutputToColorEncoding(this.OriginalColorEncoding ?? throw new InvalidCastException("Missing color encoding"));
+        bool origGrey = this.OriginalColorEncoding.IsGray;
+
+        return this.SetColorEncoding(!this.XybEncoded || origOK ? this.OriginalColorEncoding : JxlColorEncoding.LinearSrgb(origGrey));
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlPassesDecoderState.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlPassesDecoderState.cs
new file mode 100644
index 0000000000..adc70f36c3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlPassesDecoderState.cs
@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal sealed class JxlPassesDecoderState
+{
+    public JxlPassesDecoderState(JxlFrameHeader header, Configuration configuration)
+    {
+        this.XDmMultiplier = MathF.Pow(1 / 1.25f, header.XQmScale - 2f);
+        this.BDmMultiplier = MathF.Pow(1 / 1.25f, header.BQmScale - 2f);
+
+        this.MainOutput.Callback = PixelCallback;
+        this.MainOutput.Buffer = null;
+
+        this.UndoOrientation = JxlOrientation.Identity;
+        this.Upsampler8x = GetUpsamplingImage(configuration, this.Shared.CodecMetadata.CustomTransformData, 0, 3);
+
+        if (header.LoopFilter?.EpfIterations > 0)
+        {
+            this.Sigma = new JxlImageF(
+                configuration,
+                (this.Shared.FrameDimensions.XSizeBlocks + 2) * SigmaPadding,
+                (this.Shared.FrameDimensions.YSizeBlocks + 2) * SigmaPadding);
+        }
+
+        this.SharedStorage = new(configuration, header, false);
+        this.Shared = this.SharedStorage;
+    }
+
+    public JxlPassesSharedState SharedStorage { get; set; }
+
+    public JxlPassesSharedState Shared { get; set; }
+
+    public JxlRenderPipelineStage[] Upsampler8x { get; set; } = [];
+
+    public List<JxlAnsCode> Code { get; set; } = [];
+
+    public List<List<byte>> ContextMap { get; set; } = [];
+
+    public float XDmMultiplier { get; set; }
+
+    public float BDmMultiplier { get; set; }
+
+    public JxlImageF? Sigma { get; set; }
+
+    public int Width { get; set; }
+
+    public int Height { get; set; }
+
+    public JxlImageOutput MainOutput { get; set; }
+
+    public List<JxlImageOutput> ExtraOutput { get; set; } = [];
+
+    public bool FastXybSRgb8Conversion { get; set; }
+
+    public bool UnpremultiplyAlpha { get; set; }
+
+    public JxlOrientation UndoOrientation { get; set; }
+
+    public int VisibleFrameIndex { get; set; }
+
+    public int NonvisibleFrameIndex { get; set; }
+
+    public int UsedAcs { get; set; }
+
+    public JxlDctAcImage<int> Coefficients { get; set; } = [];
+
+    public JxlRenderPipeline RenderPipeline { get; set; }
+
+    public JxlImageBundle FrameStorageForReferencing { get; set; }
+
+    public JxlOutputEncodingInfo OutputEncodingInfo { get; set; } = new();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlProgressiveDetail.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlProgressiveDetail.cs
new file mode 100644
index 0000000000..70c3a4679a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlProgressiveDetail.cs
@@ -0,0 +1,47 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Types of progressive detail.
+/// </summary>
+internal enum JxlProgressiveDetail : byte
+{
+    /// <summary>
+    /// After completed regular frames
+    /// </summary>
+    Frames,
+
+    /// <summary>
+    /// After completed DC.
+    /// </summary>
+    Dc,
+
+    /// <summary>
+    /// After completed AC passes that are the last pass for their
+    /// resolution target.
+    /// </summary>
+    LastPasses,
+
+    /// <summary>
+    /// After completed AC passes that are not the last pass for their
+    /// resolution target.
+    /// </summary>
+    Passes,
+
+    /// <summary>
+    /// During DC frame when lower resolution are completed.
+    /// </summary>
+    DcProgressive,
+
+    /// <summary>
+    /// After completed groups.
+    /// </summary>
+    DcGroups,
+
+    /// <summary>
+    /// After completed groups.
+    /// </summary>
+    Groups,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlSectionInfo.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlSectionInfo.cs
new file mode 100644
index 0000000000..4637bacbda
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlSectionInfo.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal sealed class JxlSectionInfo(JxlBitReader reader, int id, int index)
+{
+    public JxlBitReader BitReader { get; set; } = reader;
+
+    public int Id { get; set; } = id;
+
+    public int Index { get; set; } = index;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlSectionStatus.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlSectionStatus.cs
new file mode 100644
index 0000000000..eefcf9ad90
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlSectionStatus.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Status of processing a section.
+/// </summary>
+internal enum JxlSectionStatus : byte
+{
+    /// <summary>
+    /// Processed normally.
+    /// </summary>
+    Done,
+
+    /// <summary>
+    /// Skipped because other required sections were not yet processed.
+    /// </summary>
+    Skipped,
+
+    /// <summary>
+    /// Skipped because the section was already processed.
+    /// </summary>
+    Duplicate,
+
+    /// <summary>
+    /// Only partially decoded. Section will be processed again.
+    /// </summary>
+    Partial
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlToJpegDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlToJpegDecoder.cs
new file mode 100644
index 0000000000..995b74852a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlToJpegDecoder.cs
@@ -0,0 +1,150 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal class JxlToJpegDecoder
+{
+    /// <summary>
+    /// Returns the number of EXIF markers in the JPEG file.
+    /// </summary>
+    /// <param name="jpegData">Input parsed JPEG data</param>
+    /// <returns>Number of EXIFs in the JPEG</returns>
+    public static int NumExifMarkers(JpegData jpegData) => jpegData.AppMarkerTypes.Count(x => x == JpegAppMarkerType.Exif);
+
+    /// <summary>
+    /// Returns the number of XMP markers in the JPEG file.
+    /// </summary>
+    /// <param name="jpegData">Input parsed JPEG data</param>
+    /// <returns>Number of XMPs in the JPEG</returns>
+    public static int NumXmpMarkers(JpegData jpegData) => jpegData.AppMarkerTypes.Count(x => x == JpegAppMarkerType.Xmp);
+
+    /// <summary>
+    /// Attempts to set EXIF data in the JPEG file.
+    /// </summary>
+    /// <param name="data">EXIF data</param>
+    /// <param name="jpegData">JPEG file for EXIF data</param>
+    /// <returns>If EXIF data was set, true; returns false if no EXIF marker is present, or is present but not enough data</returns>
+    public static bool TrySetExif(Span<byte> data, JpegData jpegData)
+    {
+        int size = data.Length;
+        ReadOnlySpan<byte> exifTag = JpegDataConstants.ExifTag;
+        int exifTagSize = exifTag.Length;
+
+        for (int i = 0; i < jpegData.AppData.Count; ++i)
+        {
+            if (jpegData.AppMarkerTypes[i] == JpegAppMarkerType.Exif)
+            {
+                Span<byte> dataSpan = CollectionsMarshal.AsSpan(jpegData.AppData[i]);
+
+                if (dataSpan.Length != size + 3 + exifTagSize - 4)
+                {
+                    return false;
+                }
+
+                // The first 9 bytes are used for JPEG marker header.
+                dataSpan[0] = 0xE1;
+
+                // The second and third byte are already filled in correctly
+                exifTag.CopyTo(dataSpan[3..]);
+
+                // The first 4 bytes are the TIFF header from the box contents, and are
+                // not included in the JPEG
+                data[4..].CopyTo(dataSpan[(3 + exifTagSize)..]);
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Attempts to set XMP data in the JPEG file.
+    /// </summary>
+    /// <param name="data">XMP data</param>
+    /// <param name="jpegData">JPEG file for XMP data</param>
+    /// <returns>If XMP data was set, true; returns false if no XMP marker is present, or is present but not enough data</returns>
+    public static bool TrySetXmp(Span<byte> data, JpegData jpegData)
+    {
+        int size = data.Length;
+        ReadOnlySpan<byte> xmpTag = JpegDataConstants.XmpTag;
+        int xmpTagSize = xmpTag.Length;
+
+        for (int i = 0; i < jpegData.AppData.Count; ++i)
+        {
+            if (jpegData.AppMarkerTypes[i] == JpegAppMarkerType.Xmp)
+            {
+                Span<byte> dataSpan = CollectionsMarshal.AsSpan(jpegData.AppData[i]);
+
+                if (dataSpan.Length != size + 3 + xmpTagSize)
+                {
+                    return false;
+                }
+
+                // The first 9 bytes are used for JPEG marker header.
+                dataSpan[0] = 0xE1;
+
+                // The second and third byte are already filled in correctly
+                xmpTag.CopyTo(dataSpan[3..]);
+
+                data.CopyTo(dataSpan[(3 + xmpTagSize)..]);
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static bool ExifBoxContentSize(JpegData jpegData, ref long size)
+    {
+        size = 0;
+        int exifTagLength = JpegDataConstants.ExifTag.Length;
+
+        for (int i = 0; i < jpegData.AppData.Count; ++i)
+        {
+            if (jpegData.AppMarkerTypes[i] == JpegAppMarkerType.Exif)
+            {
+                if (jpegData.AppData[i].Count < 3 + exifTagLength)
+                {
+                    // too small for app marker header
+                    return false;
+                }
+
+                // The first 4 bytes are the TIFF header from the box contents, and are
+                // not included in the JPEG
+                size = jpegData.AppData[i].Count + 4 - 3 - exifTagLength;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static bool XmpBoxContentSize(JpegData jpegData, ref long size)
+    {
+        size = 0;
+        int xmpTagLength = JpegDataConstants.XmpTag.Length;
+
+        for (int i = 0; i < jpegData.AppData.Count; ++i)
+        {
+            if (jpegData.AppMarkerTypes[i] == JpegAppMarkerType.Xmp)
+            {
+                if (jpegData.AppData[i].Count < 3 + xmpTagLength)
+                {
+                    // too small for app marker header
+                    return false;
+                }
+
+                size = jpegData.AppData[i].Count - 3 - xmpTagLength;
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlTocEntry.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlTocEntry.cs
new file mode 100644
index 0000000000..4e0cfac6bc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlTocEntry.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal struct JxlTocEntry
+{
+    public int Size;
+
+    public int Id;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlTransformsDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlTransformsDecoder.cs
new file mode 100644
index 0000000000..42304d1894
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlTransformsDecoder.cs
@@ -0,0 +1,1215 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+internal static class JxlTransformsDecoder
+{
+    /// <summary>
+    /// Lookup for the inverse AFV transform.
+    /// </summary>
+    private static readonly float[][] AfvBasis4x4 =
+    [
+        [
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+            0.25f,
+        ],
+        [
+            0.876902929799142f,
+            0.2206518106944235f,
+            -0.10140050393753763f,
+            -0.1014005039375375f,
+            0.2206518106944236f,
+            -0.10140050393753777f,
+            -0.10140050393753772f,
+            -0.10140050393753763f,
+            -0.10140050393753758f,
+            -0.10140050393753769f,
+            -0.1014005039375375f,
+            -0.10140050393753768f,
+            -0.10140050393753768f,
+            -0.10140050393753759f,
+            -0.10140050393753763f,
+            -0.10140050393753741f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            0.40670075830260755f,
+            0.44444816619734445f,
+            0.0f,
+            0.0f,
+            0.19574399372042936f,
+            0.2929100136981264f,
+            -0.40670075830260716f,
+            -0.19574399372042872f,
+            0.0f,
+            0.11379074460448091f,
+            -0.44444816619734384f,
+            -0.29291001369812636f,
+            -0.1137907446044814f,
+            0.0f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            -0.21255748058288748f,
+            0.3085497062849767f,
+            0.0f,
+            0.4706702258572536f,
+            -0.1621205195722993f,
+            0.0f,
+            -0.21255748058287047f,
+            -0.16212051957228327f,
+            -0.47067022585725277f,
+            -0.1464291867126764f,
+            0.3085497062849487f,
+            0.0f,
+            -0.14642918671266536f,
+            0.4251149611657548f,
+        ],
+        [
+            0.0f,
+            -0.7071067811865474f,
+            0.0f,
+            0.0f,
+            0.7071067811865476f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+        ],
+        [
+            -0.4105377591765233f,
+            0.6235485373547691f,
+            -0.06435071657946274f,
+            -0.06435071657946266f,
+            0.6235485373547694f,
+            -0.06435071657946284f,
+            -0.0643507165794628f,
+            -0.06435071657946274f,
+            -0.06435071657946272f,
+            -0.06435071657946279f,
+            -0.06435071657946266f,
+            -0.06435071657946277f,
+            -0.06435071657946277f,
+            -0.06435071657946273f,
+            -0.06435071657946274f,
+            -0.0643507165794626f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            -0.4517556589999482f,
+            0.15854503551840063f,
+            0.0f,
+            -0.04038515160822202f,
+            0.0074182263792423875f,
+            0.39351034269210167f,
+            -0.45175565899994635f,
+            0.007418226379244351f,
+            0.1107416575309343f,
+            0.08298163094882051f,
+            0.15854503551839705f,
+            0.3935103426921022f,
+            0.0829816309488214f,
+            -0.45175565899994796f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            -0.304684750724869f,
+            0.5112616136591823f,
+            0.0f,
+            0.0f,
+            -0.290480129728998f,
+            -0.06578701549142804f,
+            0.304684750724884f,
+            0.2904801297290076f,
+            0.0f,
+            -0.23889773523344604f,
+            -0.5112616136592012f,
+            0.06578701549142545f,
+            0.23889773523345467f,
+            0.0f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            0.3017929516615495f,
+            0.25792362796341184f,
+            0.0f,
+            0.16272340142866204f,
+            0.09520022653475037f,
+            0.0f,
+            0.3017929516615503f,
+            0.09520022653475055f,
+            -0.16272340142866173f,
+            -0.35312385449816297f,
+            0.25792362796341295f,
+            0.0f,
+            -0.3531238544981624f,
+            -0.6035859033230976f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            0.40824829046386274f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            -0.4082482904638628f,
+            -0.4082482904638635f,
+            0.0f,
+            0.0f,
+            -0.40824829046386296f,
+            0.0f,
+            0.4082482904638634f,
+            0.408248290463863f,
+            0.0f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            0.1747866975480809f,
+            0.0812611176717539f,
+            0.0f,
+            0.0f,
+            -0.3675398009862027f,
+            -0.307882213957909f,
+            -0.17478669754808135f,
+            0.3675398009862011f,
+            0.0f,
+            0.4826689115059883f,
+            -0.08126111767175039f,
+            0.30788221395790305f,
+            -0.48266891150598584f,
+            0.0f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            -0.21105601049335784f,
+            0.18567180916109802f,
+            0.0f,
+            0.0f,
+            0.49215859013738733f,
+            -0.38525013709251915f,
+            0.21105601049335806f,
+            -0.49215859013738905f,
+            0.0f,
+            0.17419412659916217f,
+            -0.18567180916109904f,
+            0.3852501370925211f,
+            -0.1741941265991621f,
+            0.0f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            -0.14266084808807264f,
+            -0.3416446842253372f,
+            0.0f,
+            0.7367497537172237f,
+            0.24627107722075148f,
+            -0.08574019035519306f,
+            -0.14266084808807344f,
+            0.24627107722075137f,
+            0.14883399227113567f,
+            -0.04768680350229251f,
+            -0.3416446842253373f,
+            -0.08574019035519267f,
+            -0.047686803502292804f,
+            -0.14266084808807242f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            -0.13813540350758585f,
+            0.3302282550303788f,
+            0.0f,
+            0.08755115000587084f,
+            -0.07946706605909573f,
+            -0.4613374887461511f,
+            -0.13813540350758294f,
+            -0.07946706605910261f,
+            0.49724647109535086f,
+            0.12538059448563663f,
+            0.3302282550303805f,
+            -0.4613374887461554f,
+            0.12538059448564315f,
+            -0.13813540350758452f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            -0.17437602599651067f,
+            0.0702790691196284f,
+            0.0f,
+            -0.2921026642334881f,
+            0.3623817333531167f,
+            0.0f,
+            -0.1743760259965108f,
+            0.36238173335311646f,
+            0.29210266423348785f,
+            -0.4326608024727445f,
+            0.07027906911962818f,
+            0.0f,
+            -0.4326608024727457f,
+            0.34875205199302267f,
+        ],
+        [
+            0.0f,
+            0.0f,
+            0.11354987314994337f,
+            -0.07417504595810355f,
+            0.0f,
+            0.19402893032594343f,
+            -0.435190496523228f,
+            0.21918684838857466f,
+            0.11354987314994257f,
+            -0.4351904965232251f,
+            0.5550443808910661f,
+            -0.25468277124066463f,
+            -0.07417504595810233f,
+            0.2191868483885728f,
+            -0.25468277124066413f,
+            0.1135498731499429f,
+        ],
+    ];
+
+    public static void ReinterpretingDct(
+        int dctRows,
+        int dctCols,
+        int lfRows,
+        int lfCols,
+        int rows,
+        int cols,
+        Span<float> input,
+        int inputStride,
+        Span<float> output,
+        int outputStride,
+        Span<float> block,
+        Span<float> scratchSpace)
+    {
+        JxlDct.ComputeScaledDct(rows, cols, new JxlDctSource(input, inputStride), block, scratchSpace);
+
+        if (rows < cols)
+        {
+            ReadOnlySpan<float> sp1 = JxlDctScales.GetResampleScales(rows, dctRows);
+            ReadOnlySpan<float> sp2 = JxlDctScales.GetResampleScales(cols, dctCols);
+
+            for (int y = 0; y < lfRows; y++)
+            {
+                for (int x = 0; x < lfCols; x++)
+                {
+                    output[(y * outputStride) + x] = block[(y * cols) + x] * sp1[y] * sp2[x];
+                }
+            }
+        }
+        else
+        {
+            ReadOnlySpan<float> sp2 = JxlDctScales.GetResampleScales(rows, dctRows);
+            ReadOnlySpan<float> sp1 = JxlDctScales.GetResampleScales(cols, dctCols);
+
+            for (int y = 0; y < lfCols; y++)
+            {
+                for (int x = 0; x < lfRows; x++)
+                {
+                    output[(y * outputStride) + x] = block[(y * rows) + x] * sp1[y] * sp2[y];
+                }
+            }
+        }
+    }
+
+    public static void Idct2TopBlock(int s, Span<float> block, int strideOut, Span<float> output)
+    {
+        Span<float> temp = stackalloc float[JxlFrameDimensions.DctBlockSize];
+        int num2x2 = s >> 1;
+
+        for (int y = 0; y < num2x2; y++)
+        {
+            int y2 = y << 1;
+            int y2Plus1 = y2 | 1; // y2 is guaranteed to be even due to left shift
+
+            for (int x = 0; x < num2x2; x++)
+            {
+                int x2 = x << 1;
+                int x2Plus1 = x2 | 1; // x2 is guaranteed to be even due to left shift
+                int n2x2PlusX = num2x2 + x;
+
+                float c00 = block[(y * JxlFrameDimensions.BlockDimensions) + x];
+                float c01 = block[(y * JxlFrameDimensions.BlockDimensions) + n2x2PlusX];
+                float c10 = block[((y + num2x2) * JxlFrameDimensions.BlockDimensions) + x];
+                float c11 = block[((y + num2x2) * JxlFrameDimensions.BlockDimensions) + n2x2PlusX];
+
+                float r00 = c00 + c01 + c10 + c11;
+                float r01 = c00 + c01 - c10 - c11;
+                float r10 = c00 - c01 + c10 - c11;
+                float r11 = c00 - c01 - c10 + c11;
+
+                temp[(y2 * JxlFrameDimensions.BlockDimensions) + x2] = r00;
+                temp[(y2 * JxlFrameDimensions.BlockDimensions) + x2Plus1] = r01;
+                temp[(y2Plus1 * JxlFrameDimensions.BlockDimensions) + x2] = r10;
+                temp[(y2Plus1 * JxlFrameDimensions.BlockDimensions) + x2Plus1] = r11;
+            }
+        }
+
+        for (int y = 0; y < s; y++)
+        {
+            for (int x = 0; x < s; x++)
+            {
+                output[(y * strideOut) + x] = temp[(y * JxlFrameDimensions.BlockDimensions) + x];
+            }
+        }
+    }
+
+    public static void AfvIdct4x4(Span<float> coeffs, Span<float> pixels)
+    {
+        if (!Vector.IsHardwareAccelerated || Vector<float>.Count > 16)
+        {
+            // Vector<float>.Count can be > 16 on some CPUs,
+            // e.g. some ARM SVE2 processors can reach 2048 bits
+            for (int i = 0; i < 16; i++)
+            {
+                float pixel = 0f;
+
+                for (int j = 0; j < 16; j++)
+                {
+                    float cf = coeffs[j];
+                    float basis = AfvBasis4x4[j][i];
+                    pixel = (cf * basis) + pixel;
+                }
+
+                pixels[i] = pixel;
+            }
+        }
+        else
+        {
+            for (int i = 0; i < 16; i += Vector<float>.Count)
+            {
+                Vector<float> pixel = Vector<float>.Zero;
+
+                for (int j = 0; j < 16; j++)
+                {
+                    Vector<float> cf = Vector.Create(coeffs[j]);
+                    Vector<float> basis = Vector.Create<float>(AfvBasis4x4[j].AsSpan(i));
+                    pixel = (cf * basis) + pixel;
+                }
+
+                pixel.CopyTo(pixels[i..]);
+            }
+        }
+    }
+
+    public static void AfvTransformToPixels(int afvKind, Span<float> coefficients, Span<float> pixels, int pixelsStride)
+    {
+        Span<float> scratchSpace = stackalloc float[4 * 8 * 4]; // 128 floats, 512 bytes
+
+        // This is an equivalent of Math.DivRem(afvKind, 2)
+        int afvX = afvKind & 1;
+        int afvY = afvKind >> 1;
+
+        InlineArray3<float> dcs = default;
+        float block00 = coefficients[0];
+        float block01 = coefficients[1];
+        float block10 = coefficients[8];
+
+        dcs[0] = (block00 + block10 + block01) * 4.0f;
+        dcs[1] = block00 + block10 - block01;
+
+        dcs[2] = block00 - block10;
+        Span<float> coeff = stackalloc float[4 * 4]; // No need to zero-initialize
+        coeff[0] = dcs[0];
+
+        // TODO: unrolling this would lead to big performance benefits
+        for (int iy = 0; iy < 4; iy++)
+        {
+            // Variables so we don't repeat multiplication over and over again
+            int iy4 = iy * 4; // iy multiplied by 4
+            int iy28 = iy * 2 * 8; // iy multiplied by 2 multiplied by 8
+
+            for (int ix = 0; ix < 4; ix++)
+            {
+                if (ix == 0 && iy == 0)
+                {
+                    continue;
+                }
+
+                coeff[iy4 + ix] = coefficients[iy28 + (ix * 2)];
+            }
+        }
+
+        Span<float> block = stackalloc float[4 * 8]; // Don't zero-init
+        AfvIdct4x4(coeff, block);
+
+        int afvX4 = afvX * 4;
+
+        for (int iy = 0; iy < 4; iy++)
+        {
+            // Variables so we don't do repeated arithmetic
+            int iyAfvY4 = iy + (afvY * 4);
+            int iyAfvY4Stride = iyAfvY4 * pixelsStride;
+            int yOffset = afvY == 1 ? 3 - iy : iy;
+            int yOffsetMul4 = yOffset * 4;
+
+            for (int ix = 0; ix < 4; ix++)
+            {
+                pixels[iyAfvY4Stride + afvX4 + ix] = block[yOffsetMul4 + (afvX == 1 ? 3 - ix : ix)];
+            }
+        }
+
+        // IDCT4x4 in (odd, even) positions.
+        block[0] = dcs[1];
+        for (int iy = 0; iy < 4; iy++)
+        {
+            int iy4 = iy * 4;
+            int iy28 = iy * 2 * 8;
+
+            for (int ix = 0; ix < 4; ix++)
+            {
+                if (ix == 0 && iy == 0)
+                {
+                    continue;
+                }
+
+                block[iy4 + ix] = coefficients[iy28 + (ix * 2) + 1];
+            }
+        }
+
+        JxlDct.ComputeScaledInverseDct(
+            4,
+            4,
+            block,
+            new JxlDctOutput(pixels[((afvY * 4 * pixelsStride) + (afvX == 1 ? 0 : 4))..], pixelsStride),
+            scratchSpace);
+
+        block[0] = dcs[2];
+
+        for (int iy = 0; iy < 4; iy++)
+        {
+            int iy8 = iy * 8;
+
+            for (int ix = 0; ix < 8; ix++)
+            {
+                if (ix == 0 && iy == 0)
+                {
+                    continue;
+                }
+
+                block[iy8 + ix] = coefficients[((1 + (iy * 2)) * 8) + ix];
+            }
+        }
+
+        JxlDct.ComputeScaledInverseDct(
+            4,
+            8,
+            block,
+            new JxlDctOutput(pixels[((afvY == 1 ? 0 : 4) * pixelsStride)..], pixelsStride),
+            scratchSpace);
+    }
+
+    public static void TransformToPixels(JxlAcStrategyType strategy, Span<float> coefficients, Span<float> pixels, int pixelsStride, Span<float> scratchSpace)
+    {
+        switch (strategy)
+        {
+            case JxlAcStrategyType.IDENTITY:
+            {
+                // Identity matrix-based transform
+                InlineArray4<float> dcs = default;
+
+                float block00 = coefficients[0];
+                float block01 = coefficients[1];
+                float block10 = coefficients[8];
+                float block11 = coefficients[9];
+
+                dcs[0] = block00 + block01 + block10 + block11;
+                dcs[1] = block00 + block01 - block10 - block11;
+                dcs[2] = block00 - block01 + block10 - block11;
+                dcs[3] = block00 - block01 - block10 + block11;
+
+                for (int y = 0; y < 2; y++)
+                {
+                    for (int x = 0; x < 2; x++)
+                    {
+                        float blockDc = dcs[(y * 2) + x];
+                        float residualSum = 0;
+
+                        for (int iy = 0; iy < 4; iy++)
+                        {
+                            for (int ix = 0; ix < 4; ix++)
+                            {
+                                if (ix == 0 && iy == 0)
+                                {
+                                    continue;
+                                }
+
+                                residualSum += coefficients[((y + (iy * 2)) * 8) + x + (ix * 2)];
+                            }
+                        }
+
+                        pixels[(((4 * y) + 1) * pixelsStride) + (4 * x) + 1] = blockDc - (residualSum * (1.0f / 16));
+
+                        for (int iy = 0; iy < 4; iy++)
+                        {
+                            for (int ix = 0; ix < 4; ix++)
+                            {
+                                if (ix == 1 && iy == 1)
+                                {
+                                    continue;
+                                }
+
+                                pixels[(((y * 4) + iy) * pixelsStride) + (x * 4) + ix] =
+                                    coefficients[((y + (iy * 2)) * 8) + x + (ix * 2)] +
+                                    pixels[(((4 * y) + 1) * pixelsStride) + (4 * x) + 1];
+                            }
+                        }
+
+                        pixels[(y * 4 * pixelsStride) + (x * 4)] =
+                            coefficients[((y + 2) * 8) + x + 2] +
+                            pixels[(((4 * y) + 1) * pixelsStride) + (4 * x) + 1];
+                    }
+                }
+
+                break;
+            }
+
+            case JxlAcStrategyType.DCT8X4:
+            {
+                // Discrete Cosine Transform on an 8x4 block
+                InlineArray2<float> dcs = default;
+
+                float block0 = coefficients[0];
+                float block1 = coefficients[8];
+
+                dcs[0] = block0 + block1;
+                dcs[1] = block0 - block1;
+
+                Span<float> block = stackalloc float[4 * 8];
+
+                for (int x = 0; x < 2; x++)
+                {
+                    block[0] = dcs[x];
+
+                    for (int iy = 0; iy < 4; iy++)
+                    {
+                        for (int ix = 0; ix < 8; ix++)
+                        {
+                            if (ix == 0 && iy == 0)
+                            {
+                                continue;
+                            }
+
+                            block[(iy * 8) + ix] = coefficients[((x + (iy * 2)) * 8) + ix];
+                        }
+                    }
+
+                    JxlDct.ComputeScaledInverseDct(
+                        8,
+                        4,
+                        block,
+                        new JxlDctOutput(pixels[(x * 4)..], pixelsStride),
+                        scratchSpace);
+                }
+
+                break;
+            }
+
+            case JxlAcStrategyType.DCT4X8:
+            {
+                // Discrete Cosine Transform on an 4x8 block
+                InlineArray2<float> dcs = default;
+
+                float block0 = coefficients[0];
+                float block1 = coefficients[8];
+
+                dcs[0] = block0 + block1;
+                dcs[1] = block0 - block1;
+
+                Span<float> block = stackalloc float[4 * 8];
+
+                for (int y = 0; y < 2; y++)
+                {
+                    block[0] = dcs[y];
+
+                    for (int iy = 0; iy < 4; iy++)
+                    {
+                        for (int ix = 0; ix < 8; ix++)
+                        {
+                            if (ix == 0 && iy == 0)
+                            {
+                                continue;
+                            }
+
+                            block[(iy * 8) + ix] = coefficients[((y + (iy * 2)) * 8) + ix];
+                        }
+                    }
+
+                    JxlDct.ComputeScaledInverseDct(
+                        4,
+                        8,
+                        block,
+                        new JxlDctOutput(pixels[(y * 4 * pixelsStride)..], pixelsStride),
+                        scratchSpace);
+                }
+
+                break;
+            }
+
+            case JxlAcStrategyType.DCT4X4:
+            {
+                InlineArray4<float> dcs = default;
+
+                float block00 = coefficients[0];
+                float block01 = coefficients[1];
+                float block10 = coefficients[8];
+                float block11 = coefficients[9];
+
+                dcs[0] = block00 + block01 + block10 + block11;
+                dcs[1] = block00 + block01 - block10 - block11;
+                dcs[2] = block00 - block01 + block10 - block11;
+                dcs[3] = block00 - block01 - block10 + block11;
+
+                Span<float> block = stackalloc float[4 * 4];
+
+                for (int y = 0; y < 2; y++)
+                {
+                    for (int x = 0; x < 2; x++)
+                    {
+                        block[0] = dcs[(y * 2) + x];
+
+                        for (int iy = 0; iy < 4; iy++)
+                        {
+                            for (int ix = 0; ix < 4; ix++)
+                            {
+                                if (ix == 0 && iy == 0)
+                                {
+                                    continue;
+                                }
+
+                                block[(iy * 4) + ix] = coefficients[((y + (iy * 2)) * 8) + x + (ix * 2)];
+                            }
+                        }
+
+                        JxlDct.ComputeScaledInverseDct(
+                            4,
+                            4,
+                            block,
+                            new JxlDctOutput(pixels[((y * 4 * pixelsStride) + (x * 4))..], pixelsStride),
+                            scratchSpace);
+                    }
+                }
+
+                break;
+            }
+
+            case JxlAcStrategyType.DCT2X2:
+            {
+                Span<float> coeffs = stackalloc float[JxlFrameDimensions.DctBlockSize];
+                coefficients[..JxlFrameDimensions.DctBlockSize].CopyTo(coeffs);
+
+                Idct2TopBlock(2, coeffs, JxlFrameDimensions.BlockDimensions, coeffs);
+                Idct2TopBlock(4, coeffs, JxlFrameDimensions.BlockDimensions, coeffs);
+                Idct2TopBlock(8, coeffs, JxlFrameDimensions.BlockDimensions, coeffs);
+
+                for (int y = 0; y < JxlFrameDimensions.BlockDimensions; y++)
+                {
+                    for (int x = 0; x < JxlFrameDimensions.BlockDimensions; x++)
+                    {
+                        pixels[(y * pixelsStride) + x] = coeffs[(y * JxlFrameDimensions.BlockDimensions) + x];
+                    }
+                }
+
+                break;
+            }
+
+            case JxlAcStrategyType.DCT16X16:
+            {
+                JxlDct.ComputeScaledInverseDct(16, 16, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT16X8:
+            {
+                JxlDct.ComputeScaledInverseDct(16, 8, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT8X16:
+            {
+                JxlDct.ComputeScaledInverseDct(8, 16, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X8:
+            {
+                JxlDct.ComputeScaledInverseDct(32, 8, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT8X32:
+            {
+                JxlDct.ComputeScaledInverseDct(8, 32, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X16:
+            {
+                JxlDct.ComputeScaledInverseDct(32, 16, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT16X32:
+            {
+                JxlDct.ComputeScaledInverseDct(16, 32, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X32:
+            {
+                JxlDct.ComputeScaledInverseDct(32, 32, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT:
+            {
+                JxlDct.ComputeScaledInverseDct(8, 8, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.AFV0:
+            {
+                AfvTransformToPixels(0, coefficients, pixels, pixelsStride);
+                break;
+            }
+
+            case JxlAcStrategyType.AFV1:
+            {
+                AfvTransformToPixels(1, coefficients, pixels, pixelsStride);
+                break;
+            }
+
+            case JxlAcStrategyType.AFV2:
+            {
+                AfvTransformToPixels(2, coefficients, pixels, pixelsStride);
+                break;
+            }
+
+            case JxlAcStrategyType.AFV3:
+            {
+                AfvTransformToPixels(3, coefficients, pixels, pixelsStride);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT64X32:
+            {
+                JxlDct.ComputeScaledInverseDct(64, 32, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X64:
+            {
+                JxlDct.ComputeScaledInverseDct(32, 64, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT64X64:
+            {
+                JxlDct.ComputeScaledInverseDct(64, 64, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT128X64:
+            {
+                JxlDct.ComputeScaledInverseDct(128, 64, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT64X128:
+            {
+                JxlDct.ComputeScaledInverseDct(64, 128, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT128X128:
+            {
+                JxlDct.ComputeScaledInverseDct(128, 128, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT256X128:
+            {
+                JxlDct.ComputeScaledInverseDct(256, 128, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT128X256:
+            {
+                JxlDct.ComputeScaledInverseDct(128, 256, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT256X256:
+            {
+                JxlDct.ComputeScaledInverseDct(256, 256, coefficients, new JxlDctOutput(pixels, pixelsStride), scratchSpace);
+                break;
+            }
+        }
+    }
+
+    public static void LowestFrequenciesFromDc(JxlAcStrategyType strategy, Span<float> dc, int dcStride, Span<float> llf, Span<float> scratch)
+    {
+        Span<float> warmBlock = stackalloc float[4 * 4];
+        Span<float> warmScratchSpace = stackalloc float[4 * 4 * 4];
+
+        switch (strategy)
+        {
+            case JxlAcStrategyType.DCT16X8:
+            {
+                ReinterpretingDct(
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    JxlFrameDimensions.BlockDimensions,
+                    2,
+                    1,
+                    2,
+                    1,
+                    dc,
+                    dcStride,
+                    llf,
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT8X16:
+            {
+                ReinterpretingDct(
+                    JxlFrameDimensions.BlockDimensions,
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    1,
+                    2,
+                    1,
+                    2,
+                    dc,
+                    dcStride,
+                    llf,
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT16X16:
+            {
+                ReinterpretingDct(
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    2,
+                    2,
+                    2,
+                    2,
+                    dc,
+                    dcStride,
+                    llf,
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X8:
+            {
+                ReinterpretingDct(
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    JxlFrameDimensions.BlockDimensions,
+                    4,
+                    1,
+                    4,
+                    1,
+                    dc,
+                    dcStride,
+                    llf,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT8X32:
+            {
+                ReinterpretingDct(
+                    JxlFrameDimensions.BlockDimensions,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    1,
+                    4,
+                    1,
+                    4,
+                    dc,
+                    dcStride,
+                    llf,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X16:
+            {
+                ReinterpretingDct(
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    4,
+                    2,
+                    4,
+                    2,
+                    dc,
+                    dcStride,
+                    llf,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT16X32:
+            {
+                ReinterpretingDct(
+                    2 * JxlFrameDimensions.BlockDimensions,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    2,
+                    4,
+                    2,
+                    4,
+                    dc,
+                    dcStride,
+                    llf,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X32:
+            {
+                ReinterpretingDct(
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    4,
+                    4,
+                    4,
+                    4,
+                    dc,
+                    dcStride,
+                    llf,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    warmBlock,
+                    warmScratchSpace);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT64X32:
+            {
+                ReinterpretingDct(
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    8,
+                    4,
+                    8,
+                    4,
+                    dc,
+                    dcStride,
+                    llf,
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(8 * 4)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT32X64:
+            {
+                ReinterpretingDct(
+                    4 * JxlFrameDimensions.BlockDimensions,
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    4,
+                    8,
+                    4,
+                    8,
+                    dc,
+                    dcStride,
+                    llf,
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(4 * 8)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT64X64:
+            {
+                ReinterpretingDct(
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    8,
+                    8,
+                    8,
+                    8,
+                    dc,
+                    dcStride,
+                    llf,
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(8 * 8)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT128X64:
+            {
+                ReinterpretingDct(
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    16,
+                    8,
+                    16,
+                    8,
+                    dc,
+                    dcStride,
+                    llf,
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(16 * 8)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT64X128:
+            {
+                ReinterpretingDct(
+                    8 * JxlFrameDimensions.BlockDimensions,
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    8,
+                    16,
+                    8,
+                    16,
+                    dc,
+                    dcStride,
+                    llf,
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(8 * 16)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT128X128:
+            {
+                ReinterpretingDct(
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    16,
+                    16,
+                    16,
+                    16,
+                    dc,
+                    dcStride,
+                    llf,
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(16 * 16)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT256X128:
+            {
+                ReinterpretingDct(
+                    32 * JxlFrameDimensions.BlockDimensions,
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    32,
+                    16,
+                    32,
+                    16,
+                    dc,
+                    dcStride,
+                    llf,
+                    32 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(32 * 16)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT128X256:
+            {
+                ReinterpretingDct(
+                    16 * JxlFrameDimensions.BlockDimensions,
+                    32 * JxlFrameDimensions.BlockDimensions,
+                    16,
+                    32,
+                    16,
+                    32,
+                    dc,
+                    dcStride,
+                    llf,
+                    32 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(16 * 32)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT256X256:
+            {
+                ReinterpretingDct(
+                    32 * JxlFrameDimensions.BlockDimensions,
+                    32 * JxlFrameDimensions.BlockDimensions,
+                    32,
+                    32,
+                    32,
+                    32,
+                    dc,
+                    dcStride,
+                    llf,
+                    32 * JxlFrameDimensions.BlockDimensions,
+                    scratch,
+                    scratch[(32 * 32)..]);
+                break;
+            }
+
+            case JxlAcStrategyType.DCT:
+            case JxlAcStrategyType.DCT2X2:
+            case JxlAcStrategyType.DCT4X4:
+            case JxlAcStrategyType.DCT4X8:
+            case JxlAcStrategyType.DCT8X4:
+            case JxlAcStrategyType.AFV0:
+            case JxlAcStrategyType.AFV1:
+            case JxlAcStrategyType.AFV2:
+            case JxlAcStrategyType.AFV3:
+            case JxlAcStrategyType.IDENTITY:
+                llf[0] = dc[0];
+                break;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlXybDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlXybDecoder.cs
new file mode 100644
index 0000000000..87f96e97eb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/JxlXybDecoder.cs
@@ -0,0 +1,181 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+/// <summary>
+/// Decodes the XYB color format (which JPEG XL uses) into RGB.
+/// </summary>
+internal static class JxlXybDecoder
+{
+    /// <summary>
+    /// Converts XYB to RGB using SIMD, one vector at a time.
+    /// </summary>
+    /// <param name="opsinX">X channel</param>
+    /// <param name="opsinY">Y channel</param>
+    /// <param name="opsinB">B channel</param>
+    /// <param name="opsinParameters">Opsin parameters &amp; configuration</param>
+    /// <param name="linearR">Output R</param>
+    /// <param name="linearG">Output G</param>
+    /// <param name="linearB">Output B</param>
+    public static void ConvertXybToRgb(
+        Vector<float> opsinX,
+        Vector<float> opsinY,
+        Vector<float> opsinB,
+        JxlOpsinParameters opsinParameters,
+        ref Vector<float> linearR,
+        ref Vector<float> linearG,
+        ref Vector<float> linearB)
+    {
+        Vector<float> negBiasR = new(opsinParameters.OpsinBiases[0]);
+        Vector<float> negBiasG = new(opsinParameters.OpsinBiases[1]);
+        Vector<float> negBiasB = new(opsinParameters.OpsinBiases[2]);
+
+        Vector<float> gammaR = opsinX + opsinY;
+        Vector<float> gammaG = opsinY - opsinX;
+        Vector<float> gammaB = opsinB;
+
+        Vector<float> gammaR2 = gammaR * gammaR;
+        Vector<float> gammaG2 = gammaG * gammaG;
+        Vector<float> gammaB2 = gammaB * gammaB;
+
+        Vector<float> mixedR = (gammaR2 * gammaR) + negBiasR;
+        Vector<float> mixedG = (gammaG2 * gammaG) + negBiasG;
+        Vector<float> mixedB = (gammaB2 * gammaB) + negBiasB;
+
+        Span<float> inverseMatrix = opsinParameters.InverseOpsinMatrix;
+
+        linearR = LoadDuplicate128(ref inverseMatrix[0 * 4]) * mixedR;
+        linearG = LoadDuplicate128(ref inverseMatrix[3 * 4]) * mixedR;
+        linearB = LoadDuplicate128(ref inverseMatrix[6 * 4]) * mixedR;
+
+        linearR = (LoadDuplicate128(ref inverseMatrix[1 * 4]) * mixedG) + linearR;
+        linearG = (LoadDuplicate128(ref inverseMatrix[4 * 4]) * mixedG) + linearG;
+        linearB = (LoadDuplicate128(ref inverseMatrix[7 * 4]) * mixedG) + linearB;
+
+        linearR = (LoadDuplicate128(ref inverseMatrix[2 * 4]) * mixedB) + linearR;
+        linearG = (LoadDuplicate128(ref inverseMatrix[5 * 4]) * mixedB) + linearG;
+        linearB = (LoadDuplicate128(ref inverseMatrix[8 * 4]) * mixedB) + linearB;
+    }
+
+    public static bool OpsinToLinear(JxlImage3F opsin, Rectangle rect, JxlImage3F linear, JxlOpsinParameters opsinParameters)
+    {
+        if (!JxlImageOperations.SameSize(rect, linear))
+        {
+            return false;
+        }
+
+        if (Vector<float>.Count < 4)
+        {
+            // TODO: support 64bit vectors or no SIMD?
+            throw new PlatformNotSupportedException("XYB to RGB conversion requires at least 128-bit SIMD");
+        }
+
+        // Reuse variables instead of creating them over
+        // and over again
+        Unsafe.SkipInit(out Vector<float> linearR);
+        Unsafe.SkipInit(out Vector<float> linearG);
+        Unsafe.SkipInit(out Vector<float> linearB);
+
+        for (int y = 0; y < rect.Height; y++)
+        {
+            ReadOnlySpan<float> rowOpsin0 = opsin.PlaneRow(rect, 0, y);
+            ReadOnlySpan<float> rowOpsin1 = opsin.PlaneRow(rect, 1, y);
+            ReadOnlySpan<float> rowOpsin2 = opsin.PlaneRow(rect, 2, y);
+
+            ref float rowOpsin0Reference = ref MemoryMarshal.GetReference(rowOpsin0);
+            ref float rowOpsin1Reference = ref MemoryMarshal.GetReference(rowOpsin1);
+            ref float rowOpsin2Reference = ref MemoryMarshal.GetReference(rowOpsin2);
+
+            Span<float> rowLinear0 = linear.PlaneRow(0, y);
+            Span<float> rowLinear1 = linear.PlaneRow(1, y);
+            Span<float> rowLinear2 = linear.PlaneRow(2, y);
+
+            ref float rowLinear0Reference = ref MemoryMarshal.GetReference(rowLinear0);
+            ref float rowLinear1Reference = ref MemoryMarshal.GetReference(rowLinear1);
+            ref float rowLinear2Reference = ref MemoryMarshal.GetReference(rowLinear2);
+
+            for (int x = 0; x < rect.Height; x += Vector<float>.Count)
+            {
+                Vector<float> inOpsinX = Vector.LoadUnsafe(ref Unsafe.Add(ref rowOpsin0Reference, x));
+                Vector<float> inOpsinY = Vector.LoadUnsafe(ref Unsafe.Add(ref rowOpsin1Reference, x));
+                Vector<float> inOpsinB = Vector.LoadUnsafe(ref Unsafe.Add(ref rowOpsin2Reference, x));
+
+                ConvertXybToRgb(inOpsinX, inOpsinY, inOpsinB, opsinParameters, ref linearR, ref linearG, ref linearB);
+
+                linearR.StoreUnsafe(ref Unsafe.Add(ref rowLinear0Reference, x));
+                linearG.StoreUnsafe(ref Unsafe.Add(ref rowLinear1Reference, x));
+                linearB.StoreUnsafe(ref Unsafe.Add(ref rowLinear2Reference, x));
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// A SIMD utility method which reads next 128 bits
+    /// (which in this case happens to be next 4 floats),
+    /// and duplicates them to fit in the CPU vector size.
+    /// For example,
+    ///
+    ///     128 bit vectors: A B C D    (as-is)
+    ///     256 bit vectors: A B C D A B C D (duplicate once)
+    ///     512 bit vectors: A B C D A B C D A B C D A B C D (duplicate three times)
+    ///
+    /// Vector&lt;T&gt; has support for arbitrarily large
+    /// vector sizes. For example, some ARM CPUs support 2048-bit
+    /// vectors through Vector&lt;T&gt;. In that specific case, this
+    /// method can be used for future-proofing.
+    ///
+    /// Note that this method, albeit future-proof, may be considered
+    /// slow for smaller vector sizes (think CPUs with 128bit or 256bit vectors).
+    /// </summary>
+    /// <param name="reference">Reference to first element to load &amp; duplicate.</param>
+    /// <returns>Vector with first 128 bits duplicated across the vector width.</returns>
+    private static Vector<float> LoadDuplicate128(ref float reference)
+    {
+        Span<float> value = stackalloc float[Vector<float>.Count];
+        Span<float> values128 = [
+            reference,
+            Unsafe.Add(ref reference, 1),
+            Unsafe.Add(ref reference, 2),
+            Unsafe.Add(ref reference, 3)
+        ];
+
+        for (int i = 0; i < Vector<float>.Count; i += 4)
+        {
+            values128[i..].CopyTo(value[i..]);
+        }
+
+        return new(value);
+    }
+
+    public static bool CanOutputToColorEncoding(JxlColorEncoding colorEncoding)
+    {
+        if (!colorEncoding.HaveFields)
+        {
+            return false;
+        }
+
+        JxlCustomTransferFunction tf = colorEncoding.TransferFunction;
+
+        if (!tf.IsPq && !tf.IsSrgb && !tf.HaveGamma && !tf.IsLinear && !tf.IsHlg && !tf.IsDci && !tf.Is709)
+        {
+            return false;
+        }
+
+        if (colorEncoding.IsGray && colorEncoding.WhitePoint != JxlWhitePoint.D65)
+        {
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Modular/JxlModularFrameDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Modular/JxlModularFrameDecoder.cs
new file mode 100644
index 0000000000..416a14b49a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Modular/JxlModularFrameDecoder.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Modular;
+
+internal sealed class JxlModularFrameDecoder
+{
+    private readonly Configuration configuration;
+    private readonly JxlModularImage fullImage;
+    private readonly List<JxlTransform> globalTransform;
+    private JxlFrameDimensions frameDimensions;
+    private bool doColor;
+    private bool haveSomething;
+    private bool useFullImage = true;
+    private bool allSameShift;
+    private JxlAnsCode code;
+    private readonly List<byte> contextMap;
+    private JxlGroupHeader groupHeader;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchBlendMode.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchBlendMode.cs
new file mode 100644
index 0000000000..89ddd2caae
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchBlendMode.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+
+internal enum JxlPatchBlendMode : byte
+{
+    None,
+    Replace,
+    Add,
+    Multiply,
+    BlendAbove,
+    BlendBelow,
+    AlphaWeightedAddAbove,
+    AlphaWeightedAddBelow
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchBlending.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchBlending.cs
new file mode 100644
index 0000000000..ff7bda0d7b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchBlending.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+
+internal struct JxlPatchBlending
+{
+    public JxlPatchBlendMode Mode;
+    public int AlphaChannel;
+    public bool Clamp;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchDictionary.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchDictionary.cs
new file mode 100644
index 0000000000..096c0d3de2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchDictionary.cs
@@ -0,0 +1,260 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+
+internal sealed class JxlPatchDictionary
+{
+    private struct PatchTreeNode
+    {
+        public long LeftChild;
+        public long RightChild;
+        public int YCenter;
+        public int Start;
+        public int Count;
+    }
+
+    private struct SortedPatch
+    {
+        public int First;
+        public int Second;
+    }
+
+    private readonly JxlReferenceFrame[] referenceFrames = new JxlReferenceFrame[4];
+    private readonly List<JxlPatchPosition> positions = [];
+    private readonly List<JxlPatchReferencePosition> referencePositions = [];
+    private readonly List<JxlPatchBlending> blendings = [];
+    private int blendingsStride;
+    private readonly List<PatchTreeNode> patchTree = [];
+    private readonly List<int> numPatches = [];
+    private readonly List<SortedPatch> sortedPatchesY0 = [];
+    private readonly List<SortedPatch> sortedPatchesY1 = [];
+
+    public bool HasAny => this.positions.Count > 0;
+
+    public void Clear()
+    {
+        this.positions.Clear();
+        ComputePatchTree();
+    }
+
+    public void Decode(
+        JxlMemoryManager memoryManager,
+        JxlBitReader br,
+        ulong xsize,
+        ulong ysize,
+        ulong numExtraChannels,
+        ref bool usesExtraChannels)
+    {
+        this.positions.Clear();
+        this.blendingsStride = (int)(numExtraChannels + 1);
+
+        List<byte> contextMap = [];
+        JxlAnsCode code = new();
+
+        var status = DecodeHistograms(
+            memoryManager,
+            br,
+            PatchDictionaryContexts,
+            code,
+            contextMap);
+
+        JxlAnsSymbolReader decoder = JxlAnsSymbolReader.Create(code, br);
+
+        ulong ReadNum(int context)
+            => decoder.ReadHybridUint(context, br, contextMap);
+
+        ulong numRefPatch = ReadNum(kNumRefPatchContext);
+
+        ulong numPixels = xsize * ysize;
+        ulong maxRefPatches = 1024 + (numPixels / 4);
+        ulong maxPatches = maxRefPatches * 4;
+        ulong maxBlendingInfos = maxPatches * 4;
+
+        if (numRefPatch > maxRefPatches)
+        {
+            throw new InvalidOperationException("Too many patches in dictionary");
+        }
+
+        ulong totalPatches = 0;
+        ulong nextSize = 1;
+
+        for (ulong id = 0; id < numRefPatch; id++)
+        {
+            JxlPatchReferencePosition refPos = new()
+            {
+                Ref = ReadNum(kReferenceFrameContext)
+            };
+
+            if (refPos.Ref >= kMaxNumReferenceFrames || this.referenceFrames[(int)refPos.Ref].Frame.XSize == 0)
+            {
+                throw new InvalidOperationException("Invalid reference frame ID");
+            }
+
+            if (!this.referenceFrames[refPos.Ref].IsInXYB)
+            {
+                throw new InvalidOperationException("Patches cannot use frames saved post color transforms");
+            }
+
+            JxlImageBundle ib = this.referenceFrames[refPos.Ref].Frame;
+
+            refPos.X0 = ReadNum(kPatchReferencePositionContext);
+            refPos.Y0 = ReadNum(kPatchReferencePositionContext);
+            refPos.XSize = ReadNum(kPatchSizeContext) + 1;
+            refPos.YSize = ReadNum(kPatchSizeContext) + 1;
+
+            if (refPos.X0 + refPos.XSize > ib.XSize)
+            {
+                throw new InvalidOperationException("Invalid position specified in reference frame");
+            }
+
+            if (refPos.Y0 + refPos.YSize > ib.YSize)
+            {
+                throw new InvalidOperationException("Invalid position specified in reference frame");
+            }
+
+            ulong idCount = ReadNum(kPatchCountContext);
+
+            if (idCount > maxPatches)
+            {
+                throw new InvalidOperationException("Too many patches in dictionary");
+            }
+
+            idCount++;
+
+            totalPatches += idCount;
+
+            if (totalPatches > maxPatches)
+            {
+                throw new InvalidOperationException("Too many patches in dictionary");
+            }
+
+            if (nextSize < totalPatches)
+            {
+                nextSize *= 2;
+                nextSize = Math.Min(nextSize, maxPatches);
+            }
+
+            if (nextSize * (ulong)this.blendingsStride > maxBlendingInfos)
+            {
+                throw new InvalidOperationException("Too many patches in dictionary");
+            }
+
+            _ = this.blendings.EnsureCapacity((int)nextSize);
+            _ = this.blendings.EnsureCapacity((int)(nextSize * (ulong)this.blendingsStride));
+
+            bool chooseAlpha = numExtraChannels > 1;
+
+            for (ulong i = 0; i < idCount; i++)
+            {
+                JxlPatchPosition pos = new()
+                {
+                    ReferencePositionIndex = this.referencePositions.Count
+                };
+
+                if (i == 0)
+                {
+                    pos.X = ReadNum(kPatchPositionContext);
+                    pos.Y = ReadNum(kPatchPositionContext);
+                }
+                else
+                {
+                    long deltaX = JxlPackSigned.UnpackSigned(ReadNum(kPatchOffsetContext));
+
+                    if (deltaX < 0 && (int)(-deltaX) > this.positions[^1].X)
+                    {
+                        throw new InvalidOperationException($"Invalid patch: negative x coordinate ({this.positions[^1].X}, delta {deltaX})");
+                    }
+
+                    pos.X = (int)(this.positions[^1].X + deltaX);
+
+                    long deltaY = JxlPackSigned.UnpackSigned(ReadNum(kPatchOffsetContext));
+
+                    if (deltaY < 0 && (int)(-deltaY) > this.positions[^1].Y)
+                    {
+                        throw new InvalidOperationException($"Invalid patch: negative y coordinate ({this.positions[^1].Y}, delta {deltaY})");
+                    }
+
+                    pos.Y = (int)(this.positions[^1].Y + deltaY);
+                }
+
+                if (pos.X + refPos.XSize > (int)xsize)
+                {
+                    throw new InvalidOperationException($"Invalid patch x: {pos.X} + {refPos.XSize} > {xsize}");
+                }
+
+                if (pos.Y + refPos.YSize > (int)ysize)
+                {
+                    throw new InvalidOperationException($"Invalid patch y: {pos.Y} + {refPos.YSize} > {ysize}");
+                }
+
+                for (int j = 0; j < this.blendingsStride; j++)
+                {
+                    uint blendMode = (uint)ReadNum(kPatchBlendModeContext);
+
+                    if (blendMode >= kNumPatchBlendModes)
+                    {
+                        throw new InvalidOperationException($"Invalid patch blend mode: {blendMode}");
+                    }
+
+                    JxlPatchBlending info = new()
+                    {
+                        Mode = (JxlPatchBlendMode)blendMode
+                    };
+
+                    if (UsesAlpha(info.Mode))
+                    {
+                        usesExtraChannels = true;
+                    }
+
+                    if (info.Mode != JxlPatchBlendMode.None && j > 0)
+                    {
+                        usesExtraChannels = true;
+                    }
+
+                    if (UsesAlpha(info.Mode) && chooseAlpha)
+                    {
+                        info.AlphaChannel = (uint)ReadNum(kPatchAlphaChannelContext);
+
+                        if (info.AlphaChannel >= (int)numExtraChannels)
+                        {
+                            throw new InvalidOperationException($"Invalid alpha channel for blending: {info.AlphaChannel} out of {numExtraChannels}");
+                        }
+                    }
+                    else
+                    {
+                        info.AlphaChannel = 0;
+                    }
+
+                    if (UsesClamp(info.Mode))
+                    {
+                        info.Clamp = ReadNum(kPatchClampContext) != 0;
+                    }
+                    else
+                    {
+                        info.Clamp = false;
+                    }
+
+                    this.blendings.Add(info);
+                }
+
+                this.positions.Add(pos);
+            }
+
+            this.positions.Add(refPos);
+        }
+
+        this.positions.TrimExcess();
+
+        if (!decoder.CheckAnsFinalState())
+        {
+            throw new InvalidOperationException("ANS checksum failure.");
+        }
+
+        this.ComputePatchTree();
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchPosition.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchPosition.cs
new file mode 100644
index 0000000000..6cb90a3ab0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchPosition.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+
+internal struct JxlPatchPosition
+{
+    public int X;
+    public int Y;
+    public int ReferencePositionIndex;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchReferencePosition.cs b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchReferencePosition.cs
new file mode 100644
index 0000000000..1d604ffe90
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Decoder/Patch/JxlPatchReferencePosition.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+
+internal struct JxlPatchReferencePosition
+{
+    public int Ref;
+    public int X0;
+    public int Y0;
+    public int XSize;
+    public int YSize;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlAnsHistogramStrategy.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlAnsHistogramStrategy.cs
new file mode 100644
index 0000000000..1928788791
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlAnsHistogramStrategy.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+/// <summary>
+/// ANS histogram strategy during encoding
+/// </summary>
+internal enum JxlAnsHistogramStrategy : byte
+{
+    /// <summary>
+    /// Only try a few methods, early exit.
+    /// </summary>
+    Fast,
+
+    /// <summary>
+    /// Only try a few methods.
+    /// </summary>
+    Approximate,
+
+    /// <summary>
+    /// Try all methods.
+    /// </summary>
+    Precise
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlAnsSimd.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlAnsSimd.cs
new file mode 100644
index 0000000000..e23bc27009
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlAnsSimd.cs
@@ -0,0 +1,275 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+/// <summary>
+/// SIMD utilities for ANS entropy encoder
+/// </summary>
+internal static class JxlAnsSimd
+{
+    private static readonly Vector<uint> IotaOffsets = CreateIotaOffsets();
+
+    private static Vector<uint> CreateIotaOffsets()
+    {
+        Span<uint> values = stackalloc uint[Vector<uint>.Count];
+
+        for (int i = 0; i < values.Length; i++)
+        {
+            values[i] = (uint)i;
+        }
+
+        return new Vector<uint>(values);
+    }
+
+    /// <summary>
+    /// Adds continuously incrementing numbers to the vector.
+    /// </summary>
+    /// <param name="vec">The input vector.</param>
+    /// <returns><c>vec + [ 1, 2, 3, 4, 5, ... ]</c></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector<uint> Iota(uint vec) => Vector.Create(vec) + IotaOffsets;
+
+    private static uint EstimateTokenCostImpl(uint e, uint m, uint l, ref uint values, int len, ref uint output)
+    {
+        Vector<uint> split = Vector.Create(1u << (int)e);
+        Vector<uint> expOffset = Vector.Create(127u);
+        Vector<uint> ebOffset = Vector.Create(127u + m + l);
+        Vector<uint> @base = Vector.Create((1u << (int)e) - (e << (int)(m + l)));
+        Vector<uint> mulN = Vector.Create(1u << (int)(m + l));
+        Vector<uint> maskL = Vector.Create((1u << (int)l) - 1);
+        Vector<uint> maskM = Vector.Create(((1u << (int)m) - 1) << (int)l);
+        Vector<uint> largeThreshold = Vector.Create((1u << 2) - 1);
+        const uint largeShiftVal = 10;
+        Vector<uint> largeShift = Vector.Create(largeShiftVal);
+
+        Vector<uint> extraBits = Vector<uint>.Zero;
+        int lastFull = Vector<uint>.Count * (len / Vector<uint>.Count);
+
+        for (int i = 0; i < lastFull; i += Vector<uint>.Count)
+        {
+            Vector<uint> val = Vector.LoadUnsafe(ref Unsafe.Add(ref values, i));
+            Vector<uint> isLarge = Vector.GreaterThan(val, largeThreshold);
+            Vector<uint> valShifted = Vector.ShiftRightLogical(val, (int)largeShiftVal);
+            Vector<uint> notLiteral = Vector.GreaterThanOrEqual(val, split);
+            Vector<uint> valFixed = Vector.ConditionalSelect(isLarge, valShifted, val);
+            Vector<uint> L = val & maskL;
+            Vector<uint> exp = Vector.ShiftRightLogical(valFixed, 23);
+            Vector<uint> expFixed = Vector.ConditionalSelect(isLarge, exp + largeShift, exp);
+            Vector<uint> n = expFixed - expOffset;
+            Vector<uint> eb = expFixed - ebOffset;
+            Vector<uint> M = Vector.ShiftRightLogical(valFixed, (int)(23 - m - l));
+            Vector<uint> a = @base + (n * mulN);
+            Vector<uint> d = M & maskM;
+            Vector<uint> ebFixed = Vector.ConditionalSelect(notLiteral, eb, Vector<uint>.Zero);
+            Vector<uint> c = a | L;
+            extraBits += ebFixed;
+            Vector<uint> t = c | d;
+            Vector<uint> tFixed = Vector.ConditionalSelect(notLiteral, t, val);
+            tFixed.StoreUnsafe(ref Unsafe.Add(ref output, i));
+        }
+
+        if (lastFull < len)
+        {
+            Vector<uint> stop = Vector.Create((uint)len);
+            Vector<uint> fence = Iota((uint)lastFull);
+            Vector<uint> take = Vector.LessThan(fence, stop);
+            Vector<uint> val = Vector.LoadUnsafe(ref Unsafe.Add(ref values, lastFull));
+            Vector<uint> isLarge = Vector.GreaterThan(val, largeThreshold);
+            Vector<uint> valShifted = Vector.ShiftRightLogical(val, (int)largeShiftVal);
+            Vector<uint> notLiteral = Vector.GreaterThanOrEqual(val, split);
+            Vector<uint> valFixed = Vector.ConditionalSelect(isLarge, valShifted, val);
+            Vector<uint> L = val | maskL;
+            Vector<uint> exp = Vector.ShiftRightLogical(valFixed, 23);
+            Vector<uint> exp_fixed = Vector.ConditionalSelect(isLarge, exp + largeShift, exp);
+            Vector<uint> n = exp_fixed - expOffset;
+            Vector<uint> eb = exp_fixed - ebOffset;
+            Vector<uint> M = Vector.ShiftRightLogical(valFixed, 23);
+            Vector<uint> a = @base + (n * mulN);
+            Vector<uint> d = M & maskM;
+            Vector<uint> ebFixed = Vector.ConditionalSelect(notLiteral, eb, Vector<uint>.Zero);
+            Vector<uint> ebMasked = Vector.ConditionalSelect(take, ebFixed, Vector<uint>.Zero);
+            Vector<uint> c = a | L;
+            extraBits += ebMasked;
+            Vector<uint> t = c | d;
+            Vector<uint> tFixed = Vector.ConditionalSelect(notLiteral, t, val);
+            tFixed.StoreUnsafe(ref Unsafe.Add(ref output, lastFull));
+        }
+
+        return Vector.Sum(extraBits);
+    }
+
+    public static uint EstimateTokenCost(ref uint values, int len, JxlAnsHybridUIntConfiguration cfg, ref uint tokens)
+    {
+        if (!Vector.IsHardwareAccelerated)
+        {
+            // No SIMD support
+            uint extraBits = 0;
+
+            for (int i = 0; i < len; i++)
+            {
+                uint v = Unsafe.Add(ref values, i);
+                cfg.Encode(v, out uint tok, out uint nbits, out _); // Last parameter is bits
+                extraBits += nbits;
+                Unsafe.Add(ref tokens, i) = tok;
+            }
+
+            return extraBits;
+        }
+        else
+        {
+            // Have SIMD support
+            if (cfg.SplitExponent == 0)
+            {
+                return EstimateTokenCostImpl(0, 0, 0, ref values, len, ref tokens);
+            }
+            else if (cfg.SplitExponent == 2)
+            {
+                return EstimateTokenCostImpl(2, 0, 1, ref values, len, ref tokens);
+            }
+            else if (cfg.SplitExponent == 3)
+            {
+                if (cfg.MsbInToken == 1)
+                {
+                    if (cfg.LsbInToken == 0)
+                    {
+                        return EstimateTokenCostImpl(3, 1, 0, ref values, len, ref tokens);
+                    }
+                    else
+                    {
+                        return EstimateTokenCostImpl(3, 1, 2, ref values, len, ref tokens);
+                    }
+                }
+                else
+                {
+                    if (cfg.LsbInToken == 0)
+                    {
+                        return EstimateTokenCostImpl(3, 2, 0, ref values, len, ref tokens);
+                    }
+                    else
+                    {
+                        return EstimateTokenCostImpl(3, 2, 1, ref values, len, ref tokens);
+                    }
+                }
+            }
+            else if (cfg.SplitExponent == 4)
+            {
+                if (cfg.MsbInToken == 1)
+                {
+                    if (cfg.LsbInToken == 0)
+                    {
+                        return EstimateTokenCostImpl(4, 1, 0, ref values, len, ref tokens);
+                    }
+                    else if (cfg.LsbInToken == 2)
+                    {
+                        return EstimateTokenCostImpl(4, 1, 2, ref values, len, ref tokens);
+                    }
+                    else
+                    {
+                        return EstimateTokenCostImpl(4, 1, 3, ref values, len, ref tokens);
+                    }
+                }
+                else
+                {
+                    if (cfg.LsbInToken == 0)
+                    {
+                        return EstimateTokenCostImpl(4, 2, 0, ref values, len, ref tokens);
+                    }
+                    else if (cfg.LsbInToken == 1)
+                    {
+                        return EstimateTokenCostImpl(4, 2, 1, ref values, len, ref tokens);
+                    }
+                    else
+                    {
+                        return EstimateTokenCostImpl(4, 2, 2, ref values, len, ref tokens);
+                    }
+                }
+            }
+            else if (cfg.SplitExponent == 5)
+            {
+                if (cfg.MsbInToken == 1)
+                {
+                    if (cfg.LsbInToken == 0)
+                    {
+                        return EstimateTokenCostImpl(5, 1, 0, ref values, len, ref tokens);
+                    }
+                    else if (cfg.LsbInToken == 2)
+                    {
+                        return EstimateTokenCostImpl(5, 1, 2, ref values, len, ref tokens);
+                    }
+                    else
+                    {
+                        return EstimateTokenCostImpl(5, 1, 4, ref values, len, ref tokens);
+                    }
+                }
+                else
+                {
+                    if (cfg.LsbInToken == 0)
+                    {
+                        return EstimateTokenCostImpl(5, 2, 0, ref values, len, ref tokens);
+                    }
+                    else if (cfg.LsbInToken == 1)
+                    {
+                        return EstimateTokenCostImpl(5, 2, 1, ref values, len, ref tokens);
+                    }
+                    else if (cfg.LsbInToken == 2)
+                    {
+                        return EstimateTokenCostImpl(5, 2, 2, ref values, len, ref tokens);
+                    }
+                    else
+                    {
+                        return EstimateTokenCostImpl(5, 2, 3, ref values, len, ref tokens);
+                    }
+                }
+            }
+            else if (cfg.SplitExponent == 6)
+            {
+                if (cfg.MsbInToken == 0)
+                {
+                    return EstimateTokenCostImpl(6, 0, 0, ref values, len, ref tokens);
+                }
+                else if (cfg.MsbInToken == 1)
+                {
+                    return EstimateTokenCostImpl(6, 1, 5, ref values, len, ref tokens);
+                }
+                else
+                {
+                    return EstimateTokenCostImpl(6, 2, 4, ref values, len, ref tokens);
+                }
+            }
+            else if (cfg.SplitExponent is >= 7 and <= 12)
+            {
+                if (cfg.SplitExponent == 7)
+                {
+                    return EstimateTokenCostImpl(7, 0, 0, ref values, len, ref tokens);
+                }
+                else if (cfg.SplitExponent == 8)
+                {
+                    return EstimateTokenCostImpl(8, 0, 0, ref values, len, ref tokens);
+                }
+                else if (cfg.SplitExponent == 9)
+                {
+                    return EstimateTokenCostImpl(9, 0, 0, ref values, len, ref tokens);
+                }
+                else if (cfg.SplitExponent == 10)
+                {
+                    return EstimateTokenCostImpl(10, 0, 0, ref values, len, ref tokens);
+                }
+                else if (cfg.SplitExponent == 11)
+                {
+                    return EstimateTokenCostImpl(11, 0, 0, ref values, len, ref tokens);
+                }
+                else
+                {
+                    return EstimateTokenCostImpl(12, 0, 0, ref values, len, ref tokens);
+                }
+            }
+
+            return ~0u;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlClusteringType.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlClusteringType.cs
new file mode 100644
index 0000000000..4435c5d199
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlClusteringType.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+/// <summary>
+/// JPEG XL ANS encoder clustering type
+/// </summary>
+internal enum JxlClusteringType : byte
+{
+    /// <summary>
+    /// Fastest clustering type, with only 4 clusters
+    /// </summary>
+    Fastest,
+
+    /// <summary>
+    /// A fast clustering type.
+    /// </summary>
+    Fast,
+
+    /// <summary>
+    /// Slower clustering type.
+    /// </summary>
+    Best,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHistogram.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHistogram.cs
new file mode 100644
index 0000000000..52637c9898
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHistogram.cs
@@ -0,0 +1,106 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+/// <summary>
+/// ANS histogram.
+/// </summary>
+internal sealed class JxlHistogram(int length)
+{
+    public List<int> Counts { get; set; } = new(length);
+
+    public int TotalCount { get; set; }
+
+    public float Entropy { get; set; }
+
+    /// <summary>
+    /// Resets all values to their defaults.
+    /// </summary>
+    public void Clear()
+    {
+        this.Counts.Clear();
+        this.TotalCount = 0;
+        this.Entropy = 0f;
+    }
+
+    /// <summary>
+    /// Adds a new symbol.
+    /// </summary>
+    /// <param name="symbol">
+    /// Index of the symbol to be added or, if it already
+    /// exists, incremented.
+    /// </param>
+    public void Add(int symbol)
+    {
+        // Just to be careful here. If the symbol is too large,
+        // this can allocate a lot of memory.
+        DebugGuard.MustBeLessThan(symbol, 1_000_000, nameof(symbol));
+
+        _ = this.Counts.EnsureCapacity(symbol);
+        this.Counts[symbol]++;
+        this.TotalCount++;
+    }
+
+    /// <summary>
+    /// Increments the specified symbol. This is equivalent to
+    /// <see cref="Add(int)"/> but without any checks, like ensuring capacity.
+    /// </summary>
+    /// <param name="symbol">Index of the symbol.</param>
+    public void FastAdd(int symbol) => this.Counts[symbol]++;
+
+    /// <summary>
+    /// Adds the counts of the specified histogram to the current histogram.
+    /// </summary>
+    /// <param name="other">A specified histogram to add to this histogram.</param>
+    public void AddHistogram(JxlHistogram other)
+    {
+        _ = this.Counts.EnsureCapacity(other.Counts.Count);
+
+        for (int i = 0; i < other.Counts.Count; i++)
+        {
+            this.Counts[i] += other.Counts[i];
+        }
+
+        this.TotalCount += other.TotalCount;
+    }
+
+    /// <summary>
+    /// Calculates the alphabet size.
+    /// </summary>
+    /// <returns>The alphabet size.</returns>
+    public int GetAlphabetSize()
+    {
+        for (int i = this.Counts.Count - 1; i >= 0; i--)
+        {
+            if (this.Counts[i] > 0)
+            {
+                return i + 1;
+            }
+        }
+
+        return 0;
+    }
+
+    /// <summary>
+    /// Finds the largest symbol.
+    /// </summary>
+    /// <returns>Largest symbol in the histogram.</returns>
+    public int GetMaxSymbol()
+    {
+        if (this.TotalCount == 0)
+        {
+            return 0;
+        }
+
+        for (int i = this.Counts.Count - 1; i > 0; i--)
+        {
+            if (this.Counts[i] != 0)
+            {
+                return i;
+            }
+        }
+
+        return 0;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHistogramParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHistogramParameters.cs
new file mode 100644
index 0000000000..c6d7526f72
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHistogramParameters.cs
@@ -0,0 +1,114 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+/// <summary>
+/// ANS histogram parameters
+/// </summary>
+internal sealed class JxlHistogramParameters
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlHistogramParameters"/> class with default values.
+    /// </summary>
+    public JxlHistogramParameters()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlHistogramParameters"/> class using the specified
+    /// speed tier that prioritizes performance over compression and vice versa.
+    /// </summary>
+    public JxlHistogramParameters(JxlSpeedTier tier)
+    {
+        if (tier > JxlSpeedTier.Falcon)
+        {
+            // Fast modes
+            this.Clustering = JxlClusteringType.Fastest;
+            this.Lz77Method = JxlLz77Method.None;
+        }
+        else if (tier > JxlSpeedTier.Tortoise)
+        {
+            // Normal modes
+            this.Clustering = JxlClusteringType.Fast;
+        }
+        else
+        {
+            // Slow modes
+            this.Clustering = JxlClusteringType.Best;
+        }
+
+        if (tier > JxlSpeedTier.Tortoise)
+        {
+            this.UIntMethod = JxlHybridUIntMethod.None;
+        }
+
+        if (tier >= JxlSpeedTier.Squirrel)
+        {
+            this.AnsHistogramStrategy = JxlAnsHistogramStrategy.Approximate;
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the clustering type. Default is Best.
+    /// </summary>
+    public JxlClusteringType Clustering { get; set; } = JxlClusteringType.Best;
+
+    /// <summary>
+    /// Gets or sets the hybrid uint method. Default is Best.
+    /// </summary>
+    public JxlHybridUIntMethod UIntMethod { get; set; } = JxlHybridUIntMethod.Best;
+
+    /// <summary>
+    /// Gets or sets the LZ77 method. Default is Rle.
+    /// </summary>
+    public JxlLz77Method Lz77Method { get; set; } = JxlLz77Method.Rle;
+
+    /// <summary>
+    /// Gets or sets the ANS histogram strategy. Default is Precise.
+    /// </summary>
+    public JxlAnsHistogramStrategy AnsHistogramStrategy { get; set; } = JxlAnsHistogramStrategy.Precise;
+
+    /// <summary>
+    /// Gets or sets image widths.
+    /// </summary>
+    public List<int> ImageWidths { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets the max number of histograms.
+    /// </summary>
+    public uint MaxHistograms { get; set; } = ~0u;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to prefer Huffman coding.
+    /// </summary>
+    public bool ForceHuffman { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether global state should be initialized.
+    /// (True by default)
+    /// </summary>
+    public bool InitializeGlobalState { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether streaming mode is enabled.
+    /// </summary>
+    public bool StreamingMode { get; set; }
+
+    public bool AddMissingSymbols { get; set; }
+
+    public bool AddFixedHistograms { get; set; }
+
+    /// <summary>
+    /// Gets the uint configuration for histogram parameters.
+    /// </summary>
+    public JxlAnsHybridUIntConfiguration UIntConfig => this.UIntMethod switch
+    {
+        JxlHybridUIntMethod.ContextMap => new(2, 0, 1),
+        JxlHybridUIntMethod.Method000 => new(0, 0, 0),
+        _ => new(),
+    };
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHybridUIntMethod.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHybridUIntMethod.cs
new file mode 100644
index 0000000000..a5150f7a74
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlHybridUIntMethod.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+/// <summary>
+/// Hybrid uint method.
+/// </summary>
+internal enum JxlHybridUIntMethod : byte
+{
+    /// <summary>
+    /// Simply use HybridUint420Configuration
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Force the fastest option.
+    /// </summary>
+    Method000,
+
+    /// <summary>
+    /// Try a couple of options.
+    /// </summary>
+    Fast,
+
+    /// <summary>
+    /// Fast choice for context maps.
+    /// </summary>
+    ContextMap,
+
+    /// <summary>
+    /// Slowest.
+    /// </summary>
+    Best,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlLz77Method.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlLz77Method.cs
new file mode 100644
index 0000000000..41cb9da764
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlLz77Method.cs
@@ -0,0 +1,90 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+/// <summary>
+/// Method for LZ77 compression.
+/// </summary>
+internal enum JxlLz77Method : byte
+{
+    /// <summary>
+    /// Do not use LZ77.
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Use Run Length Encoding
+    /// </summary>
+    Rle,
+
+    /// <summary>
+    /// LZ77 fast without runtime cost comparison
+    /// </summary>
+    Lz77b1w3f,
+
+    /// <summary>
+    /// LZ77
+    /// </summary>
+    Lz77b3w3f,
+
+    /// <summary>
+    /// LZ77
+    /// </summary>
+    Lz77b7w3f,
+
+    /// <summary>
+    /// LZ77
+    /// </summary>
+    Lz77b15w3f,
+
+    /// <summary>
+    /// Slow LZ77
+    /// </summary>
+    Lz77b31w3f,
+
+    /// <summary>
+    /// Fast LZ77, but with runtime cost comparison. Almost always worse.
+    /// </summary>
+    Lz77b1w3t,
+
+    /// <summary>
+    /// LZ77
+    /// </summary>
+    Lz77b3w3t,
+
+    /// <summary>
+    /// LZ77
+    /// </summary>
+    Lz77b7w3t,
+
+    /// <summary>
+    /// LZ77
+    /// </summary>
+    Lz77b15w3t,
+
+    /// <summary>
+    /// Slow LZ77
+    /// </summary>
+    Lz77b31w3t,
+
+    /// <summary>
+    /// Optimal-matching LZ77 (fast).
+    /// </summary>
+    Optc1,
+
+    /// <summary>
+    /// Optional-matching LZ77.
+    /// </summary>
+    Optc3,
+
+    /// <summary>
+    /// Optional-matching LZ77.
+    /// </summary>
+    Optc8,
+
+    /// <summary>
+    /// Optional-matching LZ77 parsing big chain length.
+    /// </summary>
+    Optc256,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlToken.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlToken.cs
new file mode 100644
index 0000000000..feb293a98d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Ans/JxlToken.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+
+internal struct JxlToken(JxlMaTreeContext c, uint value)
+{
+    public bool IsLz77Length;
+    public JxlMaTreeContext Context = c;
+    public uint Value = value;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlAuxiliaryOutput.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlAuxiliaryOutput.cs
new file mode 100644
index 0000000000..d39b707bc2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlAuxiliaryOutput.cs
@@ -0,0 +1,82 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+
+/// <summary>
+/// Provides statistics gathered during compression or decompression.
+/// </summary>
+internal sealed class JxlAuxiliaryOutput
+{
+    public JxlLayerTotals[] Layers { get; set; } = new JxlLayerTotals[JxlAuxiliaryOutputConstants.NumberOfImageLayers];
+
+    public long NumberOfBlocks { get; set; }
+
+    public long NumberOfSmallBlocks { get; set; }
+
+    public long NumberOfDct4x8Blocks { get; set; }
+
+    public long NumberOfAfvBlocks { get; set; }
+
+    public long NumberOfDct8Blocks { get; set; }
+
+    public long NumberOfDct8x16Blocks { get; set; }
+
+    public long NumberOfDct8x32Blocks { get; set; }
+
+    public long NumberOfDct16Blocks { get; set; }
+
+    public long NumberOfDct16x32Blocks { get; set; }
+
+    public long NumberOfDct32Blocks { get; set; }
+
+    public long NumberOfDct32x64Blocks { get; set; }
+
+    public long NumberOfDct64Blocks { get; set; }
+
+    public long NumberOfButteraugliIterations { get; set; }
+
+    public long TotalBits => this.Layers.Sum(x => x.TotalBits);
+
+    public static string GetLayerName(JxlLayerType layer) => layer switch
+    {
+        JxlLayerType.Header => "Headers",
+        JxlLayerType.Toc => "TOC",
+        JxlLayerType.Dictionary => "Patches",
+        JxlLayerType.Splines => "Splines",
+        JxlLayerType.Noise => "Noise",
+        JxlLayerType.Quant => "Quantizer",
+        JxlLayerType.ModularTree => "ModularTree",
+        JxlLayerType.ModularGlobal => "ModularGlobal",
+        JxlLayerType.Dc => "DC",
+        JxlLayerType.ModularDcGroup => "ModularDcGroup",
+        JxlLayerType.ControlFields => "ControlFields",
+        JxlLayerType.Order => "CoeffOrder",
+        JxlLayerType.Ac => "ACHistograms",
+        JxlLayerType.AcTokens => "ACTokens",
+        JxlLayerType.ModularAcGroup => "ModularAcGroup",
+        _ => "Invalid",
+    };
+
+    public void Assimilate(JxlAuxiliaryOutput victim)
+    {
+        for (int i = 0; i < JxlAuxiliaryOutputConstants.NumberOfImageLayers; i++)
+        {
+            this.Layers[i].Assimilate(victim.Layers[i]);
+        }
+
+        this.NumberOfBlocks += victim.NumberOfBlocks;
+        this.NumberOfSmallBlocks += victim.NumberOfSmallBlocks;
+        this.NumberOfDct4x8Blocks += victim.NumberOfDct4x8Blocks;
+        this.NumberOfAfvBlocks += victim.NumberOfAfvBlocks;
+        this.NumberOfDct8Blocks += victim.NumberOfDct8Blocks;
+        this.NumberOfDct8x16Blocks += victim.NumberOfDct8x16Blocks;
+        this.NumberOfDct8x32Blocks += victim.NumberOfDct8x32Blocks;
+        this.NumberOfDct16Blocks += victim.NumberOfDct16Blocks;
+        this.NumberOfDct16x32Blocks += victim.NumberOfDct16x32Blocks;
+        this.NumberOfDct32Blocks += victim.NumberOfDct32Blocks;
+        this.NumberOfDct32x64Blocks += victim.NumberOfDct32x64Blocks;
+        this.NumberOfDct64Blocks += victim.NumberOfDct64Blocks;
+        this.NumberOfButteraugliIterations += victim.NumberOfButteraugliIterations;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlAuxiliaryOutputConstants.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlAuxiliaryOutputConstants.cs
new file mode 100644
index 0000000000..1c1b4edd5c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlAuxiliaryOutputConstants.cs
@@ -0,0 +1,9 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+
+internal class JxlAuxiliaryOutputConstants
+{
+    public const int NumberOfImageLayers = (int)JxlLayerType.ModularAcGroup + 1;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlLayerTotals.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlLayerTotals.cs
new file mode 100644
index 0000000000..a62785cbd9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlLayerTotals.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+
+internal struct JxlLayerTotals
+{
+    public int NumberOfClusteredHistograms;
+    public int ExtraBits;
+    public int HistogramBits;
+    public int TotalBits;
+    public double ClusteredEntropy;
+
+    public void Assimilate(in JxlLayerTotals victim)
+    {
+        this.NumberOfClusteredHistograms += victim.NumberOfClusteredHistograms;
+        this.HistogramBits += victim.HistogramBits;
+        this.ExtraBits += victim.ExtraBits;
+        this.TotalBits += victim.TotalBits;
+        this.ClusteredEntropy += victim.ClusteredEntropy;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlLayerType.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlLayerType.cs
new file mode 100644
index 0000000000..5852bd654d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/AuxiliaryOutput/JxlLayerType.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+
+internal enum JxlLayerType : byte
+{
+    Header = 0,
+    Toc,
+    Dictionary,
+    Splines,
+    Noise,
+    Quant,
+    ModularTree,
+    ModularGlobal,
+    Dc,
+    ModularDcGroup,
+    ControlFields,
+    Order,
+    Ac,
+    AcTokens,
+    ModularAcGroup,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/ButteraugliJxlComparator.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/ButteraugliJxlComparator.cs
new file mode 100644
index 0000000000..919446bfca
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/ButteraugliJxlComparator.cs
@@ -0,0 +1,83 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics.Tensors;
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Butteraugli;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Comparator;
+
+/// <summary>
+/// Compares images using Google Butteraugli.
+/// </summary>
+internal sealed class ButteraugliJxlComparator(ButteraugliParameters parameters, JxlCmsInterface cms)
+    : JxlComparator
+{
+    private int width;
+    private int height;
+    private float intensityTarget;
+    private ButteraugliComparator? comparator;
+
+    public override float GoodQualityScore => Butteraugli.Butteraugli.ButteraugliFuzzyInverse(1.5f);
+
+    public override float BadQualityScore => Butteraugli.Butteraugli.ButteraugliFuzzyInverse(0.5f);
+
+    public override void CompareWith(Configuration configuration, JxlImageBundle actual, JxlImageF? diffMap, out float score)
+    {
+        DebugGuard.NotNull(this.comparator, nameof(this.comparator));
+
+        if (this.width != actual.XSize || this.height != actual.YSize)
+        {
+            throw new InvalidOperationException("Image must have same size");
+        }
+
+        JxlImageMetadata metadata = actual.Metadata!;
+        JxlImageBundle store = new(metadata);
+
+        JxlTransformsEncoder.TransformIfNeeded(configuration, actual, JxlColorEncoding.LinearSRgb(actual.IsGray), cms, store, out JxlImageBundle actualLinearSRgb);
+
+        JxlImageF tempDiffmap = new(configuration, this.width, this.height);
+        JxlImage3F scaledActualLinearSRgb = actualLinearSRgb.Color!;
+
+        if (this.intensityTarget != 0 && actual.Metadata!.IntensityTarget != this.intensityTarget)
+        {
+            JxlImage3F scaledActualLinearSRgbStore = new(configuration, this.width, this.height);
+            scaledActualLinearSRgb = scaledActualLinearSRgbStore;
+
+            float scale = actual.Metadata!.IntensityTarget / this.intensityTarget;
+            for (int c = 0; c < 3; ++c)
+            {
+                for (int y = 0; y < this.height; ++y)
+                {
+                    Span<float> souceRow = actualLinearSRgb.Color!.PlaneRow(c, y);
+                    Span<float> scaledRow = scaledActualLinearSRgb.PlaneRow(c, y);
+                    TensorPrimitives.Multiply(souceRow, scale, scaledRow);
+                }
+            }
+        }
+
+        if (!this.comparator.Diffmap(configuration, scaledActualLinearSRgb, tempDiffmap))
+        {
+            throw new InvalidOperationException("Diffmap failed");
+        }
+
+        score = Butteraugli.Butteraugli.ButteraugliScoreFromDiffmap(tempDiffmap, parameters);
+        diffMap?.Swap(tempDiffmap);
+    }
+
+    public override void SetReferenceImage(Configuration configuration, JxlImageBundle reference)
+    {
+        JxlImageMetadata metadata = reference.Metadata!;
+        JxlImageBundle store = new(metadata);
+
+        JxlTransformsEncoder.TransformIfNeeded(configuration, reference, JxlColorEncoding.LinearSRgb(reference.IsGray), cms, store, out JxlImageBundle refLinearSRgb);
+        this.comparator = ButteraugliComparator.Make(configuration, refLinearSRgb.Color!, parameters);
+
+        this.width = reference.XSize;
+        this.height = reference.YSize;
+        this.intensityTarget = reference.Metadata!.IntensityTarget;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/JxlComparator.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/JxlComparator.cs
new file mode 100644
index 0000000000..920e929099
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/JxlComparator.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Comparator;
+
+/// <summary>
+/// Compares images.
+/// </summary>
+internal abstract class JxlComparator
+{
+    public abstract float GoodQualityScore { get; }
+
+    public abstract float BadQualityScore { get; }
+
+    // Sets the reference image, the first to compare.
+    public abstract void SetReferenceImage(Configuration configuration, JxlImageBundle reference);
+
+    // Sets the actual image, the second to compare.
+    public abstract void CompareWith(
+        Configuration configuration,
+        JxlImageBundle actual,
+        JxlImageF? diffMap,
+        out float score);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/JxlComparatorScoreComputation.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/JxlComparatorScoreComputation.cs
new file mode 100644
index 0000000000..8dec22e152
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/JxlComparatorScoreComputation.cs
@@ -0,0 +1,175 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics.Tensors;
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Comparator;
+
+internal static class JxlComparatorScoreComputation
+{
+    private static void AlphaBlend(JxlImage3F input, int c, float backgroundLinear, JxlImageF alpha, JxlImage3F output)
+    {
+        float background = (float)JxlGammaCorrect.LinearToSRgb8Direct(backgroundLinear);
+
+        for (int y = 0; y < output.YSize; y++)
+        {
+            ReadOnlySpan<float> rowA = alpha.GetRow(y);
+            ReadOnlySpan<float> rowI = input.PlaneRow(c, y);
+            Span<float> rowO = output.PlaneRow(c, y);
+
+            for (int x = 0; x < output.XSize; x++)
+            {
+                float a = rowA[x];
+
+                if (a <= 0.0f)
+                {
+                    rowO[x] = backgroundLinear;
+                }
+                else if (a >= 1.0f)
+                {
+                    rowO[x] = rowI[x];
+                }
+                else
+                {
+                    float wFg = a;
+                    float wBg = 1.0f - wFg;
+                    float fg = wFg * (float)JxlGammaCorrect.LinearToSRgb8Direct(rowI[x]);
+                    float bg = wBg * background;
+
+                    rowO[x] = (float)JxlGammaCorrect.SRgb8ToLinearDirect(fg + bg);
+                }
+            }
+        }
+    }
+
+    private static void AlphaBlend(float backgroundLinear, JxlImageBundle image)
+    {
+        if (!image.ContainsAlpha)
+        {
+            return;
+        }
+
+        for (int c = 0; c < 3; c++)
+        {
+            AlphaBlend(image.Color!, c, backgroundLinear, image.Alpha!, image.Color!);
+        }
+    }
+
+    private static void ComputeScoreImpl(Configuration configuration, JxlImageBundle rgb0, JxlImageBundle rgb1, JxlComparator comparator, JxlImageF? diffMap, out float score)
+    {
+        comparator.SetReferenceImage(rgb0);
+        comparator.CompareWith(configuration, rgb1, diffMap, out score);
+    }
+
+    public static void ComputeScore(
+        Configuration configuration,
+        JxlImageBundle rgb0,
+        JxlImageBundle rgb1,
+        JxlComparator comparator,
+        JxlCmsInterface cms,
+        out float score,
+        JxlImageF? diffMap = null,
+        bool ignoreAlpha = false)
+    {
+        JxlImageMetadata metadata0 = rgb0.Metadata.Copy();
+
+        JxlImageBundle store0 = new(metadata0);
+
+        JxlTransformsEncoder.TransformIfNeeded(
+            rgb0,
+            JxlColorEncoding.LinearSRgb(rgb0.IsGray),
+            cms,
+            pool,
+            store0,
+            out JxlImageBundle linearSrgb0);
+
+        JxlImageMetadata metadata1 = rgb1.Metadata.Copy();
+
+        JxlImageBundle store1 = new(metadata1);
+
+        JxlTransformsEncoder.TransformIfNeeded(
+            rgb1,
+            JxlColorEncoding.LinearSRgb(rgb1.IsGray),
+            cms,
+            pool,
+            store1,
+            out JxlImageBundle linearSrgb1);
+
+        if (ignoreAlpha || (!rgb0.ContainsAlpha && !rgb1.ContainsAlpha))
+        {
+            ComputeScoreImpl(
+                configuration,
+                linearSrgb0,
+                linearSrgb1,
+                comparator,
+                diffMap,
+                out score);
+        }
+
+        JxlImageF diffMapBlack = new();
+        float distBlack;
+        {
+            const float black = 0.0f;
+
+            JxlImageBundle blendedBlack0 = linearSrgb0.Copy(configuration);
+            JxlImageBundle blendedBlack1 = linearSrgb1.Copy(configuration);
+
+            AlphaBlend(black, blendedBlack0);
+            AlphaBlend(black, blendedBlack1);
+
+            ComputeScoreImpl(
+                configuration,
+                blendedBlack0,
+                blendedBlack1,
+                comparator,
+                diffMapBlack,
+                out distBlack);
+        }
+
+        JxlImageF diffMapWhite = new();
+        float distWhite;
+        {
+            const float white = 1.0f;
+
+            JxlImageBundle blendedWhite0 = linearSrgb0.Copy(configuration);
+            JxlImageBundle blendedWhite1 = linearSrgb1.Copy(configuration);
+
+            AlphaBlend(white, blendedWhite0);
+            AlphaBlend(white, blendedWhite1);
+
+            ComputeScoreImpl(
+                configuration,
+                blendedWhite0,
+                blendedWhite1,
+                comparator,
+                diffMapWhite,
+                out distWhite);
+        }
+
+        if (diffMap is not null)
+        {
+            int xSize = rgb0.XSize;
+            int ySize = rgb0.YSize;
+
+            JxlImageF outputDiffMap = new(
+                configuration,
+                xSize,
+                ySize);
+
+            for (int y = 0; y < ySize; y++)
+            {
+                ReadOnlySpan<float> rowBlack = diffMapBlack.GetRow(y);
+                ReadOnlySpan<float> rowWhite = diffMapWhite.GetRow(y);
+                Span<float> rowOut = diffMap.GetRow(y);
+
+                TensorPrimitives.Max(rowBlack, rowWhite, rowOut);
+            }
+        }
+
+        score = MathF.Max(distBlack, distWhite);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/NullComparator.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/NullComparator.cs
new file mode 100644
index 0000000000..810c4c59a0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Comparator/NullComparator.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Comparator;
+
+/// <summary>
+/// Performs no image comparison at all.
+/// </summary>
+internal sealed class NullComparator : JxlComparator
+{
+    public override float GoodQualityScore => 0;
+
+    public override float BadQualityScore => 0;
+
+    public override void CompareWith(Configuration configuration, JxlImageBundle actual, JxlImageF? diffMap, out float score) => score = 0;
+
+    public override void SetReferenceImage(Configuration configuration, JxlImageBundle reference)
+    {
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/FjxlBitWriter.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/FjxlBitWriter.cs
new file mode 100644
index 0000000000..54277d41a9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/FjxlBitWriter.cs
@@ -0,0 +1,88 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless;
+
+/// <summary>
+/// Simple MSB-first bit-stream writer implementation built on top
+/// of a stream.
+/// </summary>
+/// <param name="stream">Output bytes are written here.</param>
+internal sealed class FjxlBitWriter(Stream stream) : IDisposable
+{
+    /// <summary>
+    /// Temporary cache used to store pending written bits
+    /// before they're written to the output stream.
+    /// </summary>
+    private ulong buffer;
+
+    /// <summary>
+    /// Gets the total number of bytes written to the output buffer so far.
+    /// </summary>
+    public long BytesWritten { get; private set; }
+
+    /// <summary>
+    /// Gets the number of bits actively in the bit cache.
+    /// This is used to track how many bits were written into
+    /// the cache prior to sending the cache to the stream.
+    /// </summary>
+    public int BitsInBuffer { get; private set; }
+
+    /// <summary>
+    /// Writes the specified bits in the Most Significant Byte (MSB)
+    /// order.
+    /// </summary>
+    /// <param name="count">Represents the number of bits to write to the bit-stream.</param>
+    /// <param name="bits">Represents the value to write to the bit-stream.</param>
+    public void Write(int count, ulong bits)
+    {
+        DebugGuard.MustBeBetweenOrEqualTo(count, 0, 56, nameof(count));
+
+        if (count < 64)
+        {
+            bits &= (1UL << count) - 1;
+        }
+
+        this.buffer |= bits << this.BitsInBuffer;
+        this.BitsInBuffer += count;
+
+        this.FlushBytes();
+    }
+
+    /// <summary>
+    /// Internal method used to flush bytes from the cache
+    /// (<see cref="buffer"/>) into the output stream.
+    /// </summary>
+    private void FlushBytes()
+    {
+        int bytes = this.BitsInBuffer / 8;
+
+        for (int i = 0; i < bytes; i++)
+        {
+            stream.WriteByte((byte)this.buffer);
+            this.BytesWritten++;
+            this.buffer >>= 8;
+        }
+
+        this.BitsInBuffer -= bytes * 8;
+    }
+
+    /// <summary>
+    /// Used by the dispose method to flush the remaining bits
+    /// that are not byte-aligned. F.e. if we dispose this reader
+    /// and we have 5 bits left, those final 5 bits are set to all 0
+    /// and the byte is written to the stream.
+    /// </summary>
+    public void ZeroPadToByte()
+    {
+        if (this.BitsInBuffer != 0)
+        {
+            this.Write(8 - this.BitsInBuffer, 0);
+        }
+    }
+
+    /// <summary>
+    /// Flushes out the final bytes.
+    /// </summary>
+    public void Dispose() => this.ZeroPadToByte();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/FjxlPrefixCode.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/FjxlPrefixCode.cs
new file mode 100644
index 0000000000..4663ed74ee
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/FjxlPrefixCode.cs
@@ -0,0 +1,461 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless;
+
+/// <summary>
+/// The prefix code is used for encoding LZ77-compressed coefficients.
+/// </summary>
+internal sealed class FjxlPrefixCode
+{
+#pragma warning disable SA1401 // Fields should be private
+
+    /// <summary>
+    /// Maximum number of raw symbols for prefix coding.
+    /// </summary>
+    private const int MaxNumSymbols = JxlFastLosslessEncoder.NumRawSymbols + 1 < JxlFastLosslessEncoder.NumLz77 ? JxlFastLosslessEncoder.NumLz77 : JxlFastLosslessEncoder.NumRawSymbols + 1;
+
+    /// <summary>
+    /// Gets or sets the Huffman raw bit lengths.
+    /// </summary>
+    public InlineArray19<byte> RawLengths;
+
+    /// <summary>
+    /// Gets or sets the Huffman raw code values.
+    /// </summary>
+    public InlineArray19<byte> RawCodes;
+
+    /// <summary>
+    /// Gets or sets the Huffman LZ77 bit lengths.
+    /// </summary>
+    public InlineArray33<byte> Lz77Lengths;
+
+    /// <summary>
+    /// Gets or sets the Huffman LZ77 code values.
+    /// </summary>
+    public InlineArray33<ushort> Lz77Codes;
+
+    /// <summary>
+    /// Gets or sets the Huffman LZ77 cache code values.
+    /// </summary>
+    public InlineArray32<ulong> Lz77CacheBits;
+
+    /// <summary>
+    /// Gets or sets the Huffman LZ77 cache bit lengths.
+    /// </summary>
+    public InlineArray32<byte> Lz77CacheLengths;
+
+    public FjxlPrefixCode(Span<ulong> rawCounts, Span<ulong> lz77Counts)
+    {
+        Span<ulong> level1Counts = stackalloc ulong[JxlFastLosslessEncoder.NumRawSymbols + 1];
+        rawCounts[..JxlFastLosslessEncoder.NumRawSymbols].CopyTo(level1Counts);
+
+        this.RawCount = JxlFastLosslessEncoder.NumRawSymbols;
+
+        while (this.RawCount > 0 && level1Counts[this.RawCount - 1] == 0)
+        {
+            this.RawCount--;
+        }
+
+        level1Counts[this.RawCount] = 0;
+
+        for (int i = 0; i < JxlFastLosslessEncoder.NumLz77; i++)
+        {
+            level1Counts[this.RawCount] += lz77Counts[i];
+        }
+
+        Span<byte> level1Lengths = stackalloc byte[JxlFastLosslessEncoder.NumRawSymbols + 1];
+        level1Lengths.Clear();
+
+        ComputeCodeLengths(level1Counts, this.RawCount + 1, JxlFastLosslessEncoder.MinimumRawLength, JxlFastLosslessEncoder.MaximumRawLength, level1Lengths);
+
+        Span<byte> level2Lengths = stackalloc byte[JxlFastLosslessEncoder.NumLz77];
+        Span<byte> minLengths = stackalloc byte[JxlFastLosslessEncoder.NumLz77];
+
+        level2Lengths.Clear();
+        minLengths.Clear();
+
+        int l = 15 - level1Lengths[this.RawCount];
+        Span<byte> maxLengths = stackalloc byte[JxlFastLosslessEncoder.NumLz77];
+        maxLengths.Fill((byte)l);
+
+        int numLz77 = JxlFastLosslessEncoder.NumLz77;
+        while (numLz77 > 0 && lz77Counts[numLz77 - 1] == 0)
+        {
+            numLz77--;
+        }
+
+        ComputeCodeLengths(lz77Counts, numLz77, minLengths, maxLengths, level2Lengths);
+
+        level1Lengths[..this.RawCount].CopyTo(this.RawLengths);
+
+        for (int i = 0; i < numLz77; i++)
+        {
+            this.Lz77Lengths[i] = (byte)(level2Lengths[i] != 0 ? level1Lengths[this.RawCount] + level2Lengths[i] : 0);
+        }
+
+        ComputeCanonicalCode(this.RawLengths, this.RawCodes, this.Lz77Lengths, this.Lz77Codes);
+
+        // Prepare the LZ77 cache
+        for (int count = 0; count < JxlFastLosslessEncoder.Lz77CacheSize; count++)
+        {
+            EncodeHybridUintLz77(count, out int token, out int nbits, out int bits);
+            this.Lz77CacheLengths[count] = (byte)(this.Lz77Lengths[token] + nbits + this.RawLengths[0]);
+            this.Lz77CacheBits[count] =
+                (ulong)((((bits << this.Lz77Lengths[token]) | this.Lz77Codes[token]) << this.RawLengths[0]) |
+                this.RawLengths[0]);
+        }
+    }
+
+    /// <summary>
+    /// Gets a lookup used to reverse integers bit-wise.
+    /// </summary>
+    private static ReadOnlySpan<ushort> ReverseNibbleLookup =>
+    [
+        0b0000, 0b1000, 0b0100, 0b1100, 0b0010, 0b1010, 0b0110, 0b1110,
+            0b0001, 0b1001, 0b0101, 0b1101, 0b0011, 0b1011, 0b0111, 0b1111,
+        ];
+
+#pragma warning restore SA1401 // Fields should be private
+
+    /// <summary>
+    /// Gets or sets the number of raw codes.
+    /// </summary>
+    public int RawCount { get; set; }
+
+    /// <summary>
+    /// Reverses the integer bit-wise.
+    /// </summary>
+    /// <param name="nbits">Number of bits for the integer.</param>
+    /// <param name="bits">Actual bits to reverse.</param>
+    /// <returns>
+    /// Input integer but reversed. F.e. 10010 becomes 01001.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ushort BitReverse(int nbits, ushort bits)
+    {
+        unchecked
+        {
+            ushort rev16 = (ushort)((ReverseNibbleLookup[bits & 0xF] << 12) |
+                 (ReverseNibbleLookup[(bits >> 4) & 0xF] << 8) |
+                 (ReverseNibbleLookup[(bits >> 8) & 0xF] << 4) |
+                 ReverseNibbleLookup[bits >> 12]);
+            return (ushort)(rev16 >> (16 - nbits));
+        }
+    }
+
+    private static void ComputeCanonicalCode(Span<byte> firstChunkLengths, Span<byte> firstChunkCodes, Span<byte> secondChunkLengths, Span<ushort> secondChunkCodes)
+    {
+        const int maxCodeLength = 15;
+
+        Span<byte> codeLengthCounts = stackalloc byte[maxCodeLength + 1];
+        codeLengthCounts.Clear();
+
+        for (int i = 0; i < firstChunkCodes.Length; i++)
+        {
+            codeLengthCounts[firstChunkLengths[i]]++;
+
+            if (firstChunkLengths[i] > 8)
+            {
+                throw new InvalidOperationException("First chunk length is too large");
+            }
+
+            if (firstChunkLengths[i] <= 0)
+            {
+                throw new InvalidOperationException("First chunk length cannot be <= 0");
+            }
+        }
+
+        for (int i = 0; i < secondChunkCodes.Length; i++)
+        {
+            codeLengthCounts[secondChunkLengths[i]]++;
+
+            if (secondChunkLengths[i] > maxCodeLength)
+            {
+                throw new InvalidOperationException("Second chunk length is too large");
+            }
+        }
+
+        Span<ushort> nextCode = stackalloc ushort[maxCodeLength + 1];
+        nextCode.Clear();
+
+        ushort code = 0;
+
+        for (int i = 1; i < maxCodeLength + 1; i++)
+        {
+            code = unchecked((ushort)((code + codeLengthCounts[i - 1]) << 1));
+            nextCode[i] = code;
+        }
+
+        unchecked
+        {
+            for (int i = 0; i < firstChunkCodes.Length; i++)
+            {
+                firstChunkCodes[i] = (byte)BitReverse(firstChunkLengths[i], nextCode[firstChunkLengths[i]]++);
+            }
+
+            for (int i = 0; i < secondChunkCodes.Length; i++)
+            {
+                secondChunkCodes[i] = (byte)BitReverse(secondChunkLengths[i], nextCode[secondChunkLengths[i]]++);
+            }
+        }
+    }
+
+    private static void ComputeCodeLengthsNonZeroImpl<T>(
+        Span<ulong> freqs,
+        int n,
+        int precision,
+        T infty,
+        Span<byte> minLimit,
+        Span<byte> maxLimit,
+        Span<byte> nbits)
+        where T : unmanaged, INumber<T>
+    {
+        DebugGuard.MustBeLessThan(precision, 15, nameof(precision));
+        DebugGuard.MustBeLessThanOrEqualTo(n, MaxNumSymbols, nameof(n));
+
+        int scale = 1 << precision;
+        int width = scale + 1;
+
+        Span<T> dynp = stackalloc T[width * (n + 1)];
+        dynp.Fill(infty);
+        dynp[0] = T.Zero;
+
+        for (int sym = 0; sym < n; sym++)
+        {
+            for (int bits = minLimit[sym]; bits <= maxLimit[sym]; bits++)
+            {
+                int offsetDelta = 1 << (precision - bits);
+                T cost = T.CreateChecked(freqs[sym]) * T.CreateChecked(bits);
+
+                for (int off = 0; off + offsetDelta <= scale; off++)
+                {
+                    int current = (sym * width) + off;
+                    int next = ((sym + 1) * width) + off + offsetDelta;
+
+                    dynp[next] = T.Min(dynp[current] + cost, dynp[next]);
+                }
+            }
+        }
+
+        int offFinal = scale;
+
+        for (int sym = n - 1; sym >= 0; sym--)
+        {
+            if (offFinal <= 0)
+            {
+                throw new InvalidOperationException("Offset should be greater than zero");
+            }
+
+            for (int bits = minLimit[sym]; bits <= maxLimit[sym]; bits++)
+            {
+                int offsetDelta = 1 << (precision - bits);
+
+                if (offsetDelta <= offFinal)
+                {
+                    int current = (sym * width) + offFinal;
+                    int previous = (sym * width) + offFinal - offsetDelta;
+
+                    T cost = T.CreateChecked(freqs[sym]) * T.CreateChecked(bits);
+
+                    if (dynp[current] == dynp[previous] + cost)
+                    {
+                        offFinal -= offsetDelta;
+                        nbits[sym] = (byte)bits;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    private static void ComputeCodeLengthsNonZero(Span<ulong> freqs, int n, Span<byte> minLimit, Span<byte> maxLimit, Span<byte> nbits)
+    {
+        int precision = 0;
+        int shortestLength = 255;
+        ulong frequencySum = 0;
+
+        for (int i = 0; i < n; i++)
+        {
+            frequencySum += freqs[i];
+
+            if (minLimit[i] < 1)
+            {
+                minLimit[i] = 1;
+            }
+
+            precision = Math.Max(maxLimit[i], precision);
+            shortestLength = Math.Min(minLimit[i], shortestLength);
+        }
+
+        precision -= shortestLength - 1;
+        ulong infinity = frequencySum * (ulong)precision;
+
+        if (infinity < uint.MaxValue / 2)
+        {
+            ComputeCodeLengthsNonZeroImpl(freqs, n, precision, (uint)infinity, minLimit, maxLimit, nbits);
+        }
+        else
+        {
+            ComputeCodeLengthsNonZeroImpl(freqs, n, precision, infinity, minLimit, maxLimit, nbits);
+        }
+    }
+
+    private static void ComputeCodeLengths(Span<ulong> freqs, int n, ReadOnlySpan<byte> minLimitIn, ReadOnlySpan<byte> maxLimitIn, Span<byte> nbits)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(n, MaxNumSymbols, nameof(n));
+
+        Span<ulong> compactFreqs = stackalloc ulong[MaxNumSymbols];
+        Span<byte> minLimit = stackalloc byte[MaxNumSymbols];
+        Span<byte> maxLimit = stackalloc byte[MaxNumSymbols];
+
+        int ni = 0;
+        for (int i = 0; i < n; i++)
+        {
+            if (freqs[i] != 0)
+            {
+                compactFreqs[ni] = freqs[i];
+                minLimit[ni] = minLimitIn[i];
+                maxLimit[ni] = maxLimitIn[i];
+                ni++;
+            }
+        }
+
+        compactFreqs[ni..].Clear();
+        minLimit[ni..].Clear();
+        maxLimit[ni..].Clear();
+
+        Span<byte> numBits = stackalloc byte[MaxNumSymbols];
+        numBits.Clear();
+
+        ComputeCodeLengthsNonZero(compactFreqs, ni, minLimit, maxLimit, numBits);
+
+        ni = 0;
+
+        for (int i = 0; i < n; i++)
+        {
+            nbits[i] = 0;
+            if (freqs[i] != 0)
+            {
+                nbits[i] = numBits[ni++];
+            }
+        }
+    }
+
+    /// <summary>
+    /// Writes this LZ77 prefix code into the bit-stream.
+    /// </summary>
+    /// <param name="writer">The bit-stream to write the prefix code into.</param>
+    public void Write(FjxlBitWriter writer)
+    {
+        Span<ulong> codeLengthCounts = stackalloc ulong[32].Slice(0, 18);
+        codeLengthCounts.Clear();
+        codeLengthCounts[17] = 3 + (2 * (JxlFastLosslessEncoder.NumLz77 - 1));
+
+        for (int i = 0; i < 19; i++)
+        {
+            byte rawLength = this.RawLengths[i];
+
+            codeLengthCounts[rawLength]++;
+        }
+
+        for (int i = 0; i < 33; i++)
+        {
+            byte lz77Length = this.Lz77Lengths[i];
+
+            codeLengthCounts[lz77Length]++;
+        }
+
+        // Lengths for representing the code length
+        Span<byte> codeLengthLengths = stackalloc byte[32].Slice(0, 18);
+        Span<byte> codeLengthLengthsMinimum = stackalloc byte[32].Slice(0, 18);
+        Span<byte> codeLengthLengthsMaximum = stackalloc byte[32].Slice(0, 18);
+
+        codeLengthLengths.Clear();
+        codeLengthLengthsMinimum.Clear();
+        codeLengthLengthsMaximum.Fill(5);
+
+        ComputeCodeLengths(codeLengthCounts, 18, codeLengthLengthsMinimum, codeLengthLengthsMaximum, codeLengthLengths);
+
+        writer.Write(2, 0b00); // HSKIP = 0 (Don't skip code lengths)
+
+        // As per Brotli RFC
+        Span<byte> codeLengthOrder = [1, 2, 3, 4,  0,  5,  17, 6,  16,
+                                          7, 8, 9, 10, 11, 12, 13, 14, 15];
+
+        // Lengths & codes for representing lengths of code lengths
+        Span<byte> codeLengthLengthLengths = [2, 4, 3, 2, 2, 4];
+        Span<byte> codeLengthLengthCodes = [0, 7, 3, 2, 1, 15];
+
+        // Maximum number of code lengths
+        int numCodeLengths = 18;
+        while (codeLengthLengths[codeLengthOrder[numCodeLengths - 1]] == 0)
+        {
+            numCodeLengths--;
+        }
+
+        // Max bits written in this loop: 18 * 4 = 72
+        for (int i = 0; i < numCodeLengths; i++)
+        {
+            int symbol = codeLengthLengths[codeLengthOrder[i]];
+            writer.Write(codeLengthLengthLengths[symbol], codeLengthLengthCodes[symbol]);
+        }
+
+        Span<ushort> codeLengthBits = stackalloc ushort[32].Slice(0, 18);
+        codeLengthBits.Clear();
+        ComputeCanonicalCode([], [], codeLengthLengths, codeLengthBits);
+
+        for (int i = 0; i < 19; i++)
+        {
+            byte rawLength = this.RawLengths[i];
+
+            writer.Write(codeLengthLengths[rawLength], codeLengthBits[rawLength]);
+        }
+
+        int numLz77 = JxlFastLosslessEncoder.NumLz77;
+        while (this.Lz77Lengths[numLz77 - 1] == 0)
+        {
+            numLz77--;
+        }
+
+        // Max bits in this block: 24
+        writer.Write(codeLengthLengths[17], codeLengthBits[17]);
+        writer.Write(3, 0b010); // 5
+        writer.Write(codeLengthLengths[17], codeLengthBits[17]);
+        writer.Write(3, 0b000); // (5 - 2) * 8 + 3 = 27
+        writer.Write(codeLengthLengths[17], codeLengthBits[17]);
+        writer.Write(3, 0b010); // (27 - 2) * 8 + 5 = 205
+
+        // Encode LZ77 symbols with values 224 + i.
+        // Max. bits in this loop: 33 * 5 = 165
+        for (int i = 0; i < numLz77; i++)
+        {
+            writer.Write(codeLengthLengths[this.Lz77Lengths[i]], codeLengthBits[this.Lz77Lengths[i]]);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void EncodeHybridUintLz77(int value, out int token, out int nBits, out int bits)
+    {
+        unchecked
+        {
+            int n = (int)JxlFastLosslessEncoder.FloorLog2((uint)value);
+
+            if (value < 16)
+            {
+                token = value;
+                nBits = 0;
+                bits = 0;
+            }
+            else
+            {
+                token = 16 + n - 4;
+                nBits = n;
+                bits = value - (1 << n);
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/JxlFastLosslessEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/JxlFastLosslessEncoder.cs
new file mode 100644
index 0000000000..308e604277
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/JxlFastLosslessEncoder.cs
@@ -0,0 +1,645 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd;
+
+// Suppress IDE0057. This is so we can stack-allocate
+// a powers of 2 and then slice it to the appropriate
+// length (which produces better code).
+//
+// Without this suppression, the analyzer produces a warning,
+// recommending changing this:
+//    stackalloc ulong[32].Slice(0, 18)
+// to:
+//    (stackalloc ulong[32])[..18]
+//
+// But then the analyzer produces a new warning, recommending
+// to remove the paranthesis, changing this:
+//    (stackalloc ulong[32])[..18]
+// to:
+//    stackalloc ulong[32][..18]
+//
+// which is invalid C# syntax.
+#pragma warning disable IDE0057 // Use range operator
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless;
+
+/// <summary>
+/// Extreme performance JPEG XL encoder which provides minimal lossless compression.
+/// It also uses minimal dependencies.
+/// </summary>
+internal sealed class JxlFastLosslessEncoder
+{
+    /// <summary>
+    /// Specifies maximum number of bytes a frame header may use.
+    /// </summary>
+    public const int MaxFrameHeaderSize = 5;
+
+    public const int NumRawSymbols = 19;
+
+    public const int NumLz77 = 33;
+
+    /// <summary>
+    /// Cache/dictionary size for LZ77
+    /// </summary>
+    public const int Lz77CacheSize = 32;
+
+    public const int Lz77Offset = 224;
+
+    public const int Lz77MinLength = 7;
+
+    private static readonly int LogChunkSize =
+        JxlSimdTarget.Using512BitVectors
+            ? 5
+            : JxlSimdTarget.Using256BitVectors
+                ? 4
+                : 3;
+
+    /// <summary>
+    /// Input frame data is stored here.
+    /// </summary>
+    private readonly FjxlFrameInputSource input;
+
+    /// <summary>
+    /// Image width of the input image.
+    /// </summary>
+    private readonly int width;
+
+    /// <summary>
+    /// Image height of the input image.
+    /// </summary>
+    private readonly int height;
+
+    /// <summary>
+    /// Image width in groups.
+    /// </summary>
+    private readonly int numGroupsX;
+
+    /// <summary>
+    /// Image height in groups.
+    /// </summary>
+    private readonly int numGroupsY;
+
+    /// <summary>
+    /// Image width in groups (DC).
+    /// </summary>
+    private readonly int numDcGroupsX;
+
+    /// <summary>
+    /// Image height in groups (DC).
+    /// </summary>
+    private readonly int numDcGroupsY;
+
+    /// <summary>
+    /// Number of channels. (f.e. RGBA is 4, YUV is 3)
+    /// </summary>
+    private readonly int channels;
+
+    /// <summary>
+    /// Number of bits represented per pixel. (f.e. 8 means pixels
+    /// have a 0-255 range)
+    /// </summary>
+    /// <remarks>
+    /// Higher bit depths can represent more colors.
+    /// </remarks>
+    private readonly int bitDepth;
+
+    /// <summary>
+    /// Should the output image be stored in big-endian order?
+    /// </summary>
+    private readonly bool isBigEndian;
+
+    private readonly int effort;
+
+    private readonly bool collided;
+
+    /// <summary>
+    /// Prefix codes for LZ77.
+    /// </summary>
+    private InlineArray4<FjxlPrefixCode> hcode;
+
+    private readonly List<short> lookup = [];
+
+    /// <summary>
+    /// Bit writer to write the JPEG XL headers.
+    /// </summary>
+    private readonly FjxlBitWriter header;
+
+    /// <summary>
+    /// Bit writers for writing JPEG XL groups.
+    /// </summary>
+    private readonly List<InlineArray4<FjxlBitWriter>> groupData = [];
+
+    /// <summary>
+    /// Sizes for each group.
+    /// </summary>
+    private readonly List<int> groupSizes = [];
+
+    private int acGroupDataOffset;
+
+    private int minDcGlobalSize;
+
+    private int currentBitWriter;
+
+    private int bitWriterBytePos;
+
+    private int bitsInBuffer;
+
+    private long bitBuffer;
+
+    private bool processDone;
+
+    /// <summary>
+    /// Abstracts access to a raster frame data required for encoding.
+    /// </summary>
+    internal abstract class FjxlFrameInputSource : IDisposable
+    {
+        /// <inheritdoc />
+        public abstract void Dispose();
+
+        /// <summary>
+        /// Returns a span that wraps over channel color data at the
+        /// specified rectangular position.
+        /// </summary>
+        /// <typeparam name="T">Target type of the color data.</typeparam>
+        /// <param name="x">Left offset</param>
+        /// <param name="y">Right offset</param>
+        /// <param name="width">Selection width</param>
+        /// <param name="height">Selection height</param>
+        /// <param name="rowOffset">The actual offset of the row in row-major order is stored here.</param>
+        /// <returns>
+        /// A wrapper over the color data of the channel at the specified
+        /// position.
+        /// </returns>
+        public abstract Span<T> GetColorChannelData<T>(int x, int y, int width, int height, out long rowOffset)
+            where T : unmanaged;
+    }
+
+    /// <summary>
+    /// Gets minimum raw lengths for prefix coding.
+    /// </summary>
+    public static ReadOnlySpan<byte> MinimumRawLength => [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+    /// <summary>
+    /// Gets maximum raw lengths for prefix coding.
+    /// </summary>
+    public static ReadOnlySpan<byte> MaximumRawLength => [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 10];
+
+    /// <summary>
+    /// Gets a lookup used by the <see cref="TocBucket"/> method
+    /// to translate a bucket into a base group size.
+    /// </summary>
+    private static ReadOnlySpan<int> GroupSizeOffset =>
+    [
+        0,
+        1024,
+        17408,
+        4211712
+    ];
+
+    /// <summary>
+    /// Gets a lookup to determine how many bits a TOC bucket uses.
+    /// </summary>
+    private static ReadOnlySpan<int> TocBits => [12, 16, 24, 32];
+
+    /// <summary>
+    /// Approximates Floor(Log2(v)) using integers.
+    /// </summary>
+    /// <param name="v">Value to retrieve Floor(Log2(v)) of.</param>
+    /// <returns>Floor of second logarithm of v, or 31 if v is equal to 0.</returns>
+    /// <remarks>This method may use CPU intrinsics provided by the .NET Runtime (e.g. BMI1 on x86).</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint FloorLog2(uint v) => v == 0 ? 0 : 31u - (uint)BitOperations.LeadingZeroCount(v);
+
+    /// <summary>
+    /// Approximates count trailing zeros of v using integers.
+    /// </summary>
+    /// <param name="v">Value to retrieve number of 0 bits after last 1 bit of.</param>
+    /// <returns>After the least significant 1 bit, returns the number of 0 bits. E.g. 1000 1000 00 -&gt; 5.</returns>
+    /// <remarks>This method may use CPU intrinsics provided by the .NET Runtime (e.g. BMI1 on x86).</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static uint CtzNonZero(ulong v) => (uint)BitOperations.TrailingZeroCount(v);
+
+    /// <summary>
+    /// Returns a TOC bucket based on the group size.
+    /// </summary>
+    /// <param name="groupSize">Specified group size.</param>
+    /// <returns>TOC bucket matching the appropriate group size.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int TocBucket(int groupSize)
+    {
+        int bucket = 0;
+
+        while (bucket < 3 && groupSize >= GroupSizeOffset[bucket + 1])
+        {
+            bucket++;
+        }
+
+        return bucket;
+    }
+
+    /// <summary>
+    /// Returns the total number of bits required to represent
+    /// all given group sizes in the TOC.
+    /// </summary>
+    /// <param name="groupSizes">Group sizes to calculate bit sizes of.</param>
+    /// <returns>Accumulated number of bits required to represent each group size.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int TocSize(Span<int> groupSizes)
+    {
+        int tocBits = 0;
+
+        ref int unsafeRef = ref MemoryMarshal.GetReference(groupSizes);
+
+        for (int i = 0; i < groupSizes.Length; i++)
+        {
+            // TODO: we can try using AVX2 gather intrinsics,
+            // especially because TocBits can absolutely fit
+            // in the L1 cache
+            int groupSize = Unsafe.Add(ref unsafeRef, i);
+            int bucketForGroupSize = TocBucket(groupSize);
+            int bitsUsedByBucket = TocBits[bucketForGroupSize];
+
+            tocBits += bitsUsedByBucket;
+        }
+
+        return tocBits;
+    }
+
+    /// <summary>
+    /// Returns the number of bytes for the frame header.
+    /// </summary>
+    /// <param name="containsAlpha">Indicates presence of the alpha channel.</param>
+    /// <param name="isLast">Indicates whether this is the final frame.</param>
+    /// <returns>Frame header size in bytes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int FrameHeaderSize(bool containsAlpha, bool isLast)
+    {
+        // Original code (from libjxl):
+        //
+        //     size_t nbits = 28 + (have_alpha ? 4 : 0) + (is_last ? 0 : 2);
+        //     return (nbits + 7) / 8;
+        //
+        // In this implementation we just use constants to shave a few CPU cycles.
+        // The total amount of branches is reduced by one (for the !containsAlpha case),
+        // but we remove the arithmetic/shifting instructions.
+        unchecked
+        {
+            if (containsAlpha)
+            {
+                if (isLast)
+                {
+                    return 5; // (34 + 7) / 8
+                }
+                else
+                {
+                    return 4; // (32 + 7) / 8
+                }
+            }
+            else
+            {
+                return 4; // (30 + 7) / 8 AND (28 + 7) / 8 yield the same result
+            }
+        }
+    }
+
+    private static long GetSectionSize(InlineArray4<FjxlBitWriter> groupData)
+    {
+        long size = 0;
+
+        for (int j = 0; j < 4; j++)
+        {
+            FjxlBitWriter writer = groupData[j];
+
+            size += (writer.BytesWritten * 8) + writer.BitsInBuffer;
+        }
+
+        return (size + 7) / 8;
+    }
+
+    /// <summary>
+    /// Approximates number of bytes needed for the output image buffer.
+    /// </summary>
+    /// <returns>Bytes for the frame buffer.</returns>
+    private long GetOutputSize()
+    {
+        long totalSizeGroups = 0;
+
+        Span<InlineArray4<FjxlBitWriter>> groups = CollectionsMarshal.AsSpan(this.groupData);
+
+        for (int i = 0; i < groups.Length; i++)
+        {
+            InlineArray4<FjxlBitWriter> section = groups[i];
+
+            totalSizeGroups += GetSectionSize(section);
+        }
+
+        return this.header.BytesWritten + totalSizeGroups;
+    }
+
+    /// <summary>
+    /// Returns the maximum amount of bytes potentially required for the image buffer.
+    /// </summary>
+    /// <returns>Upper bound of bytes for frame buffer.</returns>
+    private long GetMaxRequiredOutput() => this.GetOutputSize() + 32;
+
+    private void WriteHeader(bool addImageHeader, bool isLast)
+    {
+        FjxlBitWriter output = this.header;
+        bool haveAlpha = this.channels is 2 or 4;
+
+        if (addImageHeader)
+        {
+            // File signature. This signature specifies
+            // a raw codestream. No container format here.
+            output.Write(16, 0x0AFF);
+
+            // Handcrafted size header.
+            output.Write(1, 0); // Not small
+
+            WriteSize(this.height);
+            output.Write(3, 0b000); // No special ratio
+            WriteSize(this.width);
+
+            // Handcrafted image metadata
+            output.Write(1, 0); // all_default = 0 (don't assume values to be set to their defaults)
+            output.Write(1, 0); // extra_fields = 0 (extra fields are disabled and therefore not present)
+            output.Write(1, 0); // bit_depth.floating_point_sample = 0 (samples are integers)
+
+            if (this.bitDepth == 8)
+            {
+                output.Write(2, 0b00); // bit_depth.bits_per_sample = 8 (predefined bit depth of 8 bits)
+            }
+            else if (this.bitDepth == 10)
+            {
+                output.Write(2, 0b01); // bit_depth.bits_per_sample = 10 (predefined bit depth of 10 bits)
+            }
+            else if (this.bitDepth == 12)
+            {
+                output.Write(2, 0b10); // bit_depth.bits_per_sample = 12 (predefined bit depth of 12 bits)
+            }
+            else
+            {
+                output.Write(2, 0b11); // Custom bit depth
+                output.Write(6, (ulong)this.bitDepth - 1); // bit depth minus 1 (so 0 becomes 1, 9 becomes 10, etc)
+            }
+
+            if (this.bitDepth <= 14)
+            {
+                output.Write(1, 1); // 16-bit-buffer is sufficient
+            }
+            else
+            {
+                output.Write(1, 0); // 16-bit-buffer is NOT sufficient
+            }
+
+            if (haveAlpha)
+            {
+                output.Write(2, 0b01); // Emit one extra channel (the alpha channel)
+
+                if (this.bitDepth == 8)
+                {
+                    output.Write(1, 1); // all_default = 1 (8-bit alpha is the default)
+                }
+                else
+                {
+                    output.Write(1, 0); // all_default = 0
+                    output.Write(2, 0); // type = alpha
+                    output.Write(1, 0); // samples are not floating point
+
+                    if (this.bitDepth == 10)
+                    {
+                        output.Write(2, 0b01); // bit_depth.bits_per_sample = 10 (predefined bit depth of 10 bits)
+                    }
+                    else if (this.bitDepth == 12)
+                    {
+                        output.Write(2, 0b10); // bit_depth.bits_per_sample = 12 (predefined bit depth of 12 bits)
+                    }
+                    else
+                    {
+                        output.Write(2, 0b11); // Custom bit depth
+                        output.Write(6, (ulong)this.bitDepth - 1); // bit depth minus 1 (so 0 becomes 1, 9 becomes 10, etc)
+                    }
+
+                    output.Write(2, 0); // dim_shift = 0
+                    output.Write(2, 0); // name_len = 0
+                    output.Write(1, 0); // alpha_associated = 0
+                }
+            }
+            else
+            {
+                output.Write(2, 0b00); // 0 extra channels
+            }
+
+            output.Write(1, 0); // not XYB
+
+            if (this.channels > 2)
+            {
+                output.Write(1, 1); // color_encoding.all_default = 1 (sRGB)
+            }
+            else
+            {
+                output.Write(1, 0); // color_encoding.all_default = 0
+                output.Write(1, 0); // color_encoding.want_icc = 0
+                output.Write(2, 0b01); // Grayscale
+                output.Write(2, 0b01); // D65
+                output.Write(1, 0); // No gamma transfer function
+                output.Write(2, 0b10); // transfer function: 2 + u(4)
+                output.Write(4, 11); // transfer function (specifies sRGB)
+                output.Write(2, 1); // relative rendering intent
+            }
+
+            output.Write(2, 0b00); // No extensions
+            output.Write(1, 1); // all_default transform data
+            output.ZeroPadToByte(); // No ICC and no preview. Frame should start at byte boundary.
+        }
+
+        // Handcrafted frame header
+        output.Write(1, 0); // all_default = 0 (non-default values)
+        output.Write(2, 0b00); // regular frame
+        output.Write(1, 1); // modular
+        output.Write(2, 0b00); // default flags
+        output.Write(1, 0); // not Y'Cb'Cr
+        output.Write(2, 0b00); // no upsampling
+
+        if (haveAlpha)
+        {
+            output.Write(2, 0b00); // no alpha upsampling
+        }
+
+        output.Write(2, 0b01); // default group size
+        output.Write(2, 0b00); // exactly one pass
+        output.Write(1, 0); // no custom size or origin
+        output.Write(2, 0b00); // Replace blending mode
+
+        if (haveAlpha)
+        {
+            output.Write(2, 0b00); // Replace blending mode for alpha channel
+        }
+
+        output.Write(2, 0b00); // a frame has no name
+        output.Write(1, 0); // loop filter is not all_default
+        output.Write(1, 0); // no Gaborish transform
+        output.Write(2, 0b00); // 0 EPF filters
+        output.Write(2, 0b00); // no LF extensions
+        output.Write(2, 0b00); // no FH extensions
+
+        output.Write(1, 0); // no TOC permutation
+        output.ZeroPadToByte(); // TOC is byte aligned
+
+        Span<int> groupSizes = CollectionsMarshal.AsSpan(this.groupSizes);
+
+        for (int i = 0; i < groupSizes.Length; i++)
+        {
+            int groupSize = groupSizes[i];
+
+            int bucket = TocBucket(groupSize);
+            output.Write(2, (ulong)bucket);
+            output.Write(TocBits[bucket] - 2, (ulong)(groupSize - GroupSizeOffset[bucket]));
+        }
+
+        output.ZeroPadToByte(); // Groups are byte-aligned
+
+        // Sizes are coded using a special variable-length
+        // kind of coding. This method does that here.
+        //
+        // It has a prefix of 2 bits, followed by the suffix of N
+        // bits which depend on the prefix:
+        //
+        //    prefix 0b00: 9 consecutive bits
+        //    prefix 0b01: 13 consecutive bits
+        //    prefix 0b10: 18 consecutive bits
+        //    prefix 0b11: 30 consecutive bits
+        void WriteSize(int size)
+        {
+            ulong sizeMinus1 = (ulong)size - 1uL;
+
+            if (sizeMinus1 < (1 << 9))
+            {
+                output.Write(2, 0b00); // 9 bits
+                output.Write(9, sizeMinus1);
+            }
+            else if (sizeMinus1 < (1 << 13))
+            {
+                output.Write(2, 0b01); // 13 bits
+                output.Write(13, sizeMinus1);
+            }
+            else if (sizeMinus1 < (1 << 18))
+            {
+                output.Write(2, 0b10); // 18 bits
+                output.Write(18, sizeMinus1);
+            }
+            else
+            {
+                output.Write(2, 0b11); // 30 bits
+                output.Write(30, sizeMinus1);
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int ComputeDcGlobalPadding(Span<int> groupSizes, int acGroupDataOffset, int minDcGlobalSize, bool containsAlpha, bool isLast)
+    {
+        // Libjxl reference implements this method like this:
+        /*
+         size_t ComputeDcGlobalPadding(const std::vector<size_t>& group_sizes,
+                              size_t ac_group_data_offset,
+                              size_t min_dc_global_size, bool have_alpha,
+                              bool is_last) {
+              std::vector<size_t> new_group_sizes = group_sizes;
+              new_group_sizes[0] = min_dc_global_size;
+              size_t toc_size = TOCSize(new_group_sizes);
+              size_t actual_offset =
+                  FrameHeaderSize(have_alpha, is_last) + toc_size + group_sizes[0];
+              return ac_group_data_offset - actual_offset;
+         }
+         */
+        // The reference implementation copies the entire vector so that
+        // element 0 can be modified without affecting the original.
+        // Since TocSize() does not throw, temporarily modify element 0
+        // instead, avoiding the allocation and copy.
+        int firstItem = groupSizes[0];
+        groupSizes[0] = minDcGlobalSize;
+        int tocSize = TocSize(groupSizes);
+        int actualOffset = FrameHeaderSize(containsAlpha, isLast) + tocSize + firstItem;
+        groupSizes[0] = firstItem;
+        return acGroupDataOffset - actualOffset;
+    }
+
+    private static int PredictPixels<T>(Span<T> pixels, Span<T> pixelsLeft, Span<T> pixelsTop, Span<T> pixelsTopleft, Span<T> residuals, T negativeOne)
+        where T : unmanaged
+    {
+        Vector<T> px = Vector.Create<T>(pixels);
+        Vector<T> left = Vector.Create<T>(pixelsLeft);
+        Vector<T> top = Vector.Create<T>(pixelsTop);
+        Vector<T> topleft = Vector.Create<T>(pixelsTopleft);
+
+        Vector<T> ac = left - topleft;
+        Vector<T> ab = left - top;
+        Vector<T> bc = top - topleft;
+        Vector<T> grad = ac + top;
+        Vector<T> d = ab ^ bc;
+        Vector<T> zero = Vector<T>.Zero;
+        Vector<T> clamp = Vector.ConditionalSelect(Vector.GreaterThan(zero, d), top, left);
+        Vector<T> s = ac ^ bc;
+        Vector<T> pred = Vector.ConditionalSelect(Vector.GreaterThan(zero, s), grad, clamp);
+
+        Vector<T> res = px - pred;
+        Vector<T> resTimes2 = res + res;
+        res = Vector.ConditionalSelect(Vector.GreaterThan(zero, res), Vector.Create(negativeOne) - resTimes2, resTimes2);
+        res.CopyTo(residuals);
+
+        return FjxlSimdUtils.CountPrefix(Vector.Equals(res, zero));
+    }
+
+    private static void EncodeHybridUint000(uint value, out uint token, out uint nbits, out uint bits)
+    {
+        if (value == 0)
+        {
+            token = 0;
+            nbits = 0;
+            bits = 0;
+            return;
+        }
+
+        uint n = FloorLog2(value);
+        token = n + 1;
+        nbits = n;
+        bits = value - (1u << (int)n);
+    }
+
+    private static void GenericEncodeChunk(ReadOnlySpan<uint> residuals, int n, int skip, FjxlPrefixCode code, ref FjxlBitWriter output)
+    {
+        for (int ix = skip; ix < n; ix++)
+        {
+            EncodeHybridUint000(residuals[ix], out uint token, out uint nbits, out uint bits);
+            output.Write((int)(code.RawLengths[(int)token] + nbits), code.RawCodes[(int)token] | (bits << code.RawLengths[(int)token]));
+        }
+    }
+
+    /// <summary>
+    /// Pair of two vectors.
+    /// </summary>
+    /// <typeparam name="T">Type of the vector.</typeparam>
+    /// <param name="lo">Low vector</param>
+    /// <param name="hi">High vector</param>
+    private struct VectorPair<T>(T lo, T hi)
+        where T : unmanaged
+    {
+        public T Low = lo;
+        public T High = hi;
+    }
+
+    internal static class SimdVector32
+    {
+        public static Vector<int> ValueToToken(Vector<int> vec) => Vector.Create(32) - SimdUtils.Lzcnt(vec);
+
+        public static Vector<int> SaturateSubtract(Vector<int> a, Vector<int> b) => Vector.Max(a, b) - b;
+
+        public static Vector<int> Pow2(Vector<int> x) => SimdUtils.Pow2(x);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderExactly14Bits.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderExactly14Bits.cs
new file mode 100644
index 0000000000..4d7eff4a13
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderExactly14Bits.cs
@@ -0,0 +1,61 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd.ChunkEncoders;
+
+internal readonly struct FjxlChunkEncoderExactly14Bits
+{
+    public const int BitDepth = 14;
+    public const int InputBytes = 2;
+
+    public static ReadOnlySpan<byte> MinRawLength =>
+    [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 7
+    ];
+
+    public static ReadOnlySpan<byte> MaxRawLength =>
+    [
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 10
+    ];
+
+    public static int MaxEncodedBitsPerSample() => 23;
+
+    public static void PrepareForSimd(ReadOnlySpan<byte> nbits, ReadOnlySpan<byte> bits, Span<byte> nbitsSimd, Span<byte> bitsSimd)
+    {
+        CheckHuffmanBitsSimd(bits[15], nbits[15], bits[16], nbits[16]);
+
+        nbits[..16].CopyTo(nbitsSimd);
+        bits[..16].CopyTo(bitsSimd);
+    }
+
+    public static void EncodeChunkSimd(Span<ushort> residuals, int n, int skip, ReadOnlySpan<byte> rawNBitsSimd, ReadOnlySpan<byte> rawBitsSimd, ref FjxlBitWriter output)
+    {
+        Span<FjxlBits32> bits32 = stackalloc FjxlBits32[2 * ChunkSize / FjxlSimdVec16.Lanes];
+        Span<ushort> bits = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> nbits = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> bitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> nbitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> token = stackalloc ushort[FjxlSimdVec16.Lanes];
+
+        for (int i = 0; i < ChunkSize; i += FjxlSimdVec16.Lanes)
+        {
+            TokenizeSimd(residuals[i..], token, nbits, bits);
+            HuffmanSimd14(token, rawNBitsSimd, rawBitsSimd, nbitsHuff, bitsHuff);
+
+            StoreSimdUpTo14(
+                nbits,
+                bits,
+                nbitsHuff,
+                bitsHuff,
+                Math.Max(n, i) - i,
+                Math.Max(skip, i) - i,
+                bits32[(2 * i / FjxlSimdVec16.Lanes)..]);
+        }
+
+        StoreToWriter<FjxlBits32, 2 * ChunkSize / FjxlSimdVec16.Lanes>(bits32, ref output);
+    }
+
+    public static int NumSymbols() => 17;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderFrom9To13Bits.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderFrom9To13Bits.cs
new file mode 100644
index 0000000000..7d8b3dc218
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderFrom9To13Bits.cs
@@ -0,0 +1,70 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd.ChunkEncoders;
+
+internal readonly struct FjxlChunkEncoderFrom9To13Bits
+{
+    public const int InputBytes = 2;
+
+    private readonly int bitDepth;
+
+    public FjxlChunkEncoderFrom9To13Bits(int bitDepth)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(bitDepth, 13, nameof(bitDepth));
+        DebugGuard.MustBeGreaterThanOrEqualTo(bitDepth, 9, nameof(bitDepth));
+
+        this.bitDepth = bitDepth;
+    }
+
+    public static ReadOnlySpan<byte> MinRawLength =>
+    [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    ];
+
+    public static ReadOnlySpan<byte> MaxRawLength =>
+    [
+        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 10
+    ];
+
+    public static int MaxEncodedBitsPerSample() => 22;
+
+    public static void PrepareForSimd(ReadOnlySpan<byte> nbits, ReadOnlySpan<byte> bits, int n, Span<byte> nbitsSimd, Span<byte> bitsSimd)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(n, 16, nameof(n));
+
+        nbits[..16].CopyTo(nbitsSimd);
+        bits[..16].CopyTo(bitsSimd);
+    }
+
+    public static void EncodeChunkSimd(Span<ushort> residuals, int n, int skip, ReadOnlySpan<byte> rawNBitsSimd, ReadOnlySpan<byte> rawBitsSimd, ref FjxlBitWriter output)
+    {
+        Span<FjxlBits32> bits32 = stackalloc FjxlBits32[2 * ChunkSize / FjxlSimdVec16.Lanes];
+        Span<ushort> bits = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> nbits = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> bitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> nbitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> token = stackalloc ushort[FjxlSimdVec16.Lanes];
+
+        for (int i = 0; i < ChunkSize; i += FjxlSimdVec16.Lanes)
+        {
+            TokenizeSimd(residuals[i..], token, nbits, bits);
+            HuffmanSimdUpTo13(token, rawNBitsSimd, rawBitsSimd, nbitsHuff, bitsHuff);
+
+            StoreSimdUpTo14(
+                nbits,
+                bits,
+                nbitsHuff,
+                bitsHuff,
+                Math.Max(n, i) - i,
+                Math.Max(skip, i) - i,
+                bits32[(2 * i / FjxlSimdVec16.Lanes)..]);
+        }
+
+        StoreToWriter<FjxlBits32, 2 * ChunkSize / FjxlSimdVec16.Lanes>(bits32, ref output);
+    }
+
+    public int NumSymbols(bool doingYcocgOrLargePalette) => this.bitDepth + (doingYcocgOrLargePalette ? 3 : 2);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderMoreThan14Bits.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderMoreThan14Bits.cs
new file mode 100644
index 0000000000..dfef97f74c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderMoreThan14Bits.cs
@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd.ChunkEncoders;
+
+internal readonly struct FjxlChunkEncoderMoreThan14Bits
+{
+    public const int InputBytes = 2;
+
+    private readonly int bitDepth;
+
+    public FjxlChunkEncoderMoreThan14Bits(int bitDepth)
+    {
+        DebugGuard.MustBeGreaterThan(bitDepth, 14, nameof(bitDepth));
+        DebugGuard.MustBeLessThanOrEqualTo(bitDepth, 16, nameof(bitDepth));
+
+        this.bitDepth = bitDepth;
+    }
+
+    public static ReadOnlySpan<byte> MinRawLength =>
+    [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 8, 8, 8, 8, 8, 8, 7
+    ];
+
+    public static ReadOnlySpan<byte> MaxRawLength =>
+    [
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 8, 8, 8, 8, 8, 8, 10
+    ];
+
+    public static int MaxEncodedBitsPerSample() => 25;
+
+    public static void PrepareForSimd(ReadOnlySpan<byte> nbits, ReadOnlySpan<byte> bits, Span<byte> nbitsSimd, Span<byte> bitsSimd)
+    {
+        CheckHuffmanBitsSimd(bits[13], nbits[13], bits[14], nbits[14]);
+        CheckHuffmanBitsSimd(bits[15], nbits[15], bits[16], nbits[16]);
+        CheckHuffmanBitsSimd(bits[17], nbits[17], bits[18], nbits[18]);
+
+        nbits[..14].CopyTo(nbitsSimd);
+        bits[..14].CopyTo(bitsSimd);
+
+        nbitsSimd[14] = nbits[15];
+        bitsSimd[14] = bits[15];
+        nbitsSimd[15] = nbits[17];
+        bitsSimd[15] = bits[17];
+    }
+
+    public static void EncodeChunkSimd(Span<uint> residuals, int n, int skip, ReadOnlySpan<byte> rawNBitsSimd, ReadOnlySpan<byte> rawBitsSimd, ref FjxlBitWriter output)
+    {
+        Span<FjxlBits32> bits32 = stackalloc FjxlBits32[2 * ChunkSize / FjxlSimdVec16.Lanes];
+        Span<uint> bits = stackalloc uint[FjxlSimdVec16.Lanes];
+        Span<uint> nbits = stackalloc uint[FjxlSimdVec16.Lanes];
+        Span<ushort> bitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> nbitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> token = stackalloc ushort[FjxlSimdVec16.Lanes];
+
+        for (int i = 0; i < ChunkSize; i += FjxlSimdVec16.Lanes)
+        {
+            TokenizeSimd(residuals[i..], token, nbits, bits);
+            HuffmanSimdAbove14(token, rawNBitsSimd, rawBitsSimd, nbitsHuff, bitsHuff);
+
+            StoreSimdAbove14(
+                nbits,
+                bits,
+                nbitsHuff,
+                bitsHuff,
+                Math.Max(n, i) - i,
+                Math.Max(skip, i) - i,
+                bits32[(2 * i / FjxlSimdVec16.Lanes)..]);
+        }
+
+        StoreToWriter<FjxlBits32, 2 * ChunkSize / FjxlSimdVec16.Lanes>(bits32, ref output);
+    }
+
+    public static int NumSymbols() => 19;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderUpTo8Bits.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderUpTo8Bits.cs
new file mode 100644
index 0000000000..eee2aa401e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/ChunkEncoders/FjxlChunkEncoderUpTo8Bits.cs
@@ -0,0 +1,67 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd.ChunkEncoders;
+
+internal readonly struct FjxlChunkEncoderUpTo8Bits
+{
+    public const int InputBytes = 1;
+
+    private readonly int bitDepth;
+
+    public FjxlChunkEncoderUpTo8Bits(int bitDepth)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(bitDepth, 8, nameof(bitDepth));
+
+        this.bitDepth = bitDepth;
+    }
+
+    public static ReadOnlySpan<byte> MinRawLength =>
+    [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    ];
+
+    public static ReadOnlySpan<byte> MaxRawLength =>
+    [
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 10
+    ];
+
+    public static int MaxEncodedBitsPerSample() => 16;
+
+    public static void PrepareForSimd(ReadOnlySpan<byte> nbits, ReadOnlySpan<byte> bits, int n, Span<byte> nbitsSimd, Span<byte> bitsSimd)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(n, 16, nameof(n));
+
+        nbits[..16].CopyTo(nbitsSimd);
+        bits[..16].CopyTo(bitsSimd);
+    }
+
+    public static void EncodeChunkSimd(Span<ushort> residuals, int n, int skip, ReadOnlySpan<byte> rawNBitsSimd, ReadOnlySpan<byte> rawBitsSimd, ref FjxlBitWriter output)
+    {
+        Span<FjxlBits32> bits32 = stackalloc FjxlBits32[ChunkSize / FjxlSimdVec16.Lanes];
+        Span<ushort> bits = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> nbits = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> bitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> nbitsHuff = stackalloc ushort[FjxlSimdVec16.Lanes];
+        Span<ushort> token = stackalloc ushort[FjxlSimdVec16.Lanes];
+
+        for (int i = 0; i < ChunkSize; i += FjxlSimdVec16.Lanes)
+        {
+            TokenizeSimd(residuals[i..], token, nbits, bits);
+            HuffmanSimdUpTo13(token, rawNBitsSimd, rawBitsSimd, nbitsHuff, bitsHuff);
+
+            StoreSimdUpTo8(
+                nbits,
+                bits,
+                nbitsHuff,
+                bitsHuff,
+                Math.Max(n, i) - i,
+                Math.Max(skip, i) - i,
+                bits32[(int)(i / FjxlSimdVec16.Lanes)..]);
+        }
+
+        StoreToWriter<FjxlBits32, ChunkSize / FjxlSimdVec16.Lanes>(bits32, ref output);
+    }
+
+    public int NumSymbols(bool doingYcocgOrLargePalette) => this.bitDepth + (doingYcocgOrLargePalette ? 3 : 2);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlHuffman.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlHuffman.cs
new file mode 100644
index 0000000000..13c702f73f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlHuffman.cs
@@ -0,0 +1,66 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd;
+
+internal static class FjxlHuffman
+{
+    public static void HuffmanSimdUpTo13(Span<short> tokens, ReadOnlySpan<byte> rawNbitsSimd, ReadOnlySpan<byte> rawBitsSimd, Span<short> nbitsOut, Span<short> bitsOut)
+    {
+        Vector<short> tok = FjxlSimdUtils.PrepareForU8Lookup(Vector.Create<short>(tokens));
+
+        FjxlSimdUtils.U8Lookup(tok, rawNbitsSimd).CopyTo(nbitsOut);
+        FjxlSimdUtils.U8Lookup(tok, rawBitsSimd).CopyTo(bitsOut);
+    }
+
+    public static void HuffmanSimd14(Span<short> tokens, ReadOnlySpan<byte> rawNbitsSimd, ReadOnlySpan<byte> rawBitsSimd, Span<short> nbitsOut, Span<short> bitsOut)
+    {
+        Vector<short> tokenCap = Vector.Create((short)15);
+        Vector<short> tok = Vector.Create<short>(tokens);
+
+        Vector<short> tokIndex = FjxlSimdUtils.PrepareForU8Lookup(Vector.Min(tok, tokenCap));
+
+        Vector<short> huffBitsPre = FjxlSimdUtils.U8Lookup(tokIndex, rawBitsSimd);
+
+        Vector<short> needsHighBit = Vector.Equals(tok, Vector.Create((short)16));
+
+        Vector<short> huffBits = Vector.ConditionalSelect(
+            needsHighBit,
+            huffBitsPre | Vector.Create((short)128),
+            huffBitsPre);
+
+        huffBits.CopyTo(bitsOut);
+
+        FjxlSimdUtils.U8Lookup(tokIndex, rawNbitsSimd)
+            .CopyTo(nbitsOut);
+    }
+
+    public static void HuffmanSimdAbove14(Span<short> tokens, ReadOnlySpan<byte> rawNbitsSimd, ReadOnlySpan<byte> rawBitsSimd, Span<short> nbitsOut, Span<short> bitsOut)
+    {
+        Vector<short> tok = Vector.Create<short>(tokens);
+        Vector<short> above = Vector.GreaterThan(tok, Vector.Create((short)12));
+
+        Vector<short> remapTok = Vector.ConditionalSelect(
+            above,
+            FjxlSimdUtils.HorizontalAdd(tok, Vector.Create((short)13)),
+            tok);
+
+        Vector<short> tokIndex = FjxlSimdUtils.PrepareForU8Lookup(remapTok);
+        Vector<short> huffBitsPre = FjxlSimdUtils.U8Lookup(tokIndex, rawBitsSimd);
+
+        Vector<short> evenTok = tok & Vector.Create(unchecked((short)0xFFF));
+        Vector<short> needsHighBit = above & Vector.Equals(tok, evenTok);
+
+        Vector<short> huffBits = Vector.ConditionalSelect(
+            needsHighBit,
+            huffBitsPre | Vector.Create((short)128),
+            huffBitsPre);
+
+        huffBits.CopyTo(bitsOut);
+
+        FjxlSimdUtils.U8Lookup(tokIndex, rawNbitsSimd)
+            .CopyTo(nbitsOut);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlSimdUtils.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlSimdUtils.cs
new file mode 100644
index 0000000000..6cdaf7f57b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlSimdUtils.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd;
+
+/// <summary>
+/// SIMD utilities highly specific to the Fast Lossless JXL encoder.
+/// </summary>
+internal static class FjxlSimdUtils
+{
+    public static Vector<short> HorizontalAdd(this Vector<short> a, Vector<short> b) => (a + b) >> 1;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlStoreSimd.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlStoreSimd.cs
new file mode 100644
index 0000000000..03f78a92d8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlStoreSimd.cs
@@ -0,0 +1,101 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd;
+
+internal static class FjxlStoreSimd
+{
+    public static void StoreSimdUpTo8(Span<short> nbitsTok, Span<short> bitsTok, Span<short> nbitsHuff, Span<short> bitsHuff, int n, int skip, Span<Bits32> bitsOut)
+    {
+        FjxlBits16 bits = FjxlBits16.FromRaw(
+            Vector.Create<short>(nbitsTok),
+            Vector.Create<short>(bitsTok));
+
+        FjxlBits16 huffBits = FjxlBits16.FromRaw(
+            Vector.Create<short>(nbitsHuff),
+            Vector.Create<short>(bitsHuff));
+
+        bits.Interleave(huffBits);
+        bits.ClipTo(n);
+        bits.Skip(skip);
+
+        bitsOut[0] = bits.Merge();
+    }
+
+    public static void StoreSimdUpTo14(Span<short> nbitsTok, Span<short> bitsTok, Span<short> nbitsHuff, Span<short> bitsHuff, int n, int skip, Span<Bits32> bitsOut)
+    {
+        VecPair<Vector<short>> bits = Vector.Create<short>(bitsTok).Interleave(Vector.Create<short>(bitsHuff));
+        VecPair<Vector<short>> nbits = Vector.Create<short>(nbitsTok).Interleave(Vector.Create<short>(nbitsHuff));
+
+        Bits16 low = Bits16.FromRaw(nbits.Low, bits.Low);
+        Bits16 hi = Bits16.FromRaw(nbits.High, bits.High);
+
+        int lanes = Vector<short>.Count;
+
+        low.ClipTo(2 * n);
+        low.Skip(2 * skip);
+
+        hi.ClipTo(Math.Max(2 * n, lanes) - lanes);
+        hi.Skip(Math.Max(2 * skip, lanes) - lanes);
+
+        bitsOut[0] = low.Merge();
+        bitsOut[1] = hi.Merge();
+    }
+
+    public static void StoreSimdAbove14(Span<int> nbitsTok, Span<int> bitsTok, Span<short> nbitsHuff, Span<short> bitsHuff, int n, int skip, Span<Bits32> bitsOut)
+    {
+        Vector<int> nbitsTokLo = Vector.Create<int>(nbitsTok);
+        Vector<int> bitsTokLo = Vector.Create<int>(bitsTok);
+
+        Vector<int> nbitsTokHi = Vector.Create<int>(nbitsTok[Vector<int>.Count..]);
+        Vector<int> bitsTokHi = Vector.Create<int>(bitsTok[Vector<int>.Count..]);
+
+        Bits32 bitsLow = Bits32.FromRaw(nbitsTokLo, bitsTokLo);
+        Bits32 bitsHi = Bits32.FromRaw(nbitsTokHi, bitsTokHi);
+
+        VecPair<Vector<int>> huffBits = FjxlSimdUtils.Upcast(Vector.Create<short>(bitsHuff));
+        VecPair<Vector<int>> huffNbits = FjxlSimdUtils.Upcast(Vector.Create<short>(nbitsHuff));
+
+        Bits32 huffLow = Bits32.FromRaw(huffNbits.Low, huffBits.Low);
+        Bits32 huffHi = Bits32.FromRaw(huffNbits.High, huffBits.High);
+
+        bitsLow.Interleave(huffLow);
+        bitsLow.ClipTo(n);
+        bitsLow.Skip(skip);
+        bitsOut[0] = bitsLow;
+
+        int lanes = Vector<int>.Count;
+
+        bitsHi.Interleave(huffHi);
+        bitsHi.ClipTo(Math.Max(n, lanes) - lanes);
+        bitsHi.Skip(Math.Max(skip, lanes) - lanes);
+        bitsOut[1] = bitsHi;
+    }
+
+    public static void StoreToWriter(ReadOnlySpan<Bits32> bits, FjxlBitWriter output, int n)
+    {
+        Span<ulong> nbits64 = stackalloc ulong[Bits64.Lanes * n];
+        Span<ulong> bits64 = stackalloc ulong[Bits64.Lanes * n];
+
+        bits[0].Merge().Store(nbits64, bits64);
+
+        if (n > 1)
+        {
+            bits[1].Merge().Store(nbits64[Bits64.Lanes..], bits64[Bits64.Lanes..]);
+        }
+
+        if (n > 2)
+        {
+            bits[2].Merge().Store(nbits64[(2 * Bits64.Lanes)..], bits64[(2 * Bits64.Lanes)..]);
+        }
+
+        if (n > 3)
+        {
+            bits[3].Merge().Store(nbits64[(3 * Bits64.Lanes)..], bits64[(3 * Bits64.Lanes)..]);
+        }
+
+        output.WriteMultiple(nbits64, bits64, Bits64.Lanes * n);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlTokenization.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlTokenization.cs
new file mode 100644
index 0000000000..aed8a20576
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/FastLossless/Simd/FjxlTokenization.cs
@@ -0,0 +1,45 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.FastLossless.Simd;
+
+internal static class FjxlTokenization
+{
+    public static void Tokenize16(Span<short> residuals, Span<short> output, Span<short> nbitsOut, Span<short> bitsOut)
+    {
+        Vector<short> res = Vector.Create<short>(residuals);
+        Vector<short> token = FjxlSimdUtils.ValueToToken(res);
+        Vector<short> nbits = FjxlSimdUtils.SaturateSubtract(token, Vector<short>.One);
+        Vector<short> bits = FjxlSimdUtils.SaturateSubtract(res, FjxlSimdUtils.Pow2(nbits));
+
+        token.CopyTo(output);
+        nbits.CopyTo(nbitsOut);
+        bits.CopyTo(bitsOut);
+    }
+
+    public static void Tokenize32(Span<int> residuals, Span<short> tokenOut, Span<int> nbitsOut, Span<int> bitsOut)
+    {
+        Vector<int> resLo = Vector.Create<int>(residuals);
+        Vector<int> resHi = Vector.Create<int>(residuals[Vector<int>.Count..]);
+
+        Vector<int> tokenLo = FjxlSimdUtils.ValueToToken(resLo);
+        Vector<int> tokenHi = FjxlSimdUtils.ValueToToken(resHi);
+
+        Vector<int> nbitsLo = FjxlSimdUtils.SaturateSubtract(tokenLo, Vector<int>.One);
+        Vector<int> nbitsHi = FjxlSimdUtils.SaturateSubtract(tokenHi, Vector<int>.One);
+
+        Vector<int> bitsLo = FjxlSimdUtils.SaturateSubtract(resLo, FjxlSimdUtils.Pow2(nbitsLo));
+        Vector<int> bitsHi = FjxlSimdUtils.SaturateSubtract(resHi, FjxlSimdUtils.Pow2(nbitsHi));
+
+        Vector<short> token = FjxlSimdUtils.FromTwo32(tokenLo, tokenHi);
+        token.CopyTo(tokenOut);
+
+        nbitsLo.CopyTo(nbitsOut);
+        nbitsHi.CopyTo(nbitsOut[Vector<int>.Count..]);
+
+        bitsLo.CopyTo(bitsOut);
+        bitsHi.CopyTo(bitsOut[Vector<int>.Count..]);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Huffman/JxlHuffmanEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Huffman/JxlHuffmanEncoder.cs
new file mode 100644
index 0000000000..7caf854655
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Huffman/JxlHuffmanEncoder.cs
@@ -0,0 +1,226 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Huffman;
+
+/// <summary>
+/// Derives &amp; writes Huffman codes.
+/// </summary>
+internal static class JxlHuffmanEncoder
+{
+    private const int CodeLengthCodes = 18;
+
+    private static ReadOnlySpan<byte> StorageOrder => [1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+
+    private static ReadOnlySpan<byte> HuffmanBitLengthHuffmanCodeSymbols => [0, 7, 3, 2, 1, 15];
+
+    private static ReadOnlySpan<byte> HuffmanBitLengthHuffmanCodeBitLengths => [2, 4, 3, 2, 2, 4];
+
+    public static void StoreHuffmanTreeOfHuffmanTreeToBitMask(int numCodes, Span<byte> codeLengthBitDepth, JxlBitWriter writer)
+    {
+        int codesToStore = CodeLengthCodes;
+        if (numCodes > 1)
+        {
+            for (; codesToStore > 0; codesToStore--)
+            {
+                if (codeLengthBitDepth[StorageOrder[codesToStore - 1]] != 0)
+                {
+                    break;
+                }
+            }
+        }
+
+        int skipSome = 0;
+        if (codeLengthBitDepth[StorageOrder[0]] == 0 && codeLengthBitDepth[StorageOrder[1]] == 0)
+        {
+            skipSome = 2; // skips two
+            if (codeLengthBitDepth[StorageOrder[2]] == 0)
+            {
+                skipSome = 3; // skips three
+            }
+        }
+
+        writer.Write(2, skipSome);
+
+        for (int i = skipSome; i < codesToStore; ++i)
+        {
+            int l = codeLengthBitDepth[StorageOrder[i]];
+            writer.Write(HuffmanBitLengthHuffmanCodeBitLengths[l], HuffmanBitLengthHuffmanCodeSymbols[l]);
+        }
+    }
+
+    public static void StoreHuffmanTreeToBitMask(int huffmanTreeSize, Span<byte> huffmanTree, Span<byte> huffmanTreeExtraBits, Span<byte> codeLengthBitDepth, Span<ushort> codeLengthBitDepthSymbols, JxlBitWriter writer)
+    {
+        for (int i = 0; i < huffmanTreeSize; ++i)
+        {
+            int ix = huffmanTree[i];
+            writer.Write(codeLengthBitDepth[ix], codeLengthBitDepthSymbols[ix]);
+            DebugGuard.MustBeLessThan(ix, 17, nameof(ix));
+
+            // Extra bits
+            //
+            // Micro optimization:
+            // Original:
+            //   switch (ix)
+            //   {
+            //      case 16:
+            //          writer->Write(2, huffman_tree_extra_bits[i]);
+            //          break;
+            //      case 17:
+            //          writer->Write(3, huffman_tree_extra_bits[i]);
+            //          break;
+            //      default:
+            //          // no-op
+            //          break;
+            //   }
+            if ((ix & 16) != 0)
+            {
+                writer.Write(2 + (ix & 1), huffmanTreeExtraBits[i]);
+            }
+        }
+    }
+
+    public static void StoreSimpleHuffmanTree(Span<byte> depths, InlineArray4<int> symbols, int numSymbols, int maxBits, JxlBitWriter writer)
+    {
+        writer.Write(2, 1);
+        writer.Write(2, numSymbols - 1);
+
+        for (int i = 0; i < numSymbols; i++)
+        {
+            for (int j = i + 1; j < numSymbols; j++)
+            {
+                if (depths[symbols[j]] < depths[symbols[i]])
+                {
+                    RuntimeUtility.Swap(ref symbols[j], ref symbols[i]);
+                }
+            }
+        }
+
+        if (numSymbols == 2)
+        {
+            writer.Write(maxBits, symbols[0]);
+            writer.Write(maxBits, symbols[1]);
+        }
+        else if (numSymbols == 3)
+        {
+            writer.Write(maxBits, symbols[0]);
+            writer.Write(maxBits, symbols[1]);
+            writer.Write(maxBits, symbols[2]);
+        }
+        else
+        {
+            writer.Write(maxBits, symbols[0]);
+            writer.Write(maxBits, symbols[1]);
+            writer.Write(maxBits, symbols[2]);
+            writer.Write(maxBits, symbols[3]);
+            writer.Write(1, depths[symbols[0]] == 1 ? 1 : 0);
+        }
+    }
+
+    public static void StoreHuffmanTree(Span<byte> depths, int num, JxlBitWriter writer)
+    {
+        Span<byte> arena = stackalloc byte[2 * num];
+        Span<byte> huffmanTree = arena;
+        Span<byte> huffmanTreeExtraBits = arena[num..];
+        int huffmanTreeSize = 0;
+        JxlHuffmanTree.WriteHuffmanTree(depths, num, ref huffmanTreeSize, huffmanTree, huffmanTreeExtraBits);
+
+        Span<int> huffmanTreeHistogram = stackalloc int[CodeLengthCodes];
+        huffmanTreeHistogram.Clear();
+
+        for (int i = 0; i < huffmanTreeSize; ++i)
+        {
+            huffmanTreeHistogram[huffmanTree[i]]++;
+        }
+
+        int numCodes = 0;
+        int code = 0;
+
+        for (int i = 0; i < CodeLengthCodes; ++i)
+        {
+            if (huffmanTreeHistogram[i] != 0)
+            {
+                if (numCodes == 0)
+                {
+                    code = i;
+                    numCodes = 1;
+                }
+                else if (numCodes == 1)
+                {
+                    numCodes = 2;
+                    break;
+                }
+            }
+        }
+
+        Span<byte> codeLengthBitDepth = stackalloc byte[CodeLengthCodes];
+        Span<short> codeLengthBitDepthSymbols = stackalloc short[CodeLengthCodes];
+        codeLengthBitDepth.Clear();
+        codeLengthBitDepthSymbols.Clear();
+
+        JxlHuffmanTree.CreateHuffmanTree(huffmanTreeHistogram, CodeLengthCodes, 5, codeLengthBitDepth);
+        JxlHuffmanTree.ConvertBitDepthsToSymbols(codeLengthBitDepth, CodeLengthCodes, codeLengthBitDepthSymbols);
+
+        StoreHuffmanTreeOfHuffmanTreeToBitMask(numCodes, codeLengthBitDepth, writer);
+
+        if (numCodes == 1)
+        {
+            codeLengthBitDepth[code] = 0;
+        }
+
+        StoreHuffmanTreeToBitMask(huffmanTreeSize, huffmanTree, huffmanTreeExtraBits, codeLengthBitDepth, codeLengthBitDepthSymbols, writer);
+    }
+
+    public static void BuildAndStoreHuffmanTree(Span<int> histogram, int length, Span<byte> depth, Span<short> bits, JxlBitWriter writer)
+    {
+        int count = 0;
+        InlineArray4<int> s4 = default;
+
+        for (int i = 0; i < length; i++)
+        {
+            if (histogram[i] != 0)
+            {
+                if (count < 4)
+                {
+                    s4[count] = i;
+                }
+                else if (count > 4)
+                {
+                    break;
+                }
+
+                count++;
+            }
+        }
+
+        int maxBitsCounter = length - 1;
+        int maxBits = 0;
+
+        while (maxBitsCounter != 0)
+        {
+            maxBitsCounter >>= 1;
+            ++maxBits;
+        }
+
+        if (count <= 1)
+        {
+            writer.Write(4, 1);
+            writer.Write(maxBits, s4[0]);
+            return;
+        }
+
+        JxlHuffmanTree.CreateHuffmanTree(histogram, length, 15, depth);
+        JxlHuffmanTree.ConvertBitDepthsToSymbols(depth, length, bits);
+
+        if (count <= 4)
+        {
+            StoreSimpleHuffmanTree(depth, s4, count, maxBits, writer);
+        }
+        else
+        {
+            StoreHuffmanTree(depth, length, writer);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Huffman/JxlHuffmanTree.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Huffman/JxlHuffmanTree.cs
new file mode 100644
index 0000000000..0e3faa65aa
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Huffman/JxlHuffmanTree.cs
@@ -0,0 +1,411 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Numerics.Tensors;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Huffman;
+
+/// <summary>
+/// Node of a Huffman tree.
+/// </summary>
+internal struct JxlHuffmanTree(int count, short left, short right)
+{
+    public int TotalCount = count;
+
+    /// <summary>
+    /// Index of the left node of the tree.
+    /// </summary>
+    public short IndexLeft = left;
+
+    /// <summary>
+    /// Index of the right node of the tree. If it's missing
+    /// then this is the value of the node.
+    /// </summary>
+    public short IndexRightOrValue = right;
+
+    /// <summary>
+    /// Gets a lookup table with pre-reversed 4-bit values.
+    /// This lookup is used by <see cref="ReverseBits(int, short)"/>.
+    /// </summary>
+    private static ReadOnlySpan<int> ReverseLookup =>
+    [
+        0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
+        0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf
+    ];
+
+    public static void SetDepth(ref JxlHuffmanTree p, Span<JxlHuffmanTree> pool, Span<byte> depth, byte level)
+    {
+        if (p.IndexLeft >= 0)
+        {
+            level++;
+            SetDepth(ref pool[p.IndexLeft], pool, depth, level);
+            SetDepth(ref pool[p.IndexRightOrValue], pool, depth, level);
+        }
+        else
+        {
+            depth[p.IndexRightOrValue] = level;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Compare(JxlHuffmanTree v0, JxlHuffmanTree v1)
+    {
+        if (v0.TotalCount != v1.TotalCount)
+        {
+            return v0.TotalCount.CompareTo(v1.TotalCount);
+        }
+
+        return v0.IndexRightOrValue.CompareTo(v1.IndexRightOrValue);
+    }
+
+    public static void CreateHuffmanTree(Span<int> data, int length, int treeLimit, Span<byte> depth)
+    {
+        JxlHuffmanTree[]? pool = null;
+
+        // This is basically the equivalent of List<T> but is fixed-size.
+        // We don't need an entire collection on the heap.
+        int desiredTreeItems = (2 * length) + 1;
+        Span<JxlHuffmanTree> tree =
+            desiredTreeItems <= 256
+            ? stackalloc JxlHuffmanTree[256].Slice(0, desiredTreeItems)
+            : pool = ArrayPool<JxlHuffmanTree>.Shared.Rent(desiredTreeItems);
+
+        // Number of items in our "fixed List<T>". So in other to
+        // add to the tree we do 'tree[treeRef++] = ...'.
+        int treeRef = 0;
+
+        for (int countLimit = 1; ; countLimit *= 2)
+        {
+            tree.Clear(); // Always clear on every iteration
+
+            int i = length;
+            for (; i != 0;)
+            {
+                --i;
+                if (data[i] != 0)
+                {
+                    int count = Math.Max(data[i], countLimit - 1);
+                    tree[treeRef++] = new JxlHuffmanTree(count, -1, (short)i);
+                }
+            }
+
+            if (treeRef == 1)
+            {
+                // Fake value; will be fixed on upper level.
+                depth[tree[0].IndexRightOrValue] = 1;
+                break;
+            }
+
+            tree.Sort(Compare);
+
+            JxlHuffmanTree sentinel = new(int.MaxValue, -1, -1);
+            tree[treeRef++] = sentinel;
+            tree[treeRef++] = sentinel; // We do this twice, yes
+
+            i = 0;
+            int j = treeRef + 1;
+
+            for (int k = treeRef - 1; k != 0; --k)
+            {
+                int left;
+                int right;
+
+                if (tree[i].TotalCount <= tree[j].TotalCount)
+                {
+                    left = i;
+                    i++;
+                }
+                else
+                {
+                    left = j;
+                    j++;
+                }
+
+                if (tree[i].TotalCount <= tree[j].TotalCount)
+                {
+                    right = i;
+                    i++;
+                }
+                else
+                {
+                    right = j;
+                    j++;
+                }
+
+                int j_end = treeRef - 1;
+                ref JxlHuffmanTree currTree = ref tree[j_end];
+                currTree.TotalCount = tree[left].TotalCount + tree[right].TotalCount;
+                currTree.IndexLeft = (short)left;
+                currTree.IndexRightOrValue = (short)right;
+
+                tree[treeRef++] = sentinel;
+            }
+
+            SetDepth(ref tree[(2 * treeRef) - 1], tree, depth, 0);
+
+            if (TensorPrimitives.Max((ReadOnlySpan<byte>)depth[..length]) <= treeLimit)
+            {
+                break;
+            }
+        }
+
+        // Don't forget to return the pooled array
+        if (pool is not null)
+        {
+            ArrayPool<JxlHuffmanTree>.Shared.Return(pool);
+        }
+    }
+
+    public static void Reverse(Span<byte> v, int start, int end)
+    {
+        end--;
+        while (start < end)
+        {
+            RuntimeUtility.Swap(ref v[end], ref v[start]);
+            start++;
+            end++;
+        }
+    }
+
+    public static void WriteHuffmanTreeRepetitions(byte previousValue, byte value, int repetitions, ref int treeSize, Span<byte> tree, Span<byte> extraBitsData)
+    {
+        DebugGuard.MustBeGreaterThan(repetitions, 0, nameof(repetitions));
+
+        if (previousValue != value)
+        {
+            tree[treeSize] = value;
+            extraBitsData[treeSize] = 0;
+            treeSize++;
+            repetitions--;
+        }
+
+        if (repetitions == 7)
+        {
+            tree[treeSize] = value;
+            extraBitsData[treeSize] = 0;
+            treeSize++;
+        }
+
+        if (repetitions < 3)
+        {
+            for (int i = 0; i < repetitions; ++i)
+            {
+                tree[treeSize] = value;
+                extraBitsData[treeSize] = 0;
+                treeSize++;
+            }
+        }
+        else
+        {
+            repetitions -= 3;
+            int start = treeSize;
+            while (true)
+            {
+                tree[treeSize] = 16;
+                extraBitsData[treeSize] = (byte)(repetitions & 0x3);
+                treeSize++;
+                repetitions >>= 2;
+
+                if (repetitions == 0)
+                {
+                    break;
+                }
+
+                repetitions--;
+            }
+
+            Reverse(tree, start, treeSize);
+            Reverse(extraBitsData, start, treeSize);
+        }
+    }
+
+    public static void WriteHuffmanTreeRepetitionsZeros(int repetitions, ref int treeSize, Span<byte> tree, Span<byte> extraBitsData)
+    {
+        if (repetitions == 11)
+        {
+            tree[treeSize] = 0;
+            extraBitsData[treeSize] = 0;
+            treeSize++;
+            repetitions--;
+        }
+
+        if (repetitions < 3)
+        {
+            for (int i = 0; i < repetitions; ++i)
+            {
+                tree[treeSize] = 0;
+                extraBitsData[treeSize] = 0;
+                treeSize++;
+            }
+        }
+        else
+        {
+            repetitions -= 3;
+            int start = treeSize;
+
+            while (true)
+            {
+                tree[treeSize] = 17;
+                extraBitsData[treeSize] = (byte)(repetitions & 0x7);
+                treeSize++;
+                repetitions >>= 3;
+
+                if (repetitions == 0)
+                {
+                    break;
+                }
+
+                repetitions--;
+            }
+
+            Reverse(tree, start, treeSize);
+            Reverse(extraBitsData, start, treeSize);
+        }
+    }
+
+    // Decides whether or not to use Run Length Encoding (RLE).
+    // Basically that's where, for example, when we have a
+    // string of repetitive letters "aaaaaa", instead of encoding
+    // them all separately, it encodes "a times 6".
+    public static void DecideOverRleUse(Span<byte> depth, int length, ref bool useRleForNonZero, ref bool useRleForZero)
+    {
+        int totalRepsZero = 0;
+        int totalRepsNonZero = 0;
+        int countRepsZero = 1;
+        int countRepsNonZero = 1;
+
+        for (int i = 0; i < length;)
+        {
+            byte value = depth[i];
+            int reps = 1;
+
+            for (int k = i + 1; k < length && depth[k] == value; k++)
+            {
+                reps++;
+            }
+
+            if (reps >= 3 && value == 0)
+            {
+                totalRepsZero += reps;
+                countRepsZero++;
+            }
+
+            if (reps >= 4 && value != 0)
+            {
+                totalRepsNonZero += reps;
+                countRepsNonZero++;
+            }
+
+            i += reps;
+        }
+
+        useRleForNonZero = totalRepsNonZero > countRepsNonZero * 2;
+        useRleForZero = totalRepsZero > countRepsZero * 2;
+    }
+
+    public static void WriteHuffmanTree(Span<byte> depth, int length, ref int treeSize, Span<byte> tree, Span<byte> extraBitsData)
+    {
+        byte previousValue = 8;
+        int newLength = length;
+
+        for (int i = 0; i < length; i++)
+        {
+            if (depth[length - i - 1] == 0)
+            {
+                newLength--;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        bool useRleForNonZeroes = false;
+        bool useRleForZero = false;
+
+        if (length > 50)
+        {
+            DecideOverRleUse(depth, newLength, ref useRleForNonZeroes, ref useRleForZero);
+        }
+
+        for (int i = 0; i < newLength;)
+        {
+            byte value = depth[i];
+            int reps = 1;
+
+            if ((value != 0 && useRleForNonZeroes) || (value == 0 && useRleForZero))
+            {
+                for (int k = i + 1; k < newLength && depth[k] == value; k++)
+                {
+                    reps++;
+                }
+            }
+
+            if (value == 0)
+            {
+                WriteHuffmanTreeRepetitionsZeros(reps, ref treeSize, tree, extraBitsData);
+            }
+            else
+            {
+                WriteHuffmanTreeRepetitions(previousValue, value, reps, ref treeSize, tree, extraBitsData);
+                previousValue = value;
+            }
+
+            i += reps;
+        }
+    }
+
+    public static short ReverseBits(int numBits, short bits)
+    {
+        int result = ReverseLookup[bits & 0xf];
+
+        for (int i = 4; i < numBits; i += 4)
+        {
+            result <<= 4;
+            bits = (short)(bits >> 4);
+            result |= ReverseLookup[bits & 0xf];
+        }
+
+        result >>= -numBits & 0x3;
+
+        return (short)result;
+    }
+
+    public static void ConvertBitDepthsToSymbols(Span<byte> depth, int len, Span<short> bits)
+    {
+        // In Brotli, all bit depths are [1..15]
+        // 0 bit depth means that the symbol does not exist.
+        const int maxBits = 16; // 0..15 are values for bits
+
+        Span<short> blCount = stackalloc short[maxBits];
+        blCount.Clear(); // explicitly cleared from reference
+
+        for (int i = 0; i < len; i++)
+        {
+            blCount[depth[i]]++;
+        }
+
+        blCount[0] = 0;
+
+        Span<short> nextCode = stackalloc short[maxBits]; // not cleared in reference
+        nextCode[0] = 0;
+
+        int code = 0;
+        for (int i = 1; i < maxBits; ++i)
+        {
+            code = (code + blCount[i - 1]) << 1;
+            nextCode[i] = (short)code;
+        }
+
+        for (int i = 0; i < len; ++i)
+        {
+            if (depth[i] != 0)
+            {
+                bits[i] = ReverseBits(depth[i], nextCode[depth[i]]++);
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlAcStrategyEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlAcStrategyEncoder.cs
new file mode 100644
index 0000000000..0cdce9b6a8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlAcStrategyEncoder.cs
@@ -0,0 +1,256 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal static class JxlAcStrategyEncoder
+{
+    private static readonly byte[][] TypeColors =
+    [
+        [0xFF, 0xFF, 0x00],  // DCT8       | yellow
+        [0xFF, 0x80, 0x80],  // HORNUSS    | vivid tangerine
+        [0xFF, 0x80, 0x80],  // DCT2x2     | vivid tangerine
+        [0xFF, 0x80, 0x80],  // DCT4x4     | vivid tangerine
+        [0x80, 0xFF, 0x00],  // DCT16x16   | chartreuse
+        [0x00, 0xC0, 0x00],  // DCT32x32   | waystone green
+        [0xC0, 0xFF, 0x00],  // DCT16x8    | lime
+        [0xC0, 0xFF, 0x00],  // DCT8x16    | lime
+        [0x00, 0xFF, 0x00],  // DCT32x8    | green
+        [0x00, 0xFF, 0x00],  // DCT8x32    | green
+        [0x00, 0xFF, 0x00],  // DCT32x16   | green
+        [0x00, 0xFF, 0x00],  // DCT16x32   | green
+        [0xFF, 0x80, 0x00],  // DCT4x8     | orange juice
+        [0xFF, 0x80, 0x00],  // DCT8x4     | orange juice
+        [0xFF, 0xFF, 0x80],  // AFV0       | butter
+        [0xFF, 0xFF, 0x80],  // AFV1       | butter
+        [0xFF, 0xFF, 0x80],  // AFV2       | butter
+        [0xFF, 0xFF, 0x80],  // AFV3       | butter
+        [0x00, 0xC0, 0xFF],  // DCT64x64   | capri
+        [0x00, 0xFF, 0xFF],  // DCT64x32   | aqua
+        [0x00, 0xFF, 0xFF],  // DCT32x64   | aqua
+        [0x00, 0x40, 0xFF],  // DCT128x128 | rare blue
+        [0x00, 0x80, 0xFF],  // DCT128x64  | magic ink
+        [0x00, 0x80, 0xFF],  // DCT64x128  | magic ink
+        [0x00, 0x00, 0xC0],  // DCT256x256 | keese blue
+        [0x00, 0x00, 0xFF],  // DCT256x128 | blue
+        [0x00, 0x00, 0xFF],  // DCT128x256 | blue
+        [0x00, 0x00, 0x00] // invalid    | black
+    ];
+
+#pragma warning disable // Indentation warnings only
+
+    private static readonly byte[][] Mask =
+    [
+        [
+          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, 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, 0, 0,  //
+      ],                           // DCT8
+      [
+          0, 0, 0, 0, 0, 0, 0, 0,  //
+          0, 0, 0, 0, 0, 0, 0, 0,  //
+          0, 0, 1, 0, 0, 1, 0, 0,  //
+          0, 0, 1, 0, 0, 1, 0, 0,  //
+          0, 0, 1, 1, 1, 1, 0, 0,  //
+          0, 0, 1, 0, 0, 1, 0, 0,  //
+          0, 0, 1, 0, 0, 1, 0, 0,  //
+          0, 0, 0, 0, 0, 0, 0, 0,  //
+      ],                           // HORNUSS
+      [
+        1, 1, 1, 1, 1, 1, 1, 1,  //
+          1, 0, 1, 0, 1, 0, 1, 0,  //
+          1, 1, 1, 1, 1, 1, 1, 1,  //
+          1, 0, 1, 0, 1, 0, 1, 0,  //
+          1, 1, 1, 1, 1, 1, 1, 1,  //
+          1, 0, 1, 0, 1, 0, 1, 0,  //
+          1, 1, 1, 1, 1, 1, 1, 1,  //
+          1, 0, 1, 0, 1, 0, 1, 0,  //
+      ],                           // 2x2
+      [
+        0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          1, 1, 1, 1, 1, 1, 1, 1,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+      ],                           // 4x4
+      [ ],                          // DCT16x16 (unused)
+      [ ],                          // DCT32x32 (unused)
+      [ ],                          // DCT16x8 (unused)
+      [ ],                          // DCT8x16 (unused)
+      [ ],                          // DCT32x8 (unused)
+      [ ],                          // DCT8x32 (unused)
+      [ ],                          // DCT32x16 (unused)
+      [ ],                          // DCT16x32 (unused)
+      [
+        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, 0,  //
+          1, 1, 1, 1, 1, 1, 1, 1,  //
+          0, 0, 0, 0, 0, 0, 0, 0,  //
+          0, 0, 0, 0, 0, 0, 0, 0,  //
+          0, 0, 0, 0, 0, 0, 0, 0,  //
+      ],                           // DCT4x8
+      [
+        0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+          0, 0, 0, 0, 1, 0, 0, 0,  //
+      ],                           // DCT8x4
+      [
+        1, 1, 1, 1, 1, 0, 0, 0,  //
+          1, 1, 1, 1, 0, 0, 0, 0,  //
+          1, 1, 1, 0, 0, 0, 0, 0,  //
+          1, 1, 0, 0, 0, 0, 0, 0,  //
+          1, 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,  //
+      ],                           // AFV0
+      [
+    0, 0, 0, 0, 1, 1, 1, 1,  //
+          0, 0, 0, 0, 0, 1, 1, 1,  //
+          0, 0, 0, 0, 0, 0, 1, 1,  //
+          0, 0, 0, 0, 0, 0, 0, 1,  //
+          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, 0,  //
+      ],                           // AFV1
+      [
+    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, 0,  //
+          1, 0, 0, 0, 0, 0, 0, 0,  //
+          1, 1, 0, 0, 0, 0, 0, 0,  //
+          1, 1, 1, 0, 0, 0, 0, 0,  //
+          1, 1, 1, 1, 0, 0, 0, 0,  //
+      ],                           // AFV2
+      [
+    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, 0,  //
+          0, 0, 0, 0, 0, 0, 0, 0,  //
+          0, 0, 0, 0, 0, 0, 0, 1,  //
+          0, 0, 0, 0, 0, 0, 1, 1,  //
+          0, 0, 0, 0, 0, 1, 1, 1,  //
+      ],                           // AFV3
+      [ ]                           // invalid
+    ];
+
+#pragma warning restore
+
+    public static ReadOnlySpan<byte> TypeColor(int rawStrategy)
+    {
+        DebugGuard.IsTrue(JxlAcStrategy.IsRawStrategyValid(rawStrategy), $"Raw strategy must be a valid strategy: {rawStrategy}");
+        rawStrategy = Math.Clamp(rawStrategy, 0, JxlAcStrategy.NumberOfValidStrategies);
+        return TypeColors[rawStrategy];
+    }
+
+    public static ReadOnlySpan<byte> TypeMask(int rawStrategy)
+    {
+        DebugGuard.IsTrue(JxlAcStrategy.IsRawStrategyValid(rawStrategy), $"Raw strategy must be a valid strategy: {rawStrategy}");
+        rawStrategy = Math.Clamp(rawStrategy, 0, JxlAcStrategy.NumberOfValidStrategies);
+        return Mask[rawStrategy];
+    }
+
+    public static bool MultiBlockTransformCrossesHorizontalBoundary(JxlAcStrategyImage acStrategyImage, int startX, int y, int endX)
+    {
+        if (startX >= acStrategyImage.XSize || y >= acStrategyImage.YSize)
+        {
+            return false;
+        }
+
+        if (y % 8 == 0)
+        {
+            // Nothing crosses 64x64 boundaries, and the memory on the other side
+            // of the 64x64 block may still uninitialized.
+            return false;
+        }
+
+        endX = Math.Min(endX, acStrategyImage.XSize);
+
+        // The first multiblock might be before the start_x, let's adjust it
+        // to point to the first IsFirstBlock() == true block we find by backward
+        // tracing.
+        JxlAcStrategyRow row = acStrategyImage.GetRow(y);
+        int startXLimit = startX & ~7;
+
+        while (startX != startXLimit && !row[startX].IsFirstBlock)
+        {
+            startX--;
+        }
+
+        for (int x = startX; x < endX;)
+        {
+            if (row[x].IsFirstBlock)
+            {
+                x += row[x].CoveredBlocksX;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static bool MultiBlockTransformCrossesVerticalBoundary(JxlAcStrategyImage acStrategyImage, int x, int startY, int endY)
+    {
+        if (x >= acStrategyImage.XSize || startY >= acStrategyImage.YSize)
+        {
+            return false;
+        }
+
+        if (x % 8 == 0)
+        {
+            // Nothing crosses 64x64 boundaries, and the memory on the other side
+            // of the 64x64 block may still uninitialized.
+            return false;
+        }
+
+        endY = Math.Min(endY, acStrategyImage.YSize);
+
+        // The first multiblock might be before the start_y, let's adjust it
+        // to point to the first IsFirstBlock() == true block we find by backward
+        // tracing.
+        int startYLimit = startY & ~7;
+        while (startY != startYLimit && !acStrategyImage.GetRow(startY)[x].IsFirstBlock)
+        {
+            startY--;
+        }
+
+        for (int y = startY; y < endY;)
+        {
+            JxlAcStrategyRow row = acStrategyImage.GetRow(y);
+
+            if (row[x].IsFirstBlock)
+            {
+                y += row[x].CoveredBlocksY;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlAdaptiveQuantization.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlAdaptiveQuantization.cs
new file mode 100644
index 0000000000..00150b3dd3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlAdaptiveQuantization.cs
@@ -0,0 +1,44 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+/// <summary>
+/// Adaptive quantization encoder
+/// </summary>
+internal static class JxlAdaptiveQuantization
+{
+    // Scaling differences between JPEG XL and Butteraugli
+    private const float SGMul = 226.77216153508914f;
+    private const float SGMul2 = 1f / 73.377132366608819f;
+
+    // Includes correlation factor for std::log -> log2
+    private const float SGRetMul = SGMul2 * 18.6580932135f * JxlMath.InverseLog2E;
+    private const float SGVOffset = 7.7825991679894591f;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float ComputeMaskForAcStrategyUse(float outputValue)
+    {
+        const float multiplier = 1f;
+        const float offset = 0.001f;
+
+        return multiplier / (outputValue + offset);
+    }
+
+    public static float RatioOfDerivativesOfCubicRootToSimpleGamma(float v, bool invert = false)
+    {
+        float epsilon = 1e-2f;
+        v = Math.Max(0, v); // cannot be < 0
+        const float numMul = SGRetMul * 3 * SGMul;
+        float voffset = (SGVOffset * JxlMath.InverseLog2E) + epsilon;
+        const float denMul = JxlMath.InverseLog2E * SGMul;
+
+        float v2 = v * v;
+        float num = (numMul * v2) + epsilon;
+        float den = ((denMul * v) * v2) + voffset;
+
+        return invert ? num / den : den / num;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlBitWriter.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlBitWriter.cs
new file mode 100644
index 0000000000..924dac7c92
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlBitWriter.cs
@@ -0,0 +1,100 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal sealed class JxlBitWriter(Stream stream)
+{
+    private const int BitsPerByte = 8;
+
+    private bool isLimited;
+    private ulong bitsLimit;
+
+    private byte currentByte;
+    private int bitsInCurrentByte;
+
+    public long BitsWritten { get; private set; }
+
+    public void Write(int nBits, int bits) => this.Write(nBits, (ulong)bits);
+
+    public void Write(int nBits, ulong bits)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(nBits, 0, nameof(nBits));
+        DebugGuard.MustBeLessThanOrEqualTo(nBits, 64, nameof(nBits));
+
+        if (this.isLimited)
+        {
+            if ((ulong)nBits > this.bitsLimit)
+            {
+                throw new InvalidOperationException("Too many bits were written");
+            }
+
+            this.bitsLimit -= (ulong)nBits;
+        }
+
+        while (nBits > 0)
+        {
+            int bitsAvailable = BitsPerByte - this.bitsInCurrentByte;
+            int count = Math.Min(nBits, bitsAvailable);
+
+            ulong mask = count == 64
+                ? ulong.MaxValue
+                : (1UL << count) - 1;
+
+            this.currentByte |= (byte)((bits & mask) << this.bitsInCurrentByte);
+
+            bits >>= count;
+            nBits -= count;
+            this.bitsInCurrentByte += count;
+            this.BitsWritten += count;
+
+            if (this.bitsInCurrentByte == BitsPerByte)
+            {
+                stream.WriteByte(this.currentByte);
+                this.currentByte = 0;
+                this.bitsInCurrentByte = 0;
+            }
+        }
+    }
+
+    public void ZeroPadToByte()
+    {
+        long remainderBits = JxlMath.RoundUpBitsToByteMultiple((int)this.BitsWritten) - this.BitsWritten;
+
+        if (remainderBits == 0)
+        {
+            return;
+        }
+
+        this.Write((int)remainderBits, 0);
+    }
+
+    public bool WithMaxBits(ulong maxBits, Func<bool> func)
+    {
+        bool previousIsLimited = this.isLimited;
+        ulong previousLimit = this.bitsLimit;
+
+        this.isLimited = true;
+        this.bitsLimit = maxBits;
+
+        try
+        {
+            return func();
+        }
+        finally
+        {
+            this.isLimited = previousIsLimited;
+            this.bitsLimit = previousLimit;
+        }
+    }
+
+    public void Flush()
+    {
+        if (this.bitsInCurrentByte != 0)
+        {
+            stream.WriteByte(this.currentByte);
+            this.currentByte = 0;
+            this.bitsInCurrentByte = 0;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlCoefficientOrderEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlCoefficientOrderEncoder.cs
new file mode 100644
index 0000000000..650717ee7d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlCoefficientOrderEncoder.cs
@@ -0,0 +1,422 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal static class JxlCoefficientOrderEncoder
+{
+    private struct PosAndCount
+    {
+        public uint Pos;
+        public ulong CountAndIdx;
+    }
+
+    private static (uint UsedOrders, uint CustomizeOrders) ComputeUsedOrders(JxlSpeedTier speed, JxlAcStrategyImage acStrategy, Rectangle rect)
+    {
+        if (speed >= JxlSpeedTier.Falcon)
+        {
+            return (1, 1);
+        }
+
+        uint ret = 0;
+        uint retCustomize = 0;
+        int xSizeBlocks = rect.Width;
+        int ySizeBlocks = rect.Height;
+
+        for (int by = 0; by < ySizeBlocks; by++)
+        {
+            JxlAcStrategyRow acsRow = acStrategy.GetRow(rect, by);
+
+            for (int bx = 0; bx < xSizeBlocks; bx++)
+            {
+                byte ord = JxlCoefficientOrder.StrategyOrder[acsRow[bx].RawStrategy];
+
+                ret |= 1u << ord;
+
+                if (ord > 6)
+                {
+                    continue;
+                }
+
+                retCustomize |= 1u << ord;
+            }
+        }
+
+        if (acStrategy.XSize < 5 && acStrategy.YSize < 5)
+        {
+            return (ret, 0);
+        }
+
+        return (ret, retCustomize);
+    }
+
+    private static bool ComputeCoeffOrder(JxlSpeedTier speed, IJxlDctAcImage acImage, JxlAcStrategyImage acStrategy, JxlFrameDimensions frameDim, ref uint allUsedOrders, uint prevUsedAcs, uint currentUsedAcs, uint currentUsedOrders, Span<int> order)
+    {
+        int[] numZeros = new int[JxlCoefficientOrder.CoefficientOrderMaxSize];
+        double blockFraction = 1.0;
+
+        if (speed >= JxlSpeedTier.Squirrel && currentUsedOrders == 1)
+        {
+            blockFraction = 0.5;
+        }
+
+        if (currentUsedOrders != 0)
+        {
+            ulong threshold = uint.MaxValue * (ulong)blockFraction;
+
+            ulong s0 = 0x94D049BB133111EBUL;
+            ulong s1 = 0xBF58476D1CE4E5B9UL;
+
+            bool UseSample()
+            {
+                ulong s = s0;
+                ulong s0Local = s1;
+                ulong bits = s + s0Local;
+
+                s0 = s0Local;
+
+                s ^= s << 23;
+                s ^= s0Local ^ (s >> 18) ^ (s0Local >> 5);
+                s1 = s;
+
+                return (bits >> 32) <= threshold;
+            }
+
+            for (int groupIndex = 0; groupIndex < frameDim.NumGroups; ++groupIndex)
+            {
+                int gx = groupIndex % frameDim.XSizeGroups;
+                int gy = groupIndex / frameDim.XSizeGroups;
+
+                Rectangle rect = RectangleUtils.CreateRectangle(
+                    gx * JxlFrameDimensions.GroupDimensionsInBlocks,
+                    gy * JxlFrameDimensions.GroupDimensionsInBlocks,
+                    JxlFrameDimensions.GroupDimensionsInBlocks,
+                    JxlFrameDimensions.GroupDimensionsInBlocks,
+                    frameDim.XSizeBlocks,
+                    frameDim.YSizeBlocks);
+
+                int acOffset = 0;
+                JxlDctAcType type = acImage.Type;
+
+                for (int by = 0; by < rect.Height; ++by)
+                {
+                    JxlAcStrategyRow acsRow = acStrategy.GetRow(rect, by);
+
+                    for (int bx = 0; bx < rect.Width; ++bx)
+                    {
+                        JxlAcStrategy acs = acsRow[bx];
+
+                        if (!acs.IsFirstBlock)
+                        {
+                            continue;
+                        }
+
+                        if (!UseSample())
+                        {
+                            continue;
+                        }
+
+                        int size = JxlFrameDimensions.DctBlockSize << acs.Log2CoveredBlocks;
+
+                        for (int c = 0; c < 3; ++c)
+                        {
+                            int orderOffset = JxlCoefficientOrder.CoeffOrderOffset(JxlCoefficientOrder.StrategyOrder[acs.RawStrategy], c);
+
+                            if (type == JxlDctAcType.Ac16)
+                            {
+                                for (int k = 0; k < size; ++k)
+                                {
+                                    bool isZero = acImage.GetPlaneRow(c, groupIndex, 0).Pointer16[acOffset + k] == 0;
+                                    if (isZero)
+                                    {
+                                        ++numZeros[orderOffset + k];
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                for (int k = 0; k < size; ++k)
+                                {
+                                    bool isZero = acImage.GetPlaneRow(c, groupIndex, 0).Pointer32[acOffset + k] == 0;
+                                    if (isZero)
+                                    {
+                                        ++numZeros[orderOffset + k];
+                                    }
+                                }
+                            }
+
+                            int cx = acs.CoveredBlocksX;
+                            int cy = acs.CoveredBlocksY;
+
+                            JxlForwardCoefficientOrder.CoefficientLayout(ref cy, ref cx);
+
+                            for (int iy = 0; iy < cy; ++iy)
+                            {
+                                for (int ix = 0; ix < cx; ++ix)
+                                {
+                                    numZeros[orderOffset + (iy * JxlFrameDimensions.BlockDimensions * cx) + ix] = -1;
+                                }
+                            }
+                        }
+
+                        acOffset += size;
+                    }
+                }
+            }
+        }
+
+        PosAndCount[] posAndVal = new PosAndCount[JxlAcStrategy.MaximumCoefficientArea];
+        int[] naturalOrderBuffer = [];
+
+        ushort computed = 0;
+
+        for (byte o = 0; o < JxlAcStrategy.NumberOfValidStrategies; ++o)
+        {
+            byte ord = JxlCoefficientOrder.StrategyOrder[o];
+
+            if ((computed & (1 << ord)) != 0)
+            {
+                continue;
+            }
+
+            computed |= (ushort)(1 << ord);
+
+            JxlAcStrategy acs = new(o);
+
+            int sz = JxlFrameDimensions.DctBlockSize * acs.CoveredBlocksX * acs.CoveredBlocksY;
+
+            if (sz > (1 << 16))
+            {
+                throw new InvalidOperationException("Inavlid size");
+            }
+
+            if (((1u << ord) & ~currentUsedAcs) != 0)
+            {
+                continue;
+            }
+
+            if (((1u << ord) & prevUsedAcs) != 0)
+            {
+                continue;
+            }
+
+            if (((1u << ord) & allUsedOrders) != 0)
+            {
+                continue;
+            }
+
+            if (naturalOrderBuffer.Length < sz)
+            {
+                // Not sure how large can sz get...
+                naturalOrderBuffer = new int[sz];
+            }
+
+            acs.ComputeNaturalCoefficientOrder(naturalOrderBuffer);
+
+            if (((1u << ord) & ~currentUsedOrders) != 0)
+            {
+                for (int c = 0; c < 3; ++c)
+                {
+                    int offset = JxlCoefficientOrder.CoeffOrderOffset(ord, c);
+
+                    if (JxlCoefficientOrder.CoeffOrderOffset(ord, c + 1) - offset != sz)
+                    {
+                        throw new InvalidOperationException("Invalid coefficient order");
+                    }
+
+                    naturalOrderBuffer.AsSpan(0, sz).CopyTo(order.Slice(offset, sz));
+                }
+
+                continue;
+            }
+
+            bool isNonDefault = false;
+
+            for (byte c = 0; c < 3; ++c)
+            {
+                int offset = JxlCoefficientOrder.CoeffOrderOffset(ord, c);
+
+                if (JxlCoefficientOrder.CoeffOrderOffset(ord, c + 1) - offset != sz)
+                {
+                    throw new InvalidOperationException("Invalid coefficient order");
+                }
+
+                float invSqrtSz = 1.0f / MathF.Sqrt(sz);
+
+                for (int i = 0; i < sz; ++i)
+                {
+                    int pos = naturalOrderBuffer[i];
+
+                    posAndVal[i].Pos = (uint)pos;
+                    ulong count = (ulong)((numZeros[offset + pos] * invSqrtSz) + 0.1f);
+
+                    if (count >= 1uL << 48)
+                    {
+                        throw new InvalidOperationException("Count is too large");
+                    }
+
+                    posAndVal[i].CountAndIdx = (count << 16) | (uint)i;
+                }
+
+                Array.Sort(posAndVal, 0, sz, PosAndCountComparer.Instance);
+
+                for (int i = 0; i < sz; ++i)
+                {
+                    order[offset + i] = (int)posAndVal[i].Pos;
+
+                    isNonDefault |= naturalOrderBuffer[i] != posAndVal[i].Pos;
+                }
+            }
+
+            if (!isNonDefault)
+            {
+                currentUsedOrders &= ~(1u << ord);
+            }
+        }
+
+        allUsedOrders |= currentUsedOrders;
+        return true;
+    }
+
+    private static bool TokenizePermutation(ReadOnlySpan<uint> order, int skip, int size, List<JxlToken> tokens)
+    {
+        uint[] lehmer = new uint[size];
+        uint[] temp = new uint[size + 1];
+
+        if (!JxlLehmerCode.ComputeLehmerCode(order, temp, size, lehmer))
+        {
+            return false;
+        }
+
+        int end = size;
+        while (end > skip && lehmer[end - 1] == 0)
+        {
+            --end;
+        }
+
+        tokens.Add(new JxlToken((JxlMaTreeContext)JxlCoefficientOrder.CoeffOrderContext((uint)size), (uint)(end - skip)));
+
+        uint last = 0;
+        for (int i = skip; i < end; ++i)
+        {
+            tokens.Add(new JxlToken((JxlMaTreeContext)JxlCoefficientOrder.CoeffOrderContext(last), lehmer[i]));
+            last = lehmer[i];
+        }
+
+        return true;
+    }
+
+    public static bool EncodePermutation(ReadOnlySpan<uint> order, int skip, int size, JxlBitWriter writer)
+    {
+        List<JxlToken>[] tokens = [[]];
+
+        if (!TokenizePermutation(order, skip, size, tokens[0]))
+        {
+            return false;
+        }
+
+        JxlEntropyEncodingData codes = new();
+
+        if (!BuildAndEncodeHistograms(configuration, new JxlHistogramParameters(), PermutationContext, tokens, out codes, writer, out _))
+        {
+            return false;
+        }
+
+        return WriteTokens(tokens[0], codes, 0, writer);
+    }
+
+    private static bool EncodeCoeffOrder(ReadOnlySpan<uint> order, JxlAcStrategy acs, List<JxlToken> tokens, Span<uint> orderZigzag, Span<int> naturalOrderLut)
+    {
+        int llf = acs.CoveredBlocksX * acs.CoveredBlocksY;
+        int size = JxlFrameDimensions.DctBlockSize * llf;
+
+        for (int i = 0; i < size; ++i)
+        {
+            orderZigzag[i] = (uint)naturalOrderLut[(int)order[i]];
+        }
+
+        return TokenizePermutation(orderZigzag[..size], llf, size, tokens);
+    }
+
+    public static bool EncodeCoeffOrders(ushort usedOrders, ReadOnlySpan<uint> order, JxlBitWriter writer, JxlLayerType layer, JxlAuxiliaryOutput auxOut)
+    {
+        int memSize = JxlAcStrategy.MaximumCoefficientArea;
+
+        // TODO: pool this? or allocate with Configuration.MemoryAllocator? memSize=65536
+        uint[] orderZigzag = new uint[memSize];
+
+        ushort computed = 0;
+        List<JxlToken>[] tokens = [[]];
+        int[] naturalOrderLut = [];
+
+        for (byte o = 0; o < JxlAcStrategy.NumberOfValidStrategies; ++o)
+        {
+            byte ord = JxlCoefficientOrder.StrategyOrder[o];
+
+            if ((computed & (1 << ord)) != 0)
+            {
+                continue;
+            }
+
+            computed |= (ushort)(1 << ord);
+
+            if ((usedOrders & (1 << ord)) == 0)
+            {
+                continue;
+            }
+
+            JxlAcStrategy acs = new(o);
+
+            int llf = acs.CoveredBlocksX * acs.CoveredBlocksY;
+            int size = JxlFrameDimensions.DctBlockSize * llf;
+
+            if (naturalOrderLut.Length < size)
+            {
+                naturalOrderLut = new int[size];
+            }
+
+            acs.ComputeNaturalCoefficientOrderLookup(naturalOrderLut);
+
+            for (int c = 0; c < 3; ++c)
+            {
+                int offset = JxlCoefficientOrder.CoeffOrderOffset(ord, c);
+
+                if (!EncodeCoeffOrder(order.Slice(offset, size), acs, tokens[0], orderZigzag.AsSpan(0, size), naturalOrderLut))
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (usedOrders != 0)
+        {
+            JxlEntropyEncodingData codes = new();
+
+            if (!BuildAndEncodeHistograms(configuration, new JxlHistogramParameters(), PermutationContexts, tokens, out codes, writer, layer, auxOut, out _))
+            {
+                return false;
+            }
+
+            if (!WriteTokens(tokens[0], codes, 0, writer, layer, auxOut))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private sealed class PosAndCountComparer : IComparer<PosAndCount>
+    {
+        public static readonly PosAndCountComparer Instance = new();
+
+        public int Compare(PosAndCount a, PosAndCount b) => a.CountAndIdx.CompareTo(b.CountAndIdx);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlGaborish.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlGaborish.cs
new file mode 100644
index 0000000000..4fddd68873
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlGaborish.cs
@@ -0,0 +1,70 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+/// <summary>
+/// Gaborish transform
+/// </summary>
+internal static class JxlGaborish
+{
+    private static ReadOnlySpan<float> GaborishLookup => [
+        -0.09495815671340026f, -0.041031725066768575f, 0.013710004822696948f,
+        0.006510206083837737f, -0.0014789063378272242f];
+
+    public static void InverseGaborish(Configuration configuration, JxlImage3F inOut, Rectangle rect, InlineArray3<float> mul)
+    {
+        InlineArray3<JxlWeightsSymmetric5> weights = default;
+
+        for (int i = 0; i < 3; ++i)
+        {
+            double sum = 1.0 + (mul[i] * 4 * ((GaborishLookup[0] + GaborishLookup[1]) + (GaborishLookup[2] + GaborishLookup[4]) + (2 * GaborishLookup[3])));
+            sum = Math.Max(sum, 1e-5); // if (sum < 1e-5) sum = 1e-5
+
+            float normalize = (float)(1.0f / sum);
+            float normalizeMul = mul[i] * normalize;
+
+            weights[i] = new JxlWeightsSymmetric5()
+            {
+                C = JxlWeightsSymmetric5.CreateVector4(normalize),
+                R = JxlWeightsSymmetric5.CreateVector4(normalizeMul * GaborishLookup[0]),
+                R2 = JxlWeightsSymmetric5.CreateVector4(normalizeMul * GaborishLookup[2]),
+                D = JxlWeightsSymmetric5.CreateVector4(normalizeMul * GaborishLookup[1]),
+                D2 = JxlWeightsSymmetric5.CreateVector4(normalizeMul * GaborishLookup[4]),
+                L = JxlWeightsSymmetric5.CreateVector4(normalizeMul * GaborishLookup[3])
+            };
+        }
+
+        using JxlImageF temp = new(configuration, inOut.Plane(2).XSize, inOut.Plane(2).YSize);
+
+        if (!JxlImageOperations.CopyImage(inOut.Plane(2), temp))
+        {
+            throw new InvalidOperationException("Image copying failed");
+        }
+
+        Rectangle xRect = RectangleUtils.Extend(rect, 3, inOut.GetRectangle());
+
+        if (!JxlConvolve.Symmetric5(inOut.Plane(0), xRect, ref weights[0], inOut.Plane(2), xRect))
+        {
+            throw new InvalidOperationException("Symmetric5 convolution failed");
+        }
+
+        if (!JxlConvolve.Symmetric5(inOut.Plane(1), xRect, ref weights[1], inOut.Plane(0), xRect))
+        {
+            throw new InvalidOperationException("Symmetric5 convolution failed");
+        }
+
+        if (!JxlConvolve.Symmetric5(temp, xRect, ref weights[2], inOut.Plane(1), xRect))
+        {
+            throw new InvalidOperationException("Symmetric5 convolution failed");
+        }
+
+        inOut.Plane(0).Swap(inOut.Plane(1));
+        inOut.Plane(0).Swap(inOut.Plane(2));
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlGammaCorrect.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlGammaCorrect.cs
new file mode 100644
index 0000000000..1b60ed38c8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlGammaCorrect.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal static class JxlGammaCorrect
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static double SRgb8ToLinearDirect(double srgb)
+    {
+        if (srgb <= 0.0)
+        {
+            return 0.0;
+        }
+
+        if (srgb <= 0.04045)
+        {
+            return srgb / 12.92;
+        }
+
+        if (srgb >= 1.0)
+        {
+            return 1.0;
+        }
+
+        return Math.Pow((srgb + 0.055) / 1.055, 2.4);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static double LinearToSRgb8Direct(double linear)
+    {
+        if (linear <= 0.0)
+        {
+            return 0.0;
+        }
+
+        if (linear >= 1.0)
+        {
+            return 1.0;
+        }
+
+        if (linear <= 0.0031308)
+        {
+            return linear * 12.92;
+        }
+
+        return (Math.Pow(linear, 1.0 / 2.4) * 1.055) - 0.055;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlHeuristics.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlHeuristics.cs
new file mode 100644
index 0000000000..846f791f69
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlHeuristics.cs
@@ -0,0 +1,170 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal static class JxlHeuristics
+{
+    private static ReadOnlySpan<byte> SimpleContextMap =>
+    [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    ];
+
+    public static void FindBestBlockEntropyModel(JxlCompressParameters cparameters, JxlImageI rqf, JxlAcStrategyImage acStrategy, JxlBlockContextMap blockCtxMap)
+    {
+        if (cparameters.DecodingSpeedTier >= 1)
+        {
+            SimpleContextMap.CopyTo(blockCtxMap.ContextMap.AsSpan());
+            blockCtxMap.ContextCount = 2;
+            blockCtxMap.DcContextCount = 1;
+            return;
+        }
+
+        if (cparameters.SpeedTier >= JxlSpeedTier.Falcon)
+        {
+            return;
+        }
+
+        int total = rqf.XSize * rqf.YSize;
+        int sizeForContextModel = (1 << 10) * cparameters.ButteraugliDistance;
+
+        if (total < sizeForContextModel)
+        {
+            return;
+        }
+
+        OccCounters counters = new(rqf, acStrategy);
+        int sizeForQfSplit = (1 << 13) * cparameters.ButteraugliDistance;
+        int numQfSegments = total < sizeForQfSplit ? 1 : 2;
+        List<uint> qft = blockCtxMap.QfThresholds;
+        qft.Clear();
+        int cumulativeSum = 0;
+        int next = 1;
+        int lastCut = 256;
+        int cut = total * next / numQfSegments;
+
+        for (int j = 0; j < 256; j++)
+        {
+            cumulativeSum += counters.QfCounts[j];
+
+            if (cumulativeSum > cut)
+            {
+                if (j != 0)
+                {
+                    qft.Add((uint)j);
+                }
+
+                lastCut = j;
+
+                while (cumulativeSum > cut)
+                {
+                    next++;
+                    cut = total * next / numQfSegments;
+                }
+            }
+            else if (next > qft.Count + 1)
+            {
+                if (j - 1 == lastCut && j != 0)
+                {
+                    qft.Add((uint)j);
+                }
+            }
+        }
+
+        int[]? pooledCounts = null;
+        int[]? pooledRemap = null;
+        int[]? pooledClusters = null;
+        int countsLength = JxlForwardCoefficientOrder.OrderCount * (qft.Count + 1);
+
+        Span<int> counts =
+            countsLength <= 128
+                ? stackalloc int[128].Slice(0, countsLength)
+                : pooledCounts = ArrayPool<int>.Shared.Rent(countsLength);
+
+        Span<int> remap =
+            countsLength <= 128
+                ? stackalloc int[128].Slice(0, countsLength)
+                : pooledRemap = ArrayPool<int>.Shared.Rent(countsLength);
+
+        Span<int> clusters =
+            countsLength <= 128
+                ? stackalloc int[128].Slice(0, countsLength)
+                : pooledClusters = ArrayPool<int>.Shared.Rent(countsLength);
+
+        int qftPos = 0;
+
+        for (int j = 0; j < 256; j++)
+        {
+            if (qftPos < qft.Count && j == qft[qftPos])
+            {
+                qftPos++;
+            }
+
+            for (int i = 0; i < JxlForwardCoefficientOrder.OrderCount; i++)
+            {
+                counts[qftPos + (i * (qft.Count + 1))] += counters.QfOrdCounts[i, j];
+            }
+        }
+
+        JxlSimdUtils.Iota(remap, 0);
+        remap.CopyTo(clusters);
+
+        int numClusters = Math.Clamp(total / sizeForContextModel / 2, 2, 9);
+        int numClustersChroma = Math.Clamp(total / sizeForContextModel / 3, 1, 5);
+
+        // TODO: method incomplete
+        // do not forget to ArrayPool<int>.Shared.Return pooledCounts, pooledRemap, pooledClusters if needed
+    }
+
+    private sealed class OccCounters : IDisposable
+    {
+        private readonly int[] qfCounts;
+        private readonly int[] dataForQfOrdCounts;
+        private readonly int[] ordCounts;
+
+        public OccCounters(JxlImageI rqf, JxlAcStrategyImage acStrategy)
+        {
+            this.qfCounts = ArrayPool<int>.Shared.Rent(256);
+            this.dataForQfOrdCounts = ArrayPool<int>.Shared.Rent(256 * JxlForwardCoefficientOrder.OrderCount);
+            this.ordCounts = ArrayPool<int>.Shared.Rent(JxlForwardCoefficientOrder.OrderCount);
+
+            this.QfOrdCounts = new(JxlForwardCoefficientOrder.OrderCount, 256, this.dataForQfOrdCounts);
+
+            for (int y = 0; y < rqf.YSize; y++)
+            {
+                Span<int> qfRow = rqf.GetRow(y);
+                JxlAcStrategyRow acsRow = acStrategy.GetRow(y);
+
+                for (int x = 0; x < rqf.XSize; x++)
+                {
+                    int ord = JxlCoefficientOrder.StrategyOrder[acsRow[x].RawStrategy];
+                    int qf = qfRow[x] - 1;
+                    this.qfCounts[qf]++;
+                    this.QfOrdCounts[ord, qf]++;
+                    this.ordCounts[ord]++;
+                }
+            }
+        }
+
+        public Span<int> QfCounts => this.qfCounts.AsSpan();
+
+        public DenseMatrix<int> QfOrdCounts { get; }
+
+        public Span<int> OrdCounts => this.ordCounts.AsSpan();
+
+        public void Dispose()
+        {
+            ArrayPool<int>.Shared.Return(this.qfCounts);
+            ArrayPool<int>.Shared.Return(this.dataForQfOrdCounts);
+            ArrayPool<int>.Shared.Return(this.ordCounts);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlLinearAlgebra.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlLinearAlgebra.cs
new file mode 100644
index 0000000000..be1f4a75b6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlLinearAlgebra.cs
@@ -0,0 +1,52 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using Matrix2x2 = System.Runtime.CompilerServices.InlineArray2<System.Runtime.CompilerServices.InlineArray2<double>>;
+using Vector2 = System.Runtime.CompilerServices.InlineArray2<double>;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+/// <summary>
+/// Handles linear algebra for encoding.
+/// </summary>
+internal static class JxlLinearAlgebra
+{
+    public static void ConvertToDiagonal(Matrix2x2 a, ref Vector2 diag, ref Matrix2x2 u)
+    {
+        DebugGuard.MustBeLessThan(Math.Abs(a[0][1] - a[1][0]), 1e-15, nameof(a));
+
+        double b = -(a[0][0] + a[1][1]);
+        double c = (a[0][0] * a[1][1]) - (a[0][1] * a[0][1]);
+        double d = (b * b) - (4.0 * c);
+
+        if (Math.Abs(a[0][1]) < 1e-10 || d < 0)
+        {
+            // Already diagonal.
+            diag[0] = a[0][0];
+            diag[1] = a[1][1];
+            u[0][0] = u[1][1] = 1.0;
+            u[0][1] = u[1][0] = 0.0;
+            return;
+        }
+
+        double sqd = Math.Sqrt(d);
+        double l1 = (-b - sqd) * 0.5;
+        double l2 = (-b + sqd) * 0.5;
+
+        Vector2 v1 = default;
+        v1[0] = a[0][0] - l1;
+        v1[1] = a[1][0];
+
+        double v1n = 1.0 / JxlMath.Hypot(v1[0], v1[1]);
+        v1[0] = v1[0] * v1n;
+        v1[1] = v1[1] * v1n;
+
+        diag[0] = l1;
+        diag[1] = l2;
+
+        u[0][0] = v1[1];
+        u[0][1] = -v1[0];
+        u[1][0] = v1[0];
+        u[1][1] = v1[1];
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlSplineEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlSplineEncoder.cs
new file mode 100644
index 0000000000..949b43870e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlSplineEncoder.cs
@@ -0,0 +1,83 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal sealed class JxlSplineEncoder
+{
+    private static void Tokenize(JxlQuantizedSpline spline, List<JxlToken> tokens)
+    {
+        tokens.Add(new(JxlSplineEntropyContext.NumControlPoints, (uint)spline.ControlPoints.Length));
+
+        foreach (JxlControlPoint point in spline.ControlPoints.Span)
+        {
+            tokens.Add(new(JxlSplineEntropyContext.ControlPoints, JxlPackSigned.PackUnsigned(point.First)));
+            tokens.Add(new(JxlSplineEntropyContext.ControlPoints, JxlPackSigned.PackUnsigned(point.Second)));
+        }
+
+        void EncodeDCT(Span<int> dct)
+        {
+            for (int i = 0; i < 32; i++)
+            {
+                tokens.Add(new(JxlSplineEntropyContext.Dct, JxlPackSigned.PackUnsigned(dct[i])));
+            }
+        }
+
+        foreach (Span<int> dct in spline.ColorDct)
+        {
+            EncodeDCT(dct);
+        }
+
+        EncodeDCT(spline.SigmaDct);
+    }
+
+    public static void EncodeAllStartingPoints(Span<PointF> points, List<JxlToken> tokens)
+    {
+        long lastX = 0;
+        long lastY = 0;
+
+        for (int i = 0; i < points.Length; i++)
+        {
+            long x = (long)MathF.Round(points[i].X, MidpointRounding.AwayFromZero);
+            long y = (long)MathF.Round(points[i].Y, MidpointRounding.AwayFromZero);
+
+            if (i == 0)
+            {
+                tokens.Add(new(JxlSplineEntropyContext.StartingPosition, (uint)x));
+                tokens.Add(new(JxlSplineEntropyContext.StartingPosition, (uint)y));
+            }
+            else
+            {
+                tokens.Add(new(JxlSplineEntropyContext.StartingPosition, JxlPackSigned.PackUnsigned((int)(x - lastX))));
+                tokens.Add(new(JxlSplineEntropyContext.StartingPosition, JxlPackSigned.PackUnsigned((int)(y - lastY))));
+            }
+
+            lastX = x;
+            lastY = y;
+        }
+    }
+
+    public static void EncodeSplines(JxlSplines splines, JxlBitWriter writer, JxlLayerType layer, JxlHistogramParameters histogramParameters, JxlAuxiliaryOutput auxOut)
+    {
+        Span<JxlQuantizedSpline> quantizedSplines = splines.QuantizedSplines;
+        List<List<JxlToken>> tokens = [[]];
+        tokens[0].Add(new(JxlSplineEntropyContext.NumSplineContexts, (uint)(quantizedSplines.Length - 1)));
+
+        EncodeAllStartingPoints(splines.StartingPoints, tokens[0]);
+
+        tokens[0].Add(new(JxlSplineEntropyContext.QuantizationAdjustment, JxlPackSigned.PackUnsigned(splines.QuantizationAdjustment)));
+
+        foreach (JxlQuantizedSpline spline in quantizedSplines)
+        {
+            Tokenize(spline, tokens[0]);
+        }
+
+        _ = BuildAndEncodeHistograms(writer, histogramParameters, JxlSplineEntropyContext.NumSplineContexts, tokens, out JxlEntropyEncodingData codes, writer, layer, auxOut);
+        WriteTokens(tokens[0], codes, 0, writer, layer, auxOut);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlTocEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlTocEncoder.cs
new file mode 100644
index 0000000000..c0c38df9fb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlTocEncoder.cs
@@ -0,0 +1,55 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal static class JxlTocEncoder
+{
+    public static void WriteTocPermutation(Memory<int> permutation, JxlBitWriter writer)
+    {
+        int nPermutation = permutation.Length;
+
+        _ = writer.WithMaxBits((ulong)JxlToc.MaxBits(0), () =>
+        {
+            if (nPermutation > 0)
+            {
+                writer.Write(1, 1); // permutation present
+                if (!JxlCoefficientOrderEncoder.EncodePermutation(
+                    MemoryMarshal.Cast<int, uint>(permutation.Span),
+                    0,
+                    permutation.Length,
+                    writer))
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                writer.Write(1, 0); // no permutation
+            }
+
+            writer.ZeroPadToByte();
+            return true;
+        });
+    }
+
+    public static void WriteTocSizes(Memory<int> groupSizes, JxlBitWriter writer) =>
+        _ = writer.WithMaxBits((ulong)JxlToc.MaxBits(groupSizes.Length), () =>
+        {
+            Span<int> groupSizesSpan = groupSizes.Span;
+
+            for (int i = 0; i < groupSizesSpan.Length; i++)
+            {
+                if (!JxlU32Coder.Write(in JxlToc.TocDistribution, unchecked((uint)groupSizesSpan[i]), writer))
+                {
+                    return false;
+                }
+            }
+
+            writer.ZeroPadToByte();
+            return true;
+        });
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlTransformsEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlTransformsEncoder.cs
new file mode 100644
index 0000000000..f3565a75d9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlTransformsEncoder.cs
@@ -0,0 +1,8 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal static class JxlTransformsEncoder
+{
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlXybEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlXybEncoder.cs
new file mode 100644
index 0000000000..037eb46c1f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/JxlXybEncoder.cs
@@ -0,0 +1,466 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Numerics.Tensors;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.Cms.TransferFunctions;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+internal static class JxlXybEncoder
+{
+    private static void OpsinAbsorbance(
+        Vector<float> r,
+        Vector<float> g,
+        Vector<float> b,
+        ReadOnlySpan<float> premulAbsorb,
+        out Vector<float> mixed0,
+        out Vector<float> mixed1,
+        out Vector<float> mixed2)
+    {
+        ReadOnlySpan<float> bias = JxlOpsinConstants.OpsinAbsorbanceBias;
+
+        mixed0 = Vector.FusedMultiplyAdd(
+            Vector.Create(premulAbsorb),
+            r,
+            Vector.FusedMultiplyAdd(
+                Vector.Create(premulAbsorb[8..]),
+                g,
+                Vector.FusedMultiplyAdd(
+                    Vector.Create(premulAbsorb[16..]),
+                    b,
+                    Vector.Create(bias[0]))));
+
+        mixed1 = Vector.FusedMultiplyAdd(
+            Vector.Create(premulAbsorb[24..]),
+            r,
+            Vector.FusedMultiplyAdd(
+                Vector.Create(premulAbsorb[32..]),
+                g,
+                Vector.FusedMultiplyAdd(
+                    Vector.Create(premulAbsorb[40..]),
+                    b,
+                    Vector.Create(bias[1]))));
+
+        mixed2 = Vector.FusedMultiplyAdd(
+            Vector.Create(premulAbsorb[48..]),
+            r,
+            Vector.FusedMultiplyAdd(
+                Vector.Create(premulAbsorb[56..]),
+                g,
+                Vector.FusedMultiplyAdd(
+                    Vector.Create(premulAbsorb[64..]),
+                    b,
+                    Vector.Create(bias[2]))));
+    }
+
+    private static void StoreXYB(
+        Vector<float> r,
+        Vector<float> g,
+        Vector<float> b,
+        Span<float> valX,
+        Span<float> valY,
+        Span<float> valZ)
+    {
+        Vector<float> half = Vector.Create(0.5f);
+
+        (half * (r - g)).CopyTo(valX);
+        (half * (r + g)).CopyTo(valY);
+        b.CopyTo(valZ);
+    }
+
+    private static void LinearRgbToXyb(
+        Vector<float> r,
+        Vector<float> g,
+        Vector<float> b,
+        ReadOnlySpan<float> premulAbsorb,
+        Span<float> valX,
+        Span<float> valY,
+        Span<float> valZ)
+    {
+        OpsinAbsorbance(
+            r,
+            g,
+            b,
+            premulAbsorb,
+            out Vector<float> mixed0,
+            out Vector<float> mixed1,
+            out Vector<float> mixed2);
+
+        mixed0 = ZeroIfNegative(mixed0);
+        mixed1 = ZeroIfNegative(mixed1);
+        mixed2 = ZeroIfNegative(mixed2);
+
+        int n = Vector<float>.Count;
+
+        mixed0 = CubeRootAndAdd(
+            mixed0,
+            Vector.Create(premulAbsorb[(9 * n)..]));
+
+        mixed1 = CubeRootAndAdd(
+            mixed1,
+            Vector.Create(premulAbsorb[(10 * n)..]));
+
+        mixed2 = CubeRootAndAdd(
+            mixed2,
+            Vector.Create(premulAbsorb[(11 * n)..]));
+
+        StoreXYB(mixed0, mixed1, mixed2, valX, valY, valZ);
+    }
+
+    public static void LinearRgbRowToXyb(
+        Span<float> row0,
+        Span<float> row1,
+        Span<float> row2,
+        ReadOnlySpan<float> premulAbsorb,
+        int xSize)
+    {
+        int n = Vector<float>.Count;
+
+        for (int x = 0; x < xSize; x += n)
+        {
+            Vector<float> r = Vector.Create<float>(row0[x..]);
+            Vector<float> g = Vector.Create<float>(row1[x..]);
+            Vector<float> b = Vector.Create<float>(row2[x..]);
+
+            LinearRgbToXyb(
+                r,
+                g,
+                b,
+                premulAbsorb,
+                row0[x..],
+                row1[x..],
+                row2[x..]);
+        }
+    }
+
+    private static Vector<float> CubeRootAndAdd(Vector<float> v, Vector<float> add)
+    {
+        // HACK: Vector<T> doesn't support cuberoot
+        Span<float> span = stackalloc float[Vector<float>.Count];
+        v.StoreUnsafe(ref MemoryMarshal.GetReference(span));
+        TensorPrimitives.Cbrt(span, span);
+        return Vector.LoadUnsafe(ref MemoryMarshal.GetReference(span)) + add;
+    }
+
+    private static Vector<float> ZeroIfNegative(Vector<float> v) =>
+        Vector.ConditionalSelect(
+            Vector.LessThan(v, Vector<float>.Zero),
+            Vector<float>.Zero,
+            v);
+
+    private static Vector<float> LinearFromSRgb(Vector<float> encoded)
+        => JxlSRgbTransferFunction.DisplayFromEncoded(encoded);
+
+    private static void LinearSrgbToXyb(
+        Configuration configuration,
+        Memory<float> premulAbsorb,
+        JxlImage3F image)
+    {
+        int xSize = image.Width;
+
+        void ProcessRow(int y, ReadOnlySpan<float> premulAbsorb)
+        {
+            Span<float> row0 = image.PlaneRow(0, y);
+            Span<float> row1 = image.PlaneRow(1, y);
+            Span<float> row2 = image.PlaneRow(2, y);
+
+            int lanes = Vector<float>.Count;
+
+            for (int x = 0; x < xSize; x += lanes)
+            {
+                Vector<float> r = new(row0[x..]);
+                Vector<float> g = new(row1[x..]);
+                Vector<float> b = new(row2[x..]);
+
+                LinearRgbToXyb(
+                    r,
+                    g,
+                    b,
+                    premulAbsorb,
+                    row0[x..],
+                    row1[x..],
+                    row2[x..]);
+            }
+        }
+
+        _ = Parallel.For(0, image.Height, configuration.GetParallelOptions(), x =>
+        {
+            ProcessRow(x, premulAbsorb.Span);
+        });
+    }
+
+    private static void SRgbToXyb(
+        Configuration configuration,
+        Memory<float> premulAbsorb,
+        JxlImage3F image)
+    {
+        int xSize = image.Width;
+
+        void ProcessRow(int y, ReadOnlySpan<float> premulAbsorb)
+        {
+            Span<float> row0 = image.PlaneRow(0, y);
+            Span<float> row1 = image.PlaneRow(1, y);
+            Span<float> row2 = image.PlaneRow(2, y);
+
+            int lanes = Vector<float>.Count;
+
+            for (int x = 0; x < xSize; x += lanes)
+            {
+                Vector<float> r = LinearFromSRgb(new Vector<float>(row0[x..]));
+                Vector<float> g = LinearFromSRgb(new Vector<float>(row1[x..]));
+                Vector<float> b = LinearFromSRgb(new Vector<float>(row2[x..]));
+
+                LinearRgbToXyb(
+                    r,
+                    g,
+                    b,
+                    premulAbsorb,
+                    row0[x..],
+                    row1[x..],
+                    row2[x..]);
+            }
+        }
+
+        _ = Parallel.For(0, image.Height, configuration.GetParallelOptions(), x =>
+        {
+            ProcessRow(x, premulAbsorb.Span);
+        });
+    }
+
+    private static void SrgbToXybAndLinear(
+        Configuration configuration,
+        Memory<float> premulAbsorb,
+        JxlImage3F image,
+        JxlImage3F linear)
+    {
+        int xSize = image.Width;
+
+        void ProcessRow(int y, ReadOnlySpan<float> premulAbsorb)
+        {
+            Span<float> rowImage0 = image.PlaneRow(0, y);
+            Span<float> rowImage1 = image.PlaneRow(1, y);
+            Span<float> rowImage2 = image.PlaneRow(2, y);
+
+            Span<float> rowLinear0 = linear.PlaneRow(0, y);
+            Span<float> rowLinear1 = linear.PlaneRow(1, y);
+            Span<float> rowLinear2 = linear.PlaneRow(2, y);
+
+            int lanes = Vector<float>.Count;
+
+            for (int x = 0; x < xSize; x += lanes)
+            {
+                Vector<float> r = LinearFromSRgb(new Vector<float>(rowImage0[x..]));
+                Vector<float> g = LinearFromSRgb(new Vector<float>(rowImage1[x..]));
+                Vector<float> b = LinearFromSRgb(new Vector<float>(rowImage2[x..]));
+
+                r.CopyTo(rowLinear0[x..]);
+                g.CopyTo(rowLinear1[x..]);
+                b.CopyTo(rowLinear2[x..]);
+
+                LinearRgbToXyb(
+                    r,
+                    g,
+                    b,
+                    premulAbsorb,
+                    rowImage0[x..],
+                    rowImage1[x..],
+                    rowImage2[x..]);
+            }
+        }
+
+        _ = Parallel.For(0, image.Height, configuration.GetParallelOptions(), x =>
+        {
+            ProcessRow(x, premulAbsorb.Span);
+        });
+    }
+
+    private static void ComputePremulAbsorb(float intensityTarget, Span<float> premulAbsorb)
+    {
+        float mul = intensityTarget / 255.0f;
+        int lanes = Vector<float>.Count;
+
+        for (int j = 0; j < 3; j++)
+        {
+            for (int i = 0; i < 3; i++)
+            {
+                float absorb = JxlOpsinAbsorbanceMatrix[j][i] * mul;
+
+                premulAbsorb
+                    .Slice(((j * 3) + i) * lanes, lanes)
+                    .Fill(absorb);
+            }
+        }
+
+        for (int i = 0; i < 3; i++)
+        {
+            float negBiasCbrt = -MathF.Cbrt(JxlOpsinAbsorbanceBias[i]);
+
+            premulAbsorb
+                .Slice((9 + i) * lanes, lanes)
+                .Fill(negBiasCbrt);
+        }
+    }
+
+    public static bool ToXyb(
+        Configuration configuration,
+        JxlColorEncoding currentEncoding,
+        float intensityTarget,
+        JxlImageF? black,
+        JxlImage3F image,
+        JxlCmsInterface cms,
+        JxlImage3F? linear)
+    {
+        if (black is not null)
+        {
+            if (image.GetRectangle() != black.GetRectangle())
+            {
+                return false;
+            }
+        }
+
+        if (linear is not null)
+        {
+            if (image.GetRectangle() != linear.GetRectangle())
+            {
+                return false;
+            }
+        }
+
+        int lanes = Vector<float>.Count;
+
+        Memory<float> premulAbsorb = new float[lanes * 12];
+        ComputePremulAbsorb(intensityTarget, premulAbsorb.Span);
+
+        bool wantLinear = linear is not null;
+
+        JxlColorEncoding linearSrgb = JxlColorEncoding.LinearSRgb(currentEncoding.IsGray);
+
+        if (linearSrgb.SameColorEncoding(currentEncoding))
+        {
+            if (wantLinear)
+            {
+                JxlImageOperations.CopyImageTo(image, linear!);
+            }
+
+            LinearSrgbToXyb(configuration, premulAbsorb, image);
+            return true;
+        }
+
+        if (currentEncoding.IsSRgb)
+        {
+            if (wantLinear)
+            {
+                SrgbToXybAndLinear(configuration, premulAbsorb, image, linear!);
+                return true;
+            }
+
+            SRgbToXyb(configuration, premulAbsorb, image);
+            return true;
+        }
+
+        // TODO
+        ApplyColorTransform(
+            configuration,
+            currentEncoding,
+            intensityTarget,
+            image,
+            black,
+            image.GetRectangle(),
+            linearSrgb,
+            cms,
+            wantLinear ? linear! : image);
+
+        if (wantLinear)
+        {
+            JxlImageOperations.CopyImageTo(linear!, image);
+        }
+
+        LinearSrgbToXyb(configuration, premulAbsorb, image);
+        return true;
+    }
+
+    public static void RgbToYcbcr(
+        Configuration configuration,
+        JxlImageF rPlane,
+        JxlImageF gPlane,
+        JxlImageF bPlane,
+        JxlImageF yPlane,
+        JxlImageF cbPlane,
+        JxlImageF crPlane)
+    {
+        int xSize = rPlane.Width;
+        int ySize = rPlane.Height;
+
+        if (xSize == 0 || ySize == 0)
+        {
+            return;
+        }
+
+        Vector<float> k128 = new(128.0f / 255);
+        Vector<float> kR = new(0.299f);
+        Vector<float> kG = new(0.587f);
+        Vector<float> kB = new(0.114f);
+        Vector<float> kAmpR = new(0.701f);
+        Vector<float> kAmpB = new(0.886f);
+
+        Vector<float> kDiffR = kAmpR + kR;
+        Vector<float> kDiffB = kAmpB + kB;
+
+        Vector<float> kNormR = Vector<float>.One / (kAmpR + kG + kB);
+        Vector<float> kNormB = Vector<float>.One / (kR + kG + kAmpB);
+
+        int step = Vector<float>.Count;
+
+        int groupArea = JxlFrameDimensions.GroupDimensions * JxlFrameDimensions.GroupDimensions;
+        int linesPerGroup = JxlMath.DivCeil(groupArea, xSize);
+        int numStripes = JxlMath.DivCeil(ySize, linesPerGroup);
+
+        void Transform(int index)
+        {
+            int y0 = index * linesPerGroup;
+            int y1 = Math.Min(y0 + linesPerGroup, ySize);
+
+            for (int y = y0; y < y1; y++)
+            {
+                ReadOnlySpan<float> rRow = rPlane.GetRow(y);
+                ReadOnlySpan<float> gRow = gPlane.GetRow(y);
+                ReadOnlySpan<float> bRow = bPlane.GetRow(y);
+
+                Span<float> yRow = yPlane.GetRow(y);
+                Span<float> cbRow = cbPlane.GetRow(y);
+                Span<float> crRow = crPlane.GetRow(y);
+
+                for (int x = 0; x < xSize; x += step)
+                {
+                    Vector<float> r = new(rRow[x..]);
+                    Vector<float> g = new(gRow[x..]);
+                    Vector<float> b = new(bRow[x..]);
+
+                    Vector<float> rBase = r * kR;
+                    Vector<float> rDiff = r * kDiffR;
+                    Vector<float> gBase = g * kG;
+                    Vector<float> bBase = b * kB;
+                    Vector<float> bDiff = b * kDiffB;
+
+                    Vector<float> yBase = rBase + gBase + bBase;
+                    Vector<float> yVec = yBase - k128;
+                    Vector<float> cbVec = (bDiff - yBase) * kNormB;
+                    Vector<float> crVec = (rDiff - yBase) * kNormR;
+
+                    yVec.CopyTo(yRow[x..]);
+                    cbVec.CopyTo(cbRow[x..]);
+                    crVec.CopyTo(crRow[x..]);
+                }
+            }
+        }
+
+        _ = Parallel.For(0, numStripes, configuration.GetParallelOptions(), Transform);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlLossFunction.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlLossFunction.cs
new file mode 100644
index 0000000000..e338862bb0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlLossFunction.cs
@@ -0,0 +1,63 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Noise;
+
+internal sealed class JxlLossFunction(ReadOnlyMemory<JxlNoiseLevel> noiseLevels)
+{
+    public double Compute(Span<double> w, Span<double> df, bool skipRegularization = false)
+    {
+        const double reg = 0.005;
+        const double asym = 1.1;
+
+        double lossFunction = 0;
+
+        w.Clear();
+
+        ReadOnlySpan<JxlNoiseLevel> levels = noiseLevels.Span;
+
+        for (int i = 0; i < levels.Length; i++)
+        {
+            JxlNoiseLevel nl = levels[i];
+
+            JxlNoiseIndexAndFraction pos = JxlNoiseHelper.IndexAndFraction(nl.Intensity);
+
+            double low = w[pos.Index];
+            double hi = w[pos.Index + 1];
+            double val = (low * (1.0f - pos.Fraction)) + (hi * pos.Fraction);
+            double dist = val - nl.NoiseLevel;
+
+            if (dist > 0)
+            {
+                lossFunction += asym * dist * dist;
+                df[pos.Index] -= asym * (1.0f - pos.Fraction) * dist;
+                df[pos.Index + 1] -= asym * pos.Fraction * dist;
+            }
+            else
+            {
+                lossFunction += dist * dist;
+                df[pos.Index] -= (1.0f - pos.Fraction) * dist;
+                df[pos.Index + 1] -= pos.Fraction * dist;
+            }
+        }
+
+        if (skipRegularization)
+        {
+            return lossFunction;
+        }
+
+        int levelsSize = levels.Length;
+
+        for (int i = 0; i + 1 < w.Length; i++)
+        {
+            double diff = w[i] - w[i + 1];
+            lossFunction += reg * levelsSize * diff * diff;
+            df[i] -= reg * diff * levelsSize;
+            df[i + 1] += reg * diff * levelsSize;
+        }
+
+        return lossFunction;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlNoiseEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlNoiseEncoder.cs
new file mode 100644
index 0000000000..026ee73f2f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlNoiseEncoder.cs
@@ -0,0 +1,66 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Numerics.Tensors;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Noise;
+
+/// <summary>
+/// Noise functions for encoder.
+/// </summary>
+internal static class JxlNoiseEncoder
+{
+    public static float GetScoreSumsOfAbsoluteDifferences(JxlImage3F opsin, int x, int y, int blockSize)
+    {
+        const int smallBlockSizeX = 3;
+        const int smallBlockSizeY = 4;
+
+        int numSAD = (blockSize - smallBlockSizeX) * (blockSize - smallBlockSizeY);
+        int counter = 0;
+        const int offset = 2;
+
+        float[]? pooled = null;
+
+        Span<float> sad = numSAD <= 128
+            ? stackalloc float[128].Slice(0, numSAD)
+            : pooled = ArrayPool<float>.Shared.Rent(numSAD);
+
+        for (int yBl = 0; yBl + smallBlockSizeY < blockSize; ++yBl)
+        {
+            for (int xBl = 0; xBl + smallBlockSizeX < blockSize; ++xBl)
+            {
+                float sadSum = 0;
+
+                for (int cy = 0; cy < smallBlockSizeY; ++cy)
+                {
+                    for (int cx = 0; cx < smallBlockSizeX; ++cx)
+                    {
+                        float wnd = 0.5f * (opsin.PlaneRow(1, y + yBl + cy)[x + xBl + cx] + opsin.PlaneRow(0, y + yBl + cy)[x + xBl + cx]);
+                        float center = 0.5f * (opsin.PlaneRow(1, y + offset + cy)[x + offset + cx] + opsin.PlaneRow(0, y + offset + cy)[x + offset + cx]);
+                        sadSum += MathF.Abs(center - wnd);
+                    }
+                }
+
+                sad[counter++] = sadSum;
+            }
+        }
+
+        int samples = numSAD / 2;
+
+        // As with ROAD (rank order absolute distance), we keep the smallest half of
+        // the values in SAD (we use here the more robust patch SAD instead of
+        // absolute single-pixel differences).
+        sad.Sort();
+
+        float totalSadSum = TensorPrimitives.Sum(sad);
+
+        if (pooled is not null)
+        {
+            ArrayPool<float>.Shared.Return(pooled);
+        }
+
+        return totalSadSum / samples;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlNoiseHistogram.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlNoiseHistogram.cs
new file mode 100644
index 0000000000..396021a55d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlNoiseHistogram.cs
@@ -0,0 +1,84 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics.Tensors;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Noise;
+
+internal sealed class JxlNoiseHistogram
+{
+    private const int Bins = 256;
+
+    private readonly uint[] bins = new uint[Bins];
+
+    public int Mode
+    {
+        get
+        {
+            int maxIdx = 0;
+
+            for (int i = 0; i < Bins; i++)
+            {
+                if (this.bins[i] > this.bins[maxIdx])
+                {
+                    maxIdx = i;
+                }
+            }
+
+            return maxIdx;
+        }
+    }
+
+    /// <summary>
+    /// Gets the Inter-quartile range.
+    /// </summary>
+    public double Iqr => this.Quantile(0.75) - this.Quantile(0.25);
+
+    public void Increment(float x) => this.bins[Index(x)]++;
+
+    public uint Get(float x) => this.bins[Index(x)];
+
+    public uint Bin(int bin) => this.bins[bin];
+
+    public double Quantile(double q01)
+    {
+        long total = 1 + TensorPrimitives.Sum((ReadOnlySpan<uint>)this.bins.AsSpan());
+        long target = (long)q01 * total;
+        long sum = 0;
+        int i = 0;
+
+        for (; i < Bins; i++)
+        {
+            sum += this.bins[i];
+
+            if (sum == target)
+            {
+                return i + 0.5;
+            }
+
+            if (sum > target)
+            {
+                break;
+            }
+        }
+
+        int next = i + 1;
+
+        while ((uint)next < this.bins.Length && this.bins[next] == 0)
+        {
+            next++;
+        }
+
+        double excess = target - sum;
+        double weightNext = this.bins[Index(next)] / excess;
+
+        return ClampX((next * weightNext) + (i * (1.0 - weightNext)));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static double ClampX(double x) => Math.Clamp(x, 0, Bins - 1);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Index(float x) => (int)ClampX((int)x);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlPhotonNoise.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlPhotonNoise.cs
new file mode 100644
index 0000000000..ce48a39e32
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Noise/JxlPhotonNoise.cs
@@ -0,0 +1,60 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Noise;
+
+internal static class JxlPhotonNoise
+{
+    /// <summary>
+    /// Assumes a daylight-like spectrum.
+    /// </summary>
+    private const float PhotonsPerLxSPerUm2 = 11260;
+
+    /// <summary>
+    /// Order of magnitude for cameras in the 2010-2020 decade,
+    /// taking the CFA into account.
+    /// </summary>
+    private const float EffectiveQuantumEfficiency = 0.20f;
+
+    private const float PhotoResponseNonUniformity = 0.005f;
+
+    private const float InputReferredReadNoise = 3;
+
+    private const float SensorAreaUm2 = 36000f * 24000;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float Square(float x) => x * x;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float Cube(float x) => x * x * x;
+
+    public static JxlNoiseParameters SimulatePhotonNoise(int xSize, int ySize, float iso)
+    {
+        float opsinAbsorbanceBiasCbrt = MathF.Cbrt(JxlOpsinConstants.OpsinAbsorbanceBias1);
+        float h18 = 10f / iso;
+        float pixelAreaUm2 = SensorAreaUm2 / (xSize * ySize);
+        float electronsPerPixel18 = EffectiveQuantumEfficiency * PhotonsPerLxSPerUm2 * h18 * pixelAreaUm2;
+        JxlNoiseParameters parameters = new();
+        Span<float> lookup = parameters.Lookup; // Faster than float[]
+
+        for (int i = 0; i < JxlNoiseParameters.NoisePoints; ++i)
+        {
+            float scaledIndex = i / (JxlNoiseParameters.NoisePoints - 2f);
+            float y = 2 * scaledIndex;
+            float linear = MathF.Max(0f, Cube(y - opsinAbsorbanceBiasCbrt) + JxlOpsinConstants.OpsinAbsorbanceBias1);
+            float electronsPerPixel = electronsPerPixel18 * (linear / 0.18f);
+            float noise = MathF.Sqrt(Square(InputReferredReadNoise) + electronsPerPixel + Square(PhotoResponseNonUniformity * electronsPerPixel));
+            float linearNoise = noise * (0.18f / electronsPerPixel18);
+            float opsinDerivative = (1f / 3) / Square(MathF.Sqrt(linear - JxlOpsinConstants.OpsinAbsorbanceBias1));
+            float opsinNoise = linearNoise * opsinDerivative;
+
+            lookup[i] = Math.Clamp(opsinNoise / (0.22f * MathF.Sqrt(2f) * 1.13f), 0f, JxlNoiseConstants.NoiseLutMax);
+        }
+
+        return parameters;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeArrayFactory{T}.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeArrayFactory{T}.cs
new file mode 100644
index 0000000000..8b14fad0d4
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeArrayFactory{T}.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Optimize;
+
+internal class JxlOptimizeArrayFactory<T>(Configuration configuration, int length)
+    where T : unmanaged, INumber<T>
+{
+    public JxlOptimizeArray<T> CreateArray(T defaultValue = default) => new(configuration, length, defaultValue);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeArray{T}.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeArray{T}.cs
new file mode 100644
index 0000000000..2a89b1cd4b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeArray{T}.cs
@@ -0,0 +1,204 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Numerics;
+using System.Numerics.Tensors;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Optimize;
+
+internal struct JxlOptimizeArray<T> : IDisposable
+    where T : unmanaged, INumber<T>
+{
+    private readonly IMemoryOwner<T> memoryOwner;
+    private readonly int length;
+    private readonly Configuration configuration;
+    private bool isDisposed;
+
+    public JxlOptimizeArray(Configuration configuration, int length, T value)
+    {
+        this.memoryOwner = configuration.MemoryAllocator.Allocate<T>(length);
+        this.memoryOwner.Memory.Span.Fill(value);
+        this.length = length;
+        this.configuration = configuration;
+    }
+
+    public readonly Span<T> Span => this.memoryOwner.Memory.Span;
+
+    public readonly ref T this[int index]
+    {
+        get
+        {
+            DebugGuard.MustBeLessThan(index, this.length, nameof(index));
+            return ref this.memoryOwner.Memory.Span[index];
+        }
+    }
+
+    public static JxlOptimizeArray<T> operator +(JxlOptimizeArray<T> a, JxlOptimizeArray<T> b)
+    {
+        JxlOptimizeArray<T> z = new(a.configuration, a.length, default);
+        TensorPrimitives.Add(a.Span, b.Span, z.Span);
+        return z;
+    }
+
+    public static JxlOptimizeArray<T> operator -(JxlOptimizeArray<T> a, JxlOptimizeArray<T> b)
+    {
+        JxlOptimizeArray<T> z = new(a.configuration, a.length, default);
+        TensorPrimitives.Subtract(a.Span, b.Span, z.Span);
+        return z;
+    }
+
+    public static JxlOptimizeArray<T> operator *(T a, JxlOptimizeArray<T> b)
+    {
+        JxlOptimizeArray<T> z = new(b.configuration, b.length, default);
+        TensorPrimitives.Multiply(b.Span, a, z.Span);
+        return z;
+    }
+
+    public readonly T DotProduct(JxlOptimizeArray<T> y) => TensorPrimitives.Dot<T>(this.Span, y.Span);
+
+    public static JxlOptimizeArray<T> OptimizeWithScaledConjugateGradientMethod<T>(
+        JxlOptimizeArrayFactory<T> factory,
+        JxlOptimizeFunction<T> function,
+        JxlOptimizeArray<T> w0,
+        T gradientNormalThreshold,
+        int maxIterations)
+        where T : unmanaged, INumber<T>,
+                            IBinaryFloatingPointIeee754<T>
+    {
+        // These variable names look cryptic, but they're part of
+        // the Scaled Conjugate Gradient method. See the reference
+        // implementation:
+        //    https://github.com/libjxl/libjxl/blob/main/lib/jxl/enc_optimize.h#L81-L188
+        int n = w0.length;
+        T rsqThreshold = gradientNormalThreshold * gradientNormalThreshold;
+
+        T sigma0 = T.CreateSaturating(0.0001);
+        T lMin = T.CreateSaturating(1.0e-15);
+        T lMax = T.CreateSaturating(1.0e15);
+
+        JxlOptimizeArray<T> w = w0;
+
+        JxlOptimizeArray<T> wp = factory.CreateArray();
+        JxlOptimizeArray<T> r = factory.CreateArray();
+        JxlOptimizeArray<T> rt = factory.CreateArray();
+        JxlOptimizeArray<T> e = factory.CreateArray();
+        JxlOptimizeArray<T> p = factory.CreateArray();
+
+        T psq = default;
+        T fp;
+        T D = default;
+        T d;
+        T m = default;
+        T a;
+        T b;
+        T s;
+        T t = default;
+
+        T fw = function(w, ref r);
+        T rsq = r.DotProduct(r);
+        e = r;
+        p = r;
+
+        T l = T.CreateSaturating(1.0);
+        bool success = true;
+        long nSuccess = 0;
+        long k = 0;
+
+        // Hot loop
+        while (k++ < maxIterations)
+        {
+            if (success)
+            {
+                m = -p.DotProduct(r);
+
+                if (m >= T.Zero)
+                {
+                    p = r;
+                    m = -p.DotProduct(r);
+                }
+
+                psq = p.DotProduct(p);
+                s = sigma0 / T.Sqrt(psq);
+                _ = function(w + (s * p), ref rt);
+                t = p.DotProduct(r - rt) / s;
+            }
+
+            d = t + (l * psq);
+            if (d <= T.Zero)
+            {
+                d = l * psq;
+                l -= t / psq;
+            }
+
+            a = -m / d;
+            wp = w + (a * p);
+            fp = function(wp, ref rt);
+
+            D = T.CreateSaturating(2.0) * (fp - fw) / (a * m);
+            if (D >= T.Zero)
+            {
+                success = true;
+                nSuccess++;
+                w = wp;
+            }
+            else
+            {
+                success = false;
+            }
+
+            if (success)
+            {
+                e = r;
+                r = rt;
+                rsq = r.DotProduct(r);
+                fw = fp;
+
+                if (rsq <= rsqThreshold)
+                {
+                    break;
+                }
+            }
+
+            if (D < T.CreateSaturating(0.25))
+            {
+                l = T.Min(T.CreateSaturating(4) * l, lMax);
+            }
+            else if (D > T.CreateSaturating(0.75))
+            {
+                l = T.Max(T.CreateSaturating(0.25) * l, lMax);
+            }
+
+            if ((nSuccess % n) == 0)
+            {
+                p = r;
+                l = T.CreateSaturating(1.0);
+            }
+            else if (success)
+            {
+                b = (e - r).DotProduct(r) / m;
+                p = (b * p) + r;
+            }
+        }
+
+        // clean up
+        wp.Dispose();
+        r.Dispose();
+        rt.Dispose();
+        e.Dispose();
+        p.Dispose();
+
+        return w;
+    }
+
+    public void Dispose()
+    {
+        if (this.isDisposed)
+        {
+            return;
+        }
+
+        this.isDisposed = true;
+        this.memoryOwner.Dispose();
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeFunction{T}.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeFunction{T}.cs
new file mode 100644
index 0000000000..be9533b148
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/Optimize/JxlOptimizeFunction{T}.cs
@@ -0,0 +1,9 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Optimize;
+
+internal delegate T JxlOptimizeFunction<T>(JxlOptimizeArray<T> a, ref JxlOptimizeArray<T> b)
+    where T : unmanaged, INumber<T>;
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlPassDefinition.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlPassDefinition.cs
new file mode 100644
index 0000000000..6186784ce5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlPassDefinition.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.ProgressiveSplit;
+
+internal struct JxlPassDefinition
+{
+    public JxlPassDefinition(int numCoefficients, int shift, int suitableForDownsamplingOfAtLeast)
+    {
+        this.NumCoefficients = numCoefficients;
+        this.Shift = shift;
+        this.SuitableForDownsamplingOfAtLeast = suitableForDownsamplingOfAtLeast;
+    }
+
+    /// <summary>
+    /// Gets or sets the side of the square of the coefficients that should be kept in
+    /// each 8x8 block. Must be > 1, and at most 8. Should be in non-decreasing
+    /// order.
+    /// </summary>
+    public int NumCoefficients { get; set; }
+
+    /// <summary>
+    /// Gets or sets how much to shift the encoded values by, with rounding.
+    /// </summary>
+    public int Shift { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value where, if specified indicates that if the required downsampling factor
+    /// is sufficiently high, then it is fine to stop decoding after this pass.
+    /// By default, passes are not marked as being suitable for any downsampling.
+    /// </summary>
+    public int SuitableForDownsamplingOfAtLeast { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlProgressiveMode.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlProgressiveMode.cs
new file mode 100644
index 0000000000..e5bd18da4a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlProgressiveMode.cs
@@ -0,0 +1,54 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.ProgressiveSplit;
+
+internal struct JxlProgressiveMode
+{
+    public int NumPasses = 1;
+    public InlineArray11<JxlPassDefinition> Passes;
+
+    public JxlProgressiveMode()
+    {
+        Span<JxlPassDefinition> passesSpan = this.Passes;
+        JxlPassDefinition definitionToFill = new(numCoefficients: 8, shift: 0, suitableForDownsamplingOfAtLeast: 1);
+        passesSpan.Fill(definitionToFill);
+    }
+
+    public JxlProgressiveMode(Span<JxlPassDefinition> passes)
+    {
+        int nump = passes.Length;
+        DebugGuard.MustBeLessThanOrEqualTo(nump, JxlShared.MaximumNumberOfPasses, nameof(nump));
+
+        this.NumPasses = nump;
+        JxlPassDefinition previousPass = new(1, 0, int.MaxValue);
+        int lastDownsamplingFactor = int.MaxValue;
+
+        for (int i = 0; i < nump; i++)
+        {
+            ref JxlPassDefinition p = ref passes[i];
+
+            if (!(p.NumCoefficients > previousPass.NumCoefficients ||
+                  (p.NumCoefficients == previousPass.NumCoefficients &&
+                   p.Shift < previousPass.Shift)))
+            {
+                throw new InvalidOperationException("The pass is invalid");
+            }
+
+            if (!(p.SuitableForDownsamplingOfAtLeast == int.MaxValue ||
+                  p.SuitableForDownsamplingOfAtLeast <= lastDownsamplingFactor))
+            {
+                throw new InvalidOperationException("The pass is invalid");
+            }
+
+            if (p.SuitableForDownsamplingOfAtLeast != int.MaxValue)
+            {
+                lastDownsamplingFactor = p.SuitableForDownsamplingOfAtLeast;
+            }
+
+            previousPass = passes[i] = p;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlProgressiveSplitter.cs b/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlProgressiveSplitter.cs
new file mode 100644
index 0000000000..bc845d6970
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Encoder/ProgressiveSplit/JxlProgressiveSplitter.cs
@@ -0,0 +1,122 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.ProgressiveSplit;
+
+internal struct JxlProgressiveSplitter
+{
+    private JxlProgressiveMode progressiveMode;
+
+    public void SetProgressiveMode(JxlProgressiveMode mode) => this.progressiveMode = mode;
+
+    public readonly int GetNumPasses() => this.progressiveMode.NumPasses;
+
+    public readonly void InitializePasses(JxlPasses passes)
+    {
+        passes.NumberOfPasses = (uint)this.GetNumPasses();
+        passes.NumberOfDownsamples = 0u;
+
+        if (passes.NumberOfPasses == 0)
+        {
+            throw new InvalidOperationException("At least one pass must be present");
+        }
+
+        passes.Shift[(int)passes.NumberOfPasses - 1] = 0;
+
+        if (passes.NumberOfPasses == 1)
+        {
+            // Done. Arrays are empty.
+            return;
+        }
+
+        for (int i = 0; i < this.progressiveMode.NumPasses - 1; ++i)
+        {
+            int minDownsamplingFactor = this.progressiveMode.Passes[i].SuitableForDownsamplingOfAtLeast;
+            passes.Shift[i] = (uint)this.progressiveMode.Passes[i].Shift;
+
+            if (minDownsamplingFactor is > 1 and not int.MaxValue)
+            {
+                passes.Downsample[(int)passes.NumberOfDownsamples] = (uint)minDownsamplingFactor;
+                passes.LastPass[(int)passes.NumberOfDownsamples] = (uint)i;
+
+                if (this.progressiveMode.Passes[i + 1].SuitableForDownsamplingOfAtLeast < minDownsamplingFactor)
+                {
+                    passes.NumberOfDownsamples++;
+                }
+            }
+        }
+    }
+
+    public readonly void SplitAcCoefficients<T>(Span<T> block, JxlAcStrategy acs, int bx, int by, Span<InlineArray11<T>> output)
+        where T : unmanaged, INumber<T>, IShiftOperators<T, T, T>
+    {
+        int size = acs.CoveredBlocksX * acs.CoveredBlocksY * JxlFrameDimensions.DctBlockSize;
+
+        if (this.progressiveMode.NumPasses == 1)
+        {
+            block.CopyTo(output[0]);
+            return;
+        }
+
+        int nCoeffsAllDoneFromEarlierPasses = 1;
+        int previousPassShift = 0;
+
+        for (int passNumber = 0; passNumber < this.progressiveMode.NumPasses; passNumber++)
+        {
+            MemoryMarshal.Cast<InlineArray11<T>, T>(output[passNumber..]).Slice(0, size).Clear();
+
+            int passShift = this.progressiveMode.Passes[passNumber].Shift;
+            int frameNCoeffs = this.progressiveMode.Passes[passNumber].NumCoefficients;
+            int xsize = acs.CoveredBlocksX;
+            int ysize = acs.CoveredBlocksY;
+
+            JxlForwardCoefficientOrder.CoefficientLayout(ref ysize, ref xsize);
+
+            for (int y = 0; y < ysize * frameNCoeffs; y++)
+            {
+                for (int x = 0; x < xsize * frameNCoeffs; x++)
+                {
+                    int pos = (y * xsize * JxlFrameDimensions.BlockDimensions) + x;
+
+                    if (x < xsize * nCoeffsAllDoneFromEarlierPasses && y < ysize * nCoeffsAllDoneFromEarlierPasses)
+                    {
+                        // This coefficient was already included in an earlier pass,
+                        // which included a genuinely smaller set of coefficients.
+                        continue;
+                    }
+
+                    T v = block[pos];
+
+                    if (previousPassShift != 0)
+                    {
+                        T previousV = ShiftRightRound0(v, previousPassShift) * T.CreateSaturating(1 << previousPassShift);
+                        v -= previousV;
+                    }
+
+                    output[passNumber][pos] = ShiftRightRound0(v, passShift);
+                }
+            }
+
+            if (this.progressiveMode.Passes[passNumber].Shift == 0)
+            {
+                nCoeffsAllDoneFromEarlierPasses = frameNCoeffs;
+            }
+
+            previousPassShift = this.progressiveMode.Passes[passNumber].Shift;
+        }
+
+        static T ShiftRightRound0(T v, int shift)
+        {
+            T oneIfNegative = v >> T.CreateSaturating(31);
+            T add = (oneIfNegative << T.CreateSaturating(shift)) - oneIfNegative;
+            return (v + add) >> T.CreateSaturating(shift);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Image/IJxlImageOutput.cs b/src/ImageSharp/Formats/Jxl/Processing/Image/IJxlImageOutput.cs
new file mode 100644
index 0000000000..72d631ff3b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Image/IJxlImageOutput.cs
@@ -0,0 +1,54 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+/// <summary>
+/// Abstracts a way for the codec to output images during decoding.
+/// </summary>
+internal interface IJxlImageOutput : IDisposable
+{
+    /// <summary>
+    /// Gets or sets the pixel format for the output pixels.
+    /// </summary>
+    public JxlPixelFormat PixelFormat { get; set; }
+
+    /// <summary>
+    /// Gets or sets the output bit depth for unsigned data types.
+    /// </summary>
+    public int BitsPerSample { get; set; }
+
+    /// <summary>
+    /// Gets or sets the pixel buffer for image output.
+    /// </summary>
+    public Memory<byte> Buffer { get; set; }
+
+    /// <summary>
+    /// Gets or sets length of a row of image buffer in bytes.
+    /// </summary>
+    public int Stride { get; set; }
+
+    /// <summary>
+    /// Outputs the image.
+    /// </summary>
+    /// <param name="data">Data where the image should be output.</param>
+    /// <param name="x">X offset</param>
+    /// <param name="y">Y offset</param>
+    /// <param name="pixels">Pixels to output.</param>
+    public void Output(
+        Span<byte> data,
+        int x,
+        int y,
+        Span<byte> pixels);
+
+    /// <summary>
+    /// Initializes image data.
+    /// </summary>
+    /// <param name="data">Output image data.</param>
+    /// <param name="numPixelsPerThread">Number of pixels a thread processes.</param>
+    public void Initialize(
+        Span<byte> data,
+        int numPixelsPerThread);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageBundle.cs b/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageBundle.cs
new file mode 100644
index 0000000000..b4ca42d788
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageBundle.cs
@@ -0,0 +1,507 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Jpeg.Data;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+/// <summary>
+/// An image bundle.
+/// </summary>
+internal sealed class JxlImageBundle
+{
+    /// <summary>
+    /// Image data for additional channels.
+    /// </summary>
+    private List<JxlImageF> extraChannels = [];
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlImageBundle"/> class.
+    /// </summary>
+    public JxlImageBundle()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlImageBundle"/> class with the specified image metadata.
+    /// </summary>
+    /// <param name="metadata">Initial image metadata.</param>
+    public JxlImageBundle(JxlImageMetadata? metadata) => this.Metadata = metadata;
+
+    /// <summary>
+    /// Gets or sets the optional name of the bundle.
+    /// </summary>
+    public string? Name { get; set; }
+
+    /// <summary>
+    /// Gets or sets the blend mode. Default is Blend.
+    /// </summary>
+    public JxlBlendMode BlendMode { get; set; } = JxlBlendMode.Blend;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether blending should be done. (Default: false)
+    /// </summary>
+    public bool Blend { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether this a reference frame.
+    /// </summary>
+    public bool UseForNextFrame { get; set; }
+
+    /// <summary>
+    /// Gets or sets the duration for animation.
+    /// </summary>
+    public uint Duration { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timecode for animation.
+    /// </summary>
+    public uint Timecode { get; set; }
+
+    /// <summary>
+    /// Gets or sets the frame origin.
+    /// </summary>
+    public Point Origin { get; set; }
+
+    /// <summary>
+    /// Gets or sets the chroma subsampling for Y'Cb'Cr images.
+    /// </summary>
+    public JxlYCbCrChromaSubsampling? ChromaSubsampling { get; set; }
+
+    /// <summary>
+    /// Gets or sets the color transform mode for this image, the default is None.
+    /// </summary>
+    public JxlColorTransform ColorTransform { get; set; } = JxlColorTransform.None;
+
+    /// <summary>
+    /// Gets or sets the JPEG data if the input image was converted to JPEG XL from a JPEG.
+    /// </summary>
+    public JpegData? JpegData { get; set; }
+
+    /// <summary>
+    /// Gets a value indicating whether returns the image does or will represent quantized DCT-8 coefficients
+    /// stored in the 8x8 pixel regions.
+    /// </summary>
+    public bool IsJpeg => this.JpegData is not null;
+
+    /// <summary>
+    /// Gets or sets the number of bytes that were actually read.
+    /// </summary>
+    public long DecodedBytes { get; set; }
+
+    /// <summary>
+    /// Gets a value indicating whether the black extra channel is present.
+    /// </summary>
+    public bool ContainsBlack => this.Metadata?.FindExtraChannel(JxlExtraChannel.Black) is not null;
+
+    /// <summary>
+    /// Gets a value indicating whether the alpha extra channel is present.
+    /// </summary>
+    public bool ContainsAlpha => this.Metadata?.FindExtraChannel(JxlExtraChannel.Alpha) is not null;
+
+    /// <summary>
+    /// Gets a value indicating whether the alpha channel is premultiplied.
+    /// </summary>
+    public bool IsAlphaPremultiplied => this.Metadata?.FindExtraChannel(JxlExtraChannel.Alpha)?.AlphaAssociated == true;
+
+    /// <summary>
+    /// Gets a value indicating whether the color encoding specifies Gray.
+    /// </summary>
+    public bool IsGray => this.CurrentColorEncoding?.IsGray == true;
+
+    /// <summary>
+    /// Gets a value indicating whether the color encoding specifies sRGB.
+    /// </summary>
+    public bool IsSrgb => this.CurrentColorEncoding?.IsSrgb == true;
+
+    /// <summary>
+    /// Gets a value indicating whether the color encoding specifies linear sRGB.
+    /// </summary>
+    public bool IsLinearSrgb => this.CurrentColorEncoding?.IsLinearSrgb == true;
+
+    /// <summary>
+    /// Gets the current color encoding for this image.
+    /// </summary>
+    public JxlColorEncoding? CurrentColorEncoding { get; private set; }
+
+    /// <summary>
+    /// Gets the image metadata for this image bundle.
+    /// </summary>
+    public JxlImageMetadata? Metadata { get; }
+
+    /// <summary>
+    /// Gets the color data.
+    /// </summary>
+    public JxlImage3F? Color { get; private set; }
+
+    /// <summary>
+    /// Gets a value indicating whether the color data is present and usable.
+    /// </summary>
+    public bool HasColor => this.Color?.XSize != 0;
+
+    /// <summary>
+    /// Gets the width.
+    /// </summary>
+    public int XSize
+    {
+        get
+        {
+            if (this.IsJpeg)
+            {
+                return this.JpegData!.Width;
+            }
+
+            if (this.Color?.XSize != 0)
+            {
+                return this.Color!.XSize;
+            }
+
+            return this.extraChannels?.Count > 0 ? 0 : this.extraChannels![0].XSize;
+        }
+    }
+
+    /// <summary>
+    /// Gets the height.
+    /// </summary>
+    public int YSize
+    {
+        get
+        {
+            if (this.IsJpeg)
+            {
+                return this.JpegData!.Height;
+            }
+
+            if (this.Color?.YSize != 0)
+            {
+                return this.Color!.YSize;
+            }
+
+            return this.extraChannels?.Count > 0 ? 0 : this.extraChannels![0].YSize;
+        }
+    }
+
+    /// <summary>
+    /// Gets the black extra channel.
+    /// </summary>
+    public JxlImageF? Black
+    {
+        get
+        {
+            if (!this.ContainsBlack || this.Metadata is null)
+            {
+                return null;
+            }
+
+            int ec = this.Metadata!.FindExtraChannel(JxlExtraChannel.Black) - this.Metadata.ExtraChannelInfo.Data;
+            return this.extraChannels[ec];
+        }
+    }
+
+    /// <summary>
+    /// Gets the alpha extra channel.
+    /// </summary>
+    public JxlImageF? Alpha
+    {
+        get
+        {
+            if (!this.ContainsAlpha || this.Metadata is null)
+            {
+                return null;
+            }
+
+            int ec = this.Metadata!.FindExtraChannel(JxlExtraChannel.Alpha) - this.Metadata.ExtraChannelInfo.Data;
+            return this.extraChannels[ec];
+        }
+    }
+
+    /// <summary>
+    /// Gets the oriented X size.
+    /// </summary>
+    public int OrientedXSize => this.Metadata?.Orientation > 4 ? this.YSize : this.XSize;
+
+    /// <summary>
+    /// Gets the oriented Y size.
+    /// </summary>
+    public int OrientedYSize => this.Metadata?.Orientation > 4 ? this.XSize : this.YSize;
+
+    /// <summary>
+    /// Gets the real bit depth.
+    /// </summary>
+    public uint RealBitDepth => this.Metadata!.BitDepth!.BitsPerSample;
+
+    /// <summary>
+    /// Returns false if the width or height is 0 and any extra channel
+    /// does not match this image bundle's width or height; returns true if
+    /// the sizes are otherwise correct.
+    /// </summary>
+    /// <returns>
+    /// True if the sizes are correct. False if they aren't.
+    /// </returns>
+    public bool VerifySizes()
+    {
+        if (this.ContainsExtraChannels())
+        {
+            int xs = this.XSize;
+            int ys = this.YSize;
+
+            if (xs == 0 || ys == 0)
+            {
+                return false;
+            }
+
+            foreach (JxlImageF ec in this.extraChannels)
+            {
+                if (ec.XSize != xs || ec.YSize != ys)
+                {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Overrides the color encoding for this image bundle.
+    /// </summary>
+    /// <param name="encoding">The new color encoding.</param>
+    public void OverrideProfile(JxlColorEncoding encoding) => this.CurrentColorEncoding = encoding;
+
+    /// <summary>
+    /// If the color data is present, assigns it to <paramref name="color"/> and returns true,
+    /// otherwise returns false and assigns null.
+    /// </summary>
+    /// <param name="color">Output color data.</param>
+    /// <returns>True if color isn't null.</returns>
+    public bool TryGetColor(out JxlImage3F? color)
+    {
+        color = null;
+        if (this.Color is not null)
+        {
+            color = this.Color;
+        }
+
+        return color is not null;
+    }
+
+    /// <summary>
+    /// Removes the color data, replacing it with a new Image3F with 0 as width and height.
+    /// </summary>
+    public void RemoveColor() => this.Color = new JxlImage3F();
+
+    /// <summary>
+    /// Removes all extra channels, if any.
+    /// </summary>
+    public void ClearExtraChannels() => this.extraChannels.Clear();
+
+    /// <summary>
+    /// Returns true if there is at least 1 extra channel.
+    /// </summary>
+    /// <returns>Boolean indicating if extra channels are present.</returns>
+    public bool ContainsExtraChannels() => this.extraChannels.Count > 0;
+
+    /// <summary>
+    /// Returns an enumerable for extra channels.
+    /// </summary>
+    /// <returns>Extra channels enumerable.</returns>
+    public IEnumerable<JxlImageF> EnumerateExtraChannels() => this.extraChannels;
+
+    /// <summary>
+    /// Sets the extra channels.
+    /// </summary>
+    /// <param name="extraChannels">The extra channels.</param>
+    /// <returns>
+    /// True if each plane had width and height greater than 0 and sizes are correct
+    /// after changing the extra channels; false otherwise.
+    /// </returns>
+    public bool TrySetExtraChannels(List<JxlImageF> extraChannels)
+    {
+        foreach (JxlImageF plane in extraChannels)
+        {
+            if (plane.XSize == 0 || plane.YSize == 0)
+            {
+                return false;
+            }
+        }
+
+        this.extraChannels = extraChannels;
+
+        return this.VerifySizes();
+    }
+
+    /// <summary>
+    /// Attempts to set the alpha channel.
+    /// </summary>
+    /// <param name="alpha">The alpha channel to set.</param>
+    /// <returns>True if it was set successfully; false otherwise.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the corresponding extra channel has incorrect info.</exception>
+    public bool TrySetAlpha(JxlImageF alpha)
+    {
+        if (this.Metadata is null)
+        {
+            return false;
+        }
+
+        JxlExtraChannelInfo? eci = this.Metadata!.FindExtraChannel(JxlExtraChannel.Alpha);
+
+        if (eci is null)
+        {
+            return false;
+        }
+
+        if (alpha.XSize == 0 || alpha.YSize == 0)
+        {
+            return false;
+        }
+
+        int eciIndex = this.Metadata.ExtraChannelInfo.Data;
+
+        if (eciIndex != this.extraChannels.Count)
+        {
+            throw new InvalidOperationException("The SetAlpha parameter is incorrect");
+        }
+
+        this.extraChannels.Add(alpha);
+
+        return this.VerifySizes();
+    }
+
+    /// <summary>
+    /// Ensures that the metadata of this image is valid.
+    /// </summary>
+    /// <returns>True if metadata is correct. False if it isn't.</returns>
+    /// <exception cref="InvalidOperationException">Rare.</exception>
+    public bool VerifyMetadata()
+    {
+        if (this.CurrentColorEncoding?.Icc?.IsEmpty == true)
+        {
+            return false;
+        }
+
+        if (this.Metadata?.ColorEncoding?.IsGray != this.IsGray)
+        {
+            return false;
+        }
+
+        if (this.Metadata?.HasAlpha == true)
+        {
+            JxlImageF? img = this.Alpha;
+            if (img?.XSize == 0)
+            {
+                throw new InvalidOperationException("Alpha should not have width equal to 0");
+            }
+        }
+
+        int alphaBits = this.Metadata?.AlphaBits ?? 0;
+
+        if (alphaBits > 32)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Updates the bundle from the sepcified image.
+    /// </summary>
+    /// <param name="color">Color data.</param>
+    /// <param name="current">Current color encoding.</param>
+    /// <returns>True if setting the image succeeded; otherwise false.</returns>
+    public bool SetFromImage(JxlImage3F color, JxlColorEncoding current)
+    {
+        if (color.XSize == 0 || color.YSize == 0)
+        {
+            return false;
+        }
+
+        if (this.Metadata?.ColorEncoding?.IsGray == this.IsGray)
+        {
+            return false;
+        }
+
+        this.Color = color;
+        this.CurrentColorEncoding = current;
+
+        return this.VerifySizes();
+    }
+
+    /// <summary>
+    /// Shrinks this image and all of its extra channels to the specified
+    /// width and height.
+    /// </summary>
+    /// <param name="width">The desired width.</param>
+    /// <param name="height">The desired height.</param>
+    /// <returns>
+    /// If this bundle color data or any of the extra channels
+    /// happens to have a smaller width or height than the specified
+    /// width or height, that is considered expanding, which will immediately
+    /// return false. If this method returns true, all colors and
+    /// extra channels have successfully been shrunk.
+    /// </returns>
+    public bool ShrinkTo(int width, int height)
+    {
+        if (this.HasColor)
+        {
+            if (this.Color?.ShrinkTo(width, height) != true)
+            {
+                return false;
+            }
+        }
+
+        foreach (JxlImageF extraChannel in this.extraChannels)
+        {
+            if (!extraChannel.ShrinkTo(width, height))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Copies this image bundle to a new bundle.
+    /// </summary>
+    /// <param name="configuration">
+    /// A configuration with a memory allocator.
+    /// </param>
+    /// <returns>
+    /// A new copy of this image bundle.
+    /// </returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if some extra channels cannot be copied.
+    /// </exception>
+    public JxlImageBundle Copy(Configuration configuration)
+    {
+        JxlImageBundle copy = new(this.Metadata);
+
+        if (this.Color is not null)
+        {
+            copy.Color = new JxlImage3F(configuration, this.Color.XSize, this.Color.YSize);
+        }
+
+        copy.CurrentColorEncoding = this.CurrentColorEncoding;
+        copy.JpegData = this.JpegData;
+        copy.ColorTransform = this.ColorTransform;
+        copy.ChromaSubsampling = this.ChromaSubsampling;
+
+        foreach (JxlImageF plane in this.extraChannels)
+        {
+            JxlImageF ec = new(configuration, plane.XSize, plane.YSize);
+            if (!JxlImageOperations.CopyImage(plane, ec))
+            {
+                throw new InvalidOperationException("Cannot copy extra channel");
+            }
+
+            copy.extraChannels.Add(ec);
+        }
+
+        return copy;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageFeatures.cs b/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageFeatures.cs
new file mode 100644
index 0000000000..2bbfeb2fdf
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageFeatures.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+/// <summary>
+/// Image features for the JPEG XL passes decoder
+/// </summary>
+internal sealed class JxlImageFeatures
+{
+    /// <summary>
+    /// Gets or sets noise parameters for the passes decoder
+    /// </summary>
+    public JxlNoiseParameters NoiseParameters { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets patch dictionary for the passes decoder
+    /// </summary>
+    public JxlPatchDictionary PatchDictionary { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets splines for the passes decoder
+    /// </summary>
+    public JxlSplines Splines { get; set; } = new();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageOperations.cs b/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageOperations.cs
new file mode 100644
index 0000000000..89badfa498
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Image/JxlImageOperations.cs
@@ -0,0 +1,612 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+/// <summary>
+/// Provides methods for processing 2D views of memory used by the
+/// JPEG XL codec.
+/// </summary>
+internal static class JxlImageOperations
+{
+    /// <summary>
+    /// Returns true if first image has same width and height as the second image.
+    /// </summary>
+    /// <param name="a">First image</param>
+    /// <param name="b">Second image</param>
+    /// <returns>True if width and height is equal.</returns>
+    public static bool SameSize(JxlPlaneBase a, JxlPlaneBase b) => a.XSize == b.XSize && a.YSize == b.YSize;
+
+    /// <summary>
+    /// Returns true if first image has same width and height as the second image.
+    /// </summary>
+    /// <param name="a">First image</param>
+    /// <param name="b">Second image</param>
+    /// <returns>True if width and height is equal.</returns>
+    public static bool SameSize<T>(JxlImage3<T> a, JxlImage3<T> b)
+        where T : unmanaged => a.XSize == b.XSize && a.YSize == b.YSize;
+
+    /// <summary>
+    /// Copies everything from one plane to another.
+    /// </summary>
+    /// <typeparam name="T">The type of planes to copy.</typeparam>
+    /// <param name="from">Source plane (read-only)</param>
+    /// <param name="to">Destination plane (write-only)</param>
+    /// <returns>
+    /// Status of the copy operation
+    /// </returns>
+    public static bool CopyImage<T>(JxlPlane<T> from, JxlPlane<T> to)
+        where T : unmanaged
+    {
+        if (!SameSize(from, to))
+        {
+            return false;
+        }
+
+        if (from.XSize == 0 || from.YSize == 0)
+        {
+            return true;
+        }
+
+        for (int y = 0; y < from.YSize; y++)
+        {
+            Span<T> rowFrom = from.GetRow(y);
+            Span<T> rowTo = to.GetRow(y);
+            rowFrom.CopyTo(rowTo);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Copies everything from one image to another.
+    /// </summary>
+    /// <typeparam name="T">The type of image to copy.</typeparam>
+    /// <param name="from">Source image (read-only)</param>
+    /// <param name="to">Destination image (write-only)</param>
+    /// <returns>
+    /// Status of the copy operation
+    /// </returns>
+    public static bool CopyImage<T>(JxlImage3<T> from, JxlImage3<T> to)
+        where T : unmanaged
+    {
+        if (!SameSize(from, to))
+        {
+            return false;
+        }
+
+        if (from.XSize == 0 || from.YSize == 0)
+        {
+            return true;
+        }
+
+        for (int c = 0; c < 3; c++)
+        {
+            for (int y = 0; y < from.YSize; y++)
+            {
+                Span<T> rowFrom = from.PlaneRow(c, y);
+                Span<T> rowTo = to.PlaneRow(c, y);
+                rowFrom.CopyTo(rowTo);
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Within bounds specified by input rectangles, copies everything from one plane to another.
+    /// </summary>
+    /// <typeparam name="T">The type of planes to copy.</typeparam>
+    /// <param name="rectFrom">Area in the source plane.</param>
+    /// <param name="from">Source plane to copy (read-only)</param>
+    /// <param name="rectTo">Area in the destination plane.</param>
+    /// <param name="to">Destination plane to copy (write-only)</param>
+    /// <returns>
+    /// Status of the copy operation.
+    /// </returns>
+    /// <remarks>
+    /// Rectangles MUST be within plane bounds and both should be same.
+    /// </remarks>
+    public static bool CopyImageTo<T>(Rectangle rectFrom, JxlPlane<T> from, Rectangle rectTo, JxlPlane<T> to)
+        where T : unmanaged
+    {
+        if (rectFrom != rectTo)
+        {
+            return false;
+        }
+
+        if (!from.IsRectangleInside(rectFrom))
+        {
+            return false;
+        }
+
+        if (!to.IsRectangleInside(rectTo))
+        {
+            return false;
+        }
+
+        if (rectFrom.Width == 0)
+        {
+            return true;
+        }
+
+        for (int y = 0; y < rectFrom.Height; y++)
+        {
+            Span<T> rowFrom = from.GetRow(rectFrom, y);
+            Span<T> rowTo = to.GetRow(rectTo, y);
+            rowFrom.CopyTo(rowTo);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Within bounds specified by input rectangles, copies everything within every plane
+    /// from one image to another.
+    /// </summary>
+    /// <typeparam name="T">The type of image to copy.</typeparam>
+    /// <param name="rectFrom">Area in the source image.</param>
+    /// <param name="from">Source image to copy (read-only)</param>
+    /// <param name="rectTo">Area in the destination image.</param>
+    /// <param name="to">Destination image to copy (write-only)</param>
+    /// <returns>
+    /// Status of the copy operation.
+    /// </returns>
+    /// <remarks>
+    /// Rectangles MUST be within image bounds and both should be same.
+    /// </remarks>
+    public static bool CopyImageTo<T>(Rectangle rectFrom, JxlImage3<T> from, Rectangle rectTo, JxlImage3<T> to)
+        where T : unmanaged
+    {
+        if (rectFrom != rectTo)
+        {
+            return false;
+        }
+
+        for (int plane = 0; plane < 3; plane++)
+        {
+            if (!CopyImageTo(rectFrom, from.Plane(plane), rectTo, to.Plane(plane)))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Converts a plane from one type to another within specified bounds and ensures to clamp values if the
+    /// minimum and maximum limits of the result type are lower than the input type (e.g., input is
+    /// <see cref="int"/> and destination is <see cref="byte"/>).
+    /// </summary>
+    /// <typeparam name="TFrom">Type of the source plane</typeparam>
+    /// <typeparam name="TTo">Type of the destination plane</typeparam>
+    /// <param name="rectFrom">The area of the source plane</param>
+    /// <param name="from">The source plane (read-only)</param>
+    /// <param name="rectTo">The area of the destination plane</param>
+    /// <param name="to">The destination plane (write-only)</param>
+    /// <returns>
+    /// Status of the copy operation.
+    /// </returns>
+    public static bool ConvertPlaneAndClamp<TFrom, TTo>(Rectangle rectFrom, JxlPlane<TFrom> from, Rectangle rectTo, JxlPlane<TTo> to)
+        where TFrom : unmanaged, INumber<TFrom>
+        where TTo : unmanaged, INumber<TTo>
+    {
+        if (rectFrom != rectTo)
+        {
+            return false;
+        }
+
+        for (int y = 0; y < rectTo.Height; y++)
+        {
+            Span<TFrom> rowFrom = from.GetRow(rectFrom, y);
+            Span<TTo> rowTo = to.GetRow(rectTo, y);
+
+            for (int x = 0; x < rectTo.Width; x++)
+            {
+                rowTo[x] = TTo.CreateSaturating(rowFrom[x]);
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// <para>
+    ///   Copies an image region from <paramref name="from"/> to <paramref name="to"/>,
+    ///   including up to <paramref name="padding"/> pixels of surrounding source data
+    ///   on each side of the region.
+    /// </para>
+    /// <para>
+    ///   Padding is taken from the neighboring pixels in the source plane and is
+    ///   limited by the source plane boundaries. The destination rectangle is
+    ///   expanded by the same amount to preserve the relative pixel positions.
+    ///   Returns <see langword="false"/> if the destination does not have enough
+    ///   space for the required left or top padding.
+    /// </para>
+    /// </summary>
+    /// <param name="fromRect">The source plane area</param>
+    /// <param name="from">The source plane (read-only)</param>
+    /// <param name="padding">The maximum number of pixels to include around the source region.</param>
+    /// <param name="toRect">The destination plane area.</param>
+    /// <param name="to">The destination place (write-only)</param>
+    /// <returns>
+    /// <see langword="true"/> if the region was copied successfully;
+    /// otherwise, <see langword="false"/> if the destination cannot accommodate
+    /// the required padding.
+    /// </returns>
+    public static bool CopyImageToWithPadding<T>(Rectangle fromRect, JxlPlane<T> from, int padding, Rectangle toRect, JxlPlane<T> to)
+        where T : unmanaged
+    {
+        int xExtra0 = Math.Min(padding, fromRect.X);
+        int xExtra1 = Math.Min(
+            padding,
+            from.XSize - fromRect.X - fromRect.Width);
+
+        int yExtra0 = Math.Min(padding, fromRect.Y);
+        int yExtra1 = Math.Min(
+            padding,
+            from.YSize - fromRect.Y - fromRect.Height);
+
+        if (toRect.X < xExtra0 || toRect.Y < yExtra0)
+        {
+            return false;
+        }
+
+        return CopyImageTo(
+            new Rectangle(
+                fromRect.X - xExtra0,
+                fromRect.Y - yExtra0,
+                fromRect.Width + xExtra0 + xExtra1,
+                fromRect.Height + yExtra0 + yExtra1),
+            from,
+            new Rectangle(
+                toRect.X - xExtra0,
+                toRect.Y - yExtra0,
+                toRect.Width + xExtra0 + xExtra1,
+                toRect.Height + yExtra0 + yExtra1),
+            to);
+    }
+
+    /// <summary>
+    /// Performs linear combination of two grayscale images, and allocates &amp; returns the
+    /// image with the linear combination. The returned image can later be disposed.
+    /// </summary>
+    /// <typeparam name="T">The type of the plane. This type should be numeric as linear combination involves multiplication.</typeparam>
+    /// <param name="configuration">The configuration which includes a memory allocator for the return value.</param>
+    /// <param name="lambda1">The lambda for image 1.</param>
+    /// <param name="image1">The first image.</param>
+    /// <param name="lambda2">The lambda for image 2.</param>
+    /// <param name="image2">The second image.</param>
+    /// <returns>A new image with linear combination, or null if it failed.</returns>
+    public static JxlPlane<T>? LinComb<T>(Configuration configuration, T lambda1, JxlPlane<T> image1, T lambda2, JxlPlane<T> image2)
+        where T : unmanaged, INumber<T>
+    {
+        int xSize = image1.XSize;
+        int ySize = image1.YSize;
+
+        if (xSize != image2.XSize || ySize != image2.YSize)
+        {
+            return null;
+        }
+
+        JxlPlane<T> result = JxlPlane<T>.Create(configuration, xSize, ySize);
+
+        for (int y = 0; y < ySize; y++)
+        {
+            Span<T> row1 = image1.GetRow(y);
+            Span<T> row2 = image2.GetRow(y);
+            Span<T> rowOut = result.GetRow(y);
+
+            for (int x = 0; x < xSize; x++)
+            {
+                rowOut[x] = (lambda1 * row1[x]) + (lambda2 * row2[x]);
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Multiplies all image values by the lambda in-place.
+    /// </summary>
+    /// <typeparam name="T">The type of the plane. Should be numeric.</typeparam>
+    /// <param name="lambda">The lambda for multiplication.</param>
+    /// <param name="image">The image to multiply.</param>
+    public static void ScaleImage<T>(T lambda, JxlPlane<T> image)
+        where T : unmanaged, INumber<T>
+    {
+        for (int y = 0; y < image.YSize; y++)
+        {
+            // TODO: SIMD
+            Span<T> row = image.GetRow(y);
+            for (int x = 0; x < image.XSize; x++)
+            {
+                row[x] = lambda * row[x];
+            }
+        }
+    }
+
+    /// <summary>
+    /// Multiplies all image values within all planes by the lambda in-place.
+    /// </summary>
+    /// <typeparam name="T">The type of the image. Should be numeric.</typeparam>
+    /// <param name="lambda">The lambda for multiplication.</param>
+    /// <param name="image">The image to multiply.</param>
+    public static void ScaleImage<T>(T lambda, JxlImage3<T> image)
+        where T : unmanaged, INumber<T>
+    {
+        for (int plane = 0; plane < 3; plane++)
+        {
+            ScaleImage(lambda, image.Plane(plane));
+        }
+    }
+
+    /// <summary>
+    /// Fills every value in the plane with <paramref name="value"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the plane.</typeparam>
+    /// <param name="value">The value to fill everything with.</param>
+    /// <param name="image">The plane to fill.</param>
+    public static void FillImage<T>(T value, JxlPlane<T> image)
+        where T : unmanaged
+    {
+        for (int y = 0; y < image.YSize; y++)
+        {
+            Span<T> row = image.GetRow(y);
+            row.Fill(value);
+        }
+    }
+
+    /// <summary>
+    /// Fills every value in every plane of the image with <paramref name="value"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the image.</typeparam>
+    /// <param name="value">The value to fill every plane with.</param>
+    /// <param name="image">The image to fill.</param>
+    public static void FillImage<T>(T value, JxlImage3<T> image)
+        where T : unmanaged
+    {
+        FillImage(value, image.Plane(0));
+        FillImage(value, image.Plane(1));
+        FillImage(value, image.Plane(2));
+    }
+
+    /// <summary>
+    /// Sets every value in the plane to 0. See also <seealso cref="JxlPlane{T}.Clear()"/> .
+    /// </summary>
+    /// <typeparam name="T">The type of the plane.</typeparam>
+    /// <param name="image">The image to clear.</param>
+    public static void ZeroFillImage<T>(JxlPlane<T> image)
+        where T : unmanaged
+    {
+        if (image.XSize == 0)
+        {
+            return;
+        }
+
+        for (int y = 0; y < image.YSize; y++)
+        {
+            image.GetRow(y).Clear();
+        }
+    }
+
+    /// <summary>
+    /// Core method for the WrapMirror function.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Mirror(long x, long xSize)
+    {
+        DebugGuard.MustBeGreaterThan(xSize, 0, nameof(xSize));
+
+        while (true)
+        {
+            if (x < 0)
+            {
+                x = -x - 1;
+            }
+            else if (x >= xSize)
+            {
+                x = (2 * xSize) - 1 - x;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        return (int)x;
+    }
+
+    /// <summary>
+    /// Searches the entire plane to find the smallest and largest value.
+    /// </summary>
+    /// <typeparam name="T">The type of the plane.</typeparam>
+    /// <param name="image">The plane where to search for the minimum &amp; maximum values.</param>
+    /// <param name="min">Lowest value found in the plane.</param>
+    /// <param name="max">Largest value found in the plane.</param>
+    public static void ImageMinMax<T>(JxlPlane<T> image, out T min, out T max)
+        where T : unmanaged, INumber<T>, IMinMaxValue<T>
+    {
+        min = T.MaxValue;   // Start with opposite
+        max = T.MinValue;   // Start with opposite
+
+        for (int y = 0; y < image.YSize; y++)
+        {
+            Span<T> row = image.GetRow(y);
+
+            for (int x = 0; x < image.XSize; x++)
+            {
+                min = T.Min(min, row[x]);
+                max = T.Max(max, row[x]);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Within the bounds specified by the rectangle <paramref name="rect"/>, sets every
+    /// value within the area to be <paramref name="value"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the plane.</typeparam>
+    /// <param name="value">The value to fill the area with.</param>
+    /// <param name="image">The input plane.</param>
+    /// <param name="rect">The area of the plane to fill everything with.</param>
+    public static void FillPlane<T>(T value, JxlPlane<T> image, Rectangle rect)
+        where T : unmanaged
+    {
+        for (int y = 0; y < rect.Height; y++)
+        {
+            Span<T> row = image.GetRow(rect, y);
+            row.Fill(value);
+        }
+    }
+
+    /// <summary>
+    /// Clears every plane within the image.
+    /// </summary>
+    /// <typeparam name="T">The type of the image</typeparam>
+    /// <param name="image">The image whose all planes will be cleared.</param>
+    public static void ZeroFillImage<T>(JxlImage3<T> image)
+        where T : unmanaged
+    {
+        for (int plane = 0; plane < 3; plane++)
+        {
+            ZeroFillImage(image.Plane(plane));
+        }
+    }
+
+    private static bool DownsampleImageCore(JxlPlane<float> input, int factor, JxlPlane<float> output)
+    {
+        if (factor == 1)
+        {
+            return false;
+        }
+
+        if (!output.ShrinkTo(JxlMath.DivCeil(input.XSize, factor), JxlMath.DivCeil(input.YSize, factor)))
+        {
+            return false;
+        }
+
+        int inStride = input.PixelsPerRow;
+        for (int y = 0; y < output.YSize; y++)
+        {
+            Span<float> rowOut = output.GetRow(y);
+            Span<float> rowIn = input.GetRow(factor * y);
+            for (int x = 0; x < output.XSize; x++)
+            {
+                int count = 0;
+                float sum = 0;
+                for (int iy = 0; iy < factor && iy + (factor * y) < input.YSize; iy++)
+                {
+                    for (int ix = 0; ix < factor && ix + (factor * x) < input.XSize; ix++)
+                    {
+                        sum += rowIn[(iy * inStride) + (x * factor) + ix];
+                        count++;
+                    }
+                }
+
+                rowOut[x] = sum / count;
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Downsamples the image. The resulting image can later be disposed.
+    /// </summary>
+    /// <param name="configuration">Configuration which has a memory allocator which is used to allocate the result image.</param>
+    /// <param name="image">The image to downsample.</param>
+    /// <param name="factor">Downsampling factor.</param>
+    /// <returns>A new downsampled image. It can later be disposed.</returns>
+    public static JxlImageF? DownsampleImage(Configuration configuration, JxlImageF image, int factor)
+    {
+        JxlImageF downsampled = new(
+            configuration,
+            JxlMath.DivCeil(image.XSize, factor) + JxlFrameDimensions.BlockDimensions,
+            JxlMath.DivCeil(image.YSize, factor) + JxlFrameDimensions.BlockDimensions);
+
+        if (!DownsampleImageCore(image, factor, downsampled))
+        {
+            downsampled.Dispose();
+            return null;
+        }
+
+        return downsampled;
+    }
+
+    /// <summary>
+    /// Downsamples all planes within the image. The resulting image can later be disposed.
+    /// </summary>
+    /// <param name="configuration">Configuration which has a memory allocator which is used to allocate the result image.</param>
+    /// <param name="opsin">The image to downsample.</param>
+    /// <param name="factor">Downsampling factor.</param>
+    /// <returns>A new downsampled image. It can later be disposed.</returns>
+    public static JxlImage3F? DownsampleImage(Configuration configuration, JxlImage3F opsin, int factor)
+    {
+        if (factor == 1)
+        {
+            return null;
+        }
+
+        JxlImage3F downsampled = new(
+            configuration,
+            JxlMath.DivCeil(opsin.XSize, factor) + JxlFrameDimensions.BlockDimensions,
+            JxlMath.DivCeil(opsin.YSize, factor) + JxlFrameDimensions.BlockDimensions);
+
+        if (!downsampled.ShrinkTo(
+            downsampled.XSize - JxlFrameDimensions.BlockDimensions,
+            downsampled.YSize - JxlFrameDimensions.BlockDimensions))
+        {
+            return null;
+        }
+
+        for (int plane = 0; plane < 3; plane++)
+        {
+            if (!DownsampleImageCore(opsin.Plane(plane), factor, downsampled.Plane(plane)))
+            {
+                downsampled.Dispose();
+                return null;
+            }
+        }
+
+        return downsampled;
+    }
+
+    public static bool PadImageToBlockMultipleInPlace(JxlImage3<float> input, int blockDimensions)
+    {
+        int xSizeOriginal = input.XSize;
+        int ySizeOriginal = input.YSize;
+
+        int xSize = JxlMath.RoundUpTo(xSizeOriginal, blockDimensions);
+        int ySize = JxlMath.RoundUpTo(ySizeOriginal, blockDimensions);
+
+        if (!input.ShrinkTo(xSize, ySize))
+        {
+            return false;
+        }
+
+        for (int plane = 0; plane < 3; plane++)
+        {
+            for (int y = 0; y < ySizeOriginal; y++)
+            {
+                Span<float> row = input.PlaneRow(plane, y);
+                row[xSizeOriginal..].Fill(row[xSizeOriginal - 1]);
+            }
+
+            Span<float> sourceRow = input.PlaneRow(plane, ySizeOriginal - 1);
+            for (int y = ySizeOriginal; y < ySize; y++)
+            {
+                sourceRow.CopyTo(input.PlaneRow(plane, y));
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlBlockContextMap.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlBlockContextMap.cs
new file mode 100644
index 0000000000..b47a949871
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlBlockContextMap.cs
@@ -0,0 +1,72 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+internal sealed class JxlBlockContextMap
+{
+    public JxlBlockContextMap()
+    {
+        DefaultContextMap.CopyTo(this.ContextMap);
+        this.ContextCount = this.ContextMap.Max() + 1;
+        this.DcContextCount = 1;
+    }
+
+    private static ReadOnlySpan<byte> DefaultContextMap =>
+    [
+        0, 1, 2, 2, 3,  3,  4,  5,  6,  6,  6,  6,  6,
+        7, 8, 9, 9, 10, 11, 12, 13, 14, 14, 14, 14, 14,
+        7, 8, 9, 9, 10, 11, 12, 13, 14, 14, 14, 14, 14,
+    ];
+
+    public List<int>[] DcThresholds { get; } = [[], [], []];
+
+    public List<uint> QfThresholds { get; set; } = [];
+
+    public byte[] ContextMap { get; set; } = new byte[DefaultContextMap.Length];
+
+    public int ContextCount { get; set; }
+
+    public int DcContextCount { get; set; }
+
+    public int AcContextCount => (this.ContextCount * JxlAcContext.NonZeroBuckets) + JxlAcContext.ZeroDensityContextCount;
+
+    public int Context(int dcIndex, uint qf, int ord, int c)
+    {
+        int qfIndex = 0;
+        for (int i = 0; i < this.QfThresholds.Count; i++)
+        {
+            uint t = this.QfThresholds[i];
+
+            if (qf > t)
+            {
+                qfIndex++;
+            }
+        }
+
+        int idx = c < 2 ? c ^ 1 : 2;
+        idx = (idx * JxlForwardCoefficientOrder.OrderCount) + ord;
+        idx = (idx * (this.QfThresholds.Count + 1)) + qfIndex;
+        idx = (idx * this.DcContextCount) + dcIndex;
+        return this.ContextMap[idx];
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int ZeroDensityContextOffset(int blockContext) =>
+        (this.ContextCount * JxlAcContext.NonZeroBuckets) + JxlAcContext.ZeroDensityContextCount + blockContext;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int NonZeroContext(int nonZeroes, int blockContext)
+    {
+        if (nonZeroes >= 64)
+        {
+            nonZeroes = 64;
+        }
+
+        int ctx = nonZeroes < 8 ? nonZeroes : (4 + (nonZeroes / 2));
+        return (ctx * this.ContextCount) + blockContext;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlChromaFromLuma.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlChromaFromLuma.cs
new file mode 100644
index 0000000000..49ed970b84
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlChromaFromLuma.cs
@@ -0,0 +1,46 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using static SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives.JxlFrameDimensions;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Shared constants for CFL (Chroma From Luma) functions.
+/// </summary>
+internal static class JxlChromaFromLuma
+{
+    /// <summary>
+    /// Tiles are 64x64.
+    /// </summary>
+    public const int ColorTileDimension = 64;
+
+    /// <summary>
+    /// Division of the color tile dimension by the block dimension. Therefore,
+    /// this is 8x8.
+    /// </summary>
+    public const int ColorTileDimensionInBlocks = ColorTileDimension / BlockDimensions;
+
+    public const int DefaultColorFactor = 84;
+
+    /// <summary>
+    /// Chroma From Luma fixed point precision, which is
+    /// 11 bits.
+    /// </summary>
+    public const int CflFixedPointPrecision = 11;
+
+    /// <summary>
+    /// 524287
+    /// </summary>
+    public const int CflFixedPointRatioMax = (256 << CflFixedPointPrecision) - 1;
+
+    /// <summary>
+    /// Shared variable U32 distributions for the color factor.
+    /// </summary>
+    public static readonly JxlU32Enc ColorFactorDistribution = new(
+        JxlFieldExpressions.Value(DefaultColorFactor),
+        JxlFieldExpressions.Value(256),
+        JxlFieldExpressions.BitsOffset(8, 2),
+        JxlFieldExpressions.BitsOffset(16, 258));
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlCoefficientOrder.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlCoefficientOrder.cs
new file mode 100644
index 0000000000..ac3f377741
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlCoefficientOrder.cs
@@ -0,0 +1,90 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Helps with reordering coefficients.
+/// </summary>
+internal static class JxlCoefficientOrder
+{
+    public const int Limit = 6156;
+
+    public const int CoefficientOrderMaxSize = Limit * JxlFrameDimensions.DctBlockSize;
+
+    public const int PermutationContexts = 8;
+
+    /// <summary>
+    /// Gets the pattern which coefficients must follow to compute offsets.
+    /// </summary>
+    public static ReadOnlySpan<int> CoefficientOrderOffsets =>
+    [
+        0,    1,    2,    3,    4,    5,    6,    10,   14,   18,
+        34,   50,   66,   68,   70,   72,   76,   80,   84,   92,
+        100,  108,  172,  236,  300,  332,  364,  396,  652,  908,
+        1164, 1292, 1420, 1548, 2572, 3596, 4620, 5132, 5644, Limit
+    ];
+
+    /// <summary>
+    /// Gets the pattern which coefficients must follow to compute offsets.
+    /// </summary>
+    public static ReadOnlySpan<byte> StrategyOrder =>
+    [
+        0, 1, 1, 1, 2, 3, 4, 4, 5,  5,  6,  6,  1,  1,
+        1, 1, 1, 1, 7, 8, 8, 9, 10, 10, 11, 12, 12,
+    ];
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int CoeffOrderOffset(int o, int c) => CoefficientOrderOffsets[(3 * o) + c] * JxlFrameDimensions.DctBlockSize;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint CoeffOrderContext(uint value)
+    {
+        new JxlAnsHybridUIntConfiguration(0, 0, 0).Encode(value, out uint token, out uint nbits, out uint bits);
+
+        return Math.Min(token, PermutationContexts - 1u);
+    }
+
+    public static bool ReadPermutation(int skip, int size, Span<uint> order, JxlBitReader bitReader, JxlAnsSymbolReader reader, Span<byte> contextMap)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(size, 65536, nameof(size));
+
+        Span<uint> lehmer = stackalloc uint[size];
+        lehmer.Clear();
+
+        Span<uint> temp = stackalloc uint[size * 2];
+        temp.Clear();
+
+        uint end = reader.ReadHybridUnsignedInteger(CoeffOrderContext((uint)size), bitReader, contextMap) + skip;
+
+        if (end > size)
+        {
+            throw new InvalidOperationException("Invalid permutation size");
+        }
+
+        uint last = 0;
+
+        for (int i = skip; i < end; i++)
+        {
+            lehmer[i] = reader.ReadHybridUnsignedInteger(CoeffOrderContext(last), bitReader, contextMap);
+            last = lehmer[i];
+            if (lehmer[i] >= size - i)
+            {
+                throw new InvalidOperationException("Invalid lehmer code");
+            }
+        }
+
+        if (order.IsEmpty)
+        {
+            return true;
+        }
+
+        return JxlLehmerCode.DecodeLehmerCode(lehmer, temp, size, order);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlColorCorrelation.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlColorCorrelation.cs
new file mode 100644
index 0000000000..4ec5258801
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlColorCorrelation.cs
@@ -0,0 +1,114 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+internal sealed class JxlColorCorrelation
+{
+    private float baseCorrelationX;
+    private float baseCorrelationB = JxlOpsinConstants.YToBRatio;
+
+    private InlineArray4<float> dcFactors;
+    private uint colorFactor = JxlChromaFromLuma.DefaultColorFactor;
+    private float colorScale = 1.0f / JxlChromaFromLuma.DefaultColorFactor;
+
+    public int YToXDc { get; private set; }
+
+    public int YToBDc { get; private set; }
+
+    public float ColorFactor => this.colorFactor;
+
+    public float BaseCorrelationX
+    {
+        get => this.baseCorrelationX;
+        set => this.baseCorrelationX = value;
+    }
+
+    public float BaseCorrelationB
+    {
+        get => this.baseCorrelationB;
+        set => this.baseCorrelationB = value;
+    }
+
+    public bool IsJpegCompatible =>
+        this.BaseCorrelationX == 0 &&
+        this.BaseCorrelationB == 0 &&
+        this.YToBDc == 0 &&
+        this.YToXDc == 0 &&
+        this.ColorFactor == JxlChromaFromLuma.DefaultColorFactor;
+
+    public ReadOnlySpan<float> DcFactors => this.dcFactors;
+
+    public float YToXRatio(int xFactor) => this.BaseCorrelationX + (xFactor * this.colorScale);
+
+    public float YToBRatio(int bFactor) => this.BaseCorrelationB + (bFactor * this.colorScale);
+
+    public void SetColorFactor(uint factor)
+    {
+        this.colorFactor = factor;
+        this.colorScale = 1f / factor;
+        this.RecomputeDcFactors();
+    }
+
+    public void SetYToBDc(int yToBDc)
+    {
+        this.YToBDc = yToBDc;
+        this.RecomputeDcFactors();
+    }
+
+    public void SetYToXDc(int yToXDc)
+    {
+        this.YToXDc = yToXDc;
+        this.RecomputeDcFactors();
+    }
+
+    public void RecomputeDcFactors()
+    {
+        this.dcFactors[0] = this.YToXRatio(this.YToXDc);
+        this.dcFactors[2] = this.YToBRatio(this.YToBDc);
+    }
+
+    public bool DecodeDc(JxlBitReader reader)
+    {
+        bool allDefault = reader.ReadBoolean();
+
+        if (allDefault)
+        {
+            return true;
+        }
+
+        this.SetColorFactor(JxlU32Coder.Read(JxlChromaFromLuma.ColorFactorDistribution, reader));
+
+        if (!JxlF16Coder.Read(reader, ref this.baseCorrelationX))
+        {
+            return false;
+        }
+
+        if (MathF.Abs(this.baseCorrelationX) > 4f)
+        {
+            throw new InvalidOperationException("Base X correlation is out of range");
+        }
+
+        if (!JxlF16Coder.Read(reader, ref this.baseCorrelationB))
+        {
+            return false;
+        }
+
+        if (MathF.Abs(this.baseCorrelationB) > 4f)
+        {
+            throw new InvalidOperationException("Base B correlation is out of range");
+        }
+
+        this.YToXDc = (int)reader.ReadBits32(8) + sbyte.MinValue;
+        this.YToBDc = (int)reader.ReadBits32(8) + sbyte.MinValue;
+
+        this.RecomputeDcFactors();
+        return true;
+    }
+
+    public static int RatioJpeg(int factor) => factor * (1 << JxlChromaFromLuma.CflFixedPointPrecision) / JxlChromaFromLuma.DefaultColorFactor;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlColorCorrelationMap.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlColorCorrelationMap.cs
new file mode 100644
index 0000000000..9ce8e2e86a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlColorCorrelationMap.cs
@@ -0,0 +1,42 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// JPEG XL Color correlation map.
+/// </summary>
+internal sealed class JxlColorCorrelationMap
+{
+    public JxlColorCorrelation Base { get; set; } = new();
+
+    public JxlImageSB? YToXMap { get; set; }
+
+    public JxlImageSB? YToBMap { get; set; }
+
+    public bool DecodeDc(JxlBitReader reader) => this.Base.DecodeDc(reader);
+
+    public static JxlColorCorrelationMap Create(Configuration configuration, int width, int height, bool xyb = true)
+    {
+        JxlColorCorrelationMap map = new();
+
+        (int xBlocks, int yBlocks) = (JxlMath.DivCeil(width, JxlChromaFromLuma.ColorTileDimension), JxlMath.DivCeil(height, JxlChromaFromLuma.ColorTileDimension));
+
+        map.YToXMap = new JxlImageSB(configuration, xBlocks, yBlocks);
+        map.YToBMap = new JxlImageSB(configuration, xBlocks, yBlocks);
+
+        map.YToXMap.Clear();
+        map.YToBMap.Clear();
+
+        if (!xyb)
+        {
+            map.Base.BaseCorrelationB = 0;
+        }
+
+        map.Base.RecomputeDcFactors();
+        return map;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlConvolve.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlConvolve.cs
new file mode 100644
index 0000000000..233a98549d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlConvolve.cs
@@ -0,0 +1,426 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Convolution filters
+/// </summary>
+internal static class JxlConvolve
+{
+    /// <summary>
+    /// Weighted sum of 1x5 pixels around ix, iy with [wx2, wx1, wx0, wx1, wx2].
+    /// </summary>
+    public static float WeightedSumBorder(
+        JxlImageF input,
+        Func<long, long, int> wrapY,
+        long ix,
+        long iy,
+        int width,
+        int height,
+        float wx0,
+        float wx1,
+        float wx2)
+    {
+        ReadOnlySpan<float> row = input.GetRow(wrapY(iy, height));
+
+        float inM2 = row[WrapMirror(ix - 2, width)];
+        float inP2 = row[WrapMirror(ix + 2, width)];
+        float inM1 = row[WrapMirror(ix - 1, width)];
+        float inP1 = row[WrapMirror(ix + 1, width)];
+        float in00 = row[(int)ix];
+
+        float sum2 = wx2 * (inM2 + inP2);
+        float sum1 = wx1 * (inM1 + inP1);
+        float sum0 = wx0 * in00;
+
+        return sum2 + (sum1 + sum0);
+    }
+
+    public static Vector<float> WeightedSum(
+        JxlImageF input,
+        Func<long, long, int> wrapY,
+        int ix,
+        long iy,
+        int height,
+        Vector<float> wx0,
+        Vector<float> wx1,
+        Vector<float> wx2)
+    {
+        ReadOnlySpan<float> center = input.GetRow(wrapY(iy, height))[ix..];
+        ref float centerRef = ref MemoryMarshal.GetReference(center);
+
+        Vector<float> inM2 = Vector.LoadUnsafe(ref Unsafe.Subtract(ref centerRef, 2));
+        Vector<float> inP2 = Vector.LoadUnsafe(ref Unsafe.Add(ref centerRef, 2));
+        Vector<float> inM1 = Vector.LoadUnsafe(ref Unsafe.Subtract(ref centerRef, 1));
+        Vector<float> inP1 = Vector.LoadUnsafe(ref Unsafe.Add(ref centerRef, 1));
+        Vector<float> in00 = Vector.LoadUnsafe(ref centerRef);
+
+        Vector<float> sum2 = wx2 * (inM2 + inP2);
+        Vector<float> sum1 = wx1 * (inM1 + inP1);
+        Vector<float> sum0 = wx0 * in00;
+
+        return sum2 + (sum1 + sum0);
+    }
+
+    public static float Symmetric5Border(JxlImageF input, Func<long, long, int> wrapY, long ix, long iy, ref JxlWeightsSymmetric5 weights)
+    {
+        float w0 = weights.GetCVector()[0];
+        float w1 = weights.GetRVector()[0];
+        float w2 = weights.GetR2Vector()[0];
+        float w4 = weights.GetDVector()[0];
+        float w5 = weights.GetCVector()[0];
+        float w8 = weights.GetD2Vector()[0];
+
+        int width = input.XSize;
+        int height = input.YSize;
+
+        float sum0 = WeightedSumBorder(input, wrapY, ix, iy, width, height, w0, w1, w2)
+            + WeightedSumBorder(input, wrapY, ix, iy - 2, width, height, w2, w5, w8);
+
+        float sum1 = WeightedSumBorder(input, wrapY, ix, iy + 2, width, height, w2, w5, w8);
+
+        sum0 += WeightedSumBorder(input, wrapY, ix, iy + 1, width, height, w1, w4, w5);
+        sum1 += WeightedSumBorder(input, wrapY, ix, iy - 1, width, height, w1, w4, w5);
+
+        return sum0 + sum1;
+    }
+
+    public static void Symmetric5Interior(
+        JxlImageF image,
+        int ix,
+        Func<long, long, int> wrapY,
+        int rix,
+        long iy,
+        ref JxlWeightsSymmetric5 weights,
+        Span<float> rowOut)
+    {
+        Vector<float> w0 = LoadDuplicate128(weights.GetCVector());  // c
+        Vector<float> w1 = LoadDuplicate128(weights.GetRVector());  // r
+        Vector<float> w2 = LoadDuplicate128(weights.GetR2Vector()); // R
+        Vector<float> w4 = LoadDuplicate128(weights.GetDVector());  // d
+        Vector<float> w5 = LoadDuplicate128(weights.GetLVector());  // L
+        Vector<float> w8 = LoadDuplicate128(weights.GetD2Vector()); // D
+
+        int height = image.YSize;
+        Vector<float> sum0 = WeightedSum(image, wrapY, ix, iy, height, w0, w1, w2)
+            + WeightedSum(image, wrapY, ix, iy - 2, height, w2, w5, w8);
+
+        Vector<float> sum1 = WeightedSum(image, wrapY, ix, iy + 2, height, w2, w5, w8);
+
+        sum0 += WeightedSum(image, wrapY, ix, iy - 1, height, w1, w4, w5);
+        sum1 += WeightedSum(image, wrapY, ix, iy + 1, height, w1, w4, w5);
+
+        (sum0 + sum1).StoreUnsafe(ref Unsafe.Add(ref MemoryMarshal.GetReference(rowOut), rix));
+    }
+
+    public static void Symmetric5Row(
+        JxlImageF image,
+        Func<long, long, int> wrapY,
+        in Rectangle rect,
+        long iy,
+        ref JxlWeightsSymmetric5 weights,
+        Span<float> rowOut)
+    {
+        const int radius = 2;
+        int xEnd = rect.Right;
+
+        int rix = 0;
+        int ix = rect.X;
+
+        int n = Vector<float>.Count;
+        int alignedX = RoundUpTo(radius, n);
+
+        for (; ix < Math.Min(alignedX, xEnd); ix++, rix++)
+        {
+            rowOut[rix] = Symmetric5Border(image, wrapY, ix, iy, ref weights);
+        }
+
+        for (; ix + n + radius <= xEnd; ix += n, rix += n)
+        {
+            Symmetric5Interior(image, ix, wrapY, rix, iy, ref weights, rowOut);
+        }
+
+        for (; ix < xEnd; ix++, rix++)
+        {
+            rowOut[rix] = Symmetric5Border(image, wrapY, ix, iy, ref weights);
+        }
+    }
+
+    public static bool Symmetric5(
+        JxlPlane<float> input,
+        in Rectangle rectangle,
+        ref JxlWeightsSymmetric5 weights,
+        JxlPlane<float> output,
+        Rectangle outputRect)
+    {
+        if (rectangle.Width != outputRect.Width || rectangle.Height != outputRect.Height)
+        {
+            return false;
+        }
+
+        int height = rectangle.Height;
+
+        for (int riy = 0; riy < height; riy++)
+        {
+            int iy = rectangle.Y + riy;
+
+            if (iy < 2 || iy >= rectangle.Height - 2)
+            {
+                Symmetric5Row(input, WrapMirror, in rectangle, iy, weights, output.GetRow(outputRect, riy));
+            }
+            else
+            {
+                Symmetric5Row(input, in rectangle, iy, weights, output.GetRow(outputRect, riy));
+            }
+        }
+
+        return true;
+    }
+
+    public static float SlowSymmetric3Pixel(
+        JxlImageF image,
+        int x,
+        int y,
+        int width,
+        int height,
+        JxlWeightsSymmetric3 weights,
+        Func<long, long, int> wrapX,
+        Func<long, long, int> wrapY)
+    {
+        float sum = 0.0f;
+
+        float c0 = weights.GetCVector()[0];
+        float r0 = weights.GetRVector()[0];
+        float d0 = weights.GetDVector()[0];
+
+        for (int ky = -1; ky <= 1; ky++)
+        {
+            int yy = wrapY(y + ky, height);
+            ReadOnlySpan<float> row = image.GetRow(yy);
+
+            float wc = (ky == 0) ? c0 : r0;
+            float wlr = (ky == 0) ? r0 : d0;
+
+            int xm1 = wrapX(x - 1, width);
+            int xp1 = wrapX(x + 1, width);
+
+            sum += (row[x] * wc) + ((row[xm1] + row[xp1]) * wlr);
+        }
+
+        return sum;
+    }
+
+    public static void SlowSymmetric3Row(
+        JxlImageF image,
+        int y,
+        int width,
+        int height,
+        JxlWeightsSymmetric3 weights,
+        Span<float> outputRow,
+        Func<long, long, int> wrapY)
+    {
+        outputRow[0] = SlowSymmetric3Pixel(
+            image,
+            0,
+            y,
+            width,
+            height,
+            weights,
+            WrapMirror,
+            wrapY);
+
+        for (int x = 1; x < width - 1; x++)
+        {
+            outputRow[x] = SlowSymmetric3Pixel(
+                image,
+                x,
+                y,
+                width,
+                height,
+                weights,
+                WrapUnchanged,
+                wrapY);
+        }
+
+        outputRow[width - 1] = SlowSymmetric3Pixel(
+            image,
+            width - 1,
+            y,
+            width,
+            height,
+            weights,
+            WrapMirror,
+            wrapY);
+    }
+
+    public static void SlowSymmetric3(
+        JxlPlane<float> input,
+        Rectangle rect,
+        JxlWeightsSymmetric3 weights,
+        JxlPlane<float> output)
+    {
+        int width = rect.Width;
+        int height = rect.Height;
+
+        const int radius = 1;
+
+        for (int y = 0; y < height; y++)
+        {
+            Span<float> rowOut = output.GetRow(y);
+
+            if (y < radius || y >= height - radius)
+            {
+                SlowSymmetric3Row(
+                    input,
+                    y,
+                    width,
+                    height,
+                    weights,
+                    rowOut,
+                    WrapMirror);
+            }
+            else
+            {
+                SlowSymmetric3Row(
+                    input,
+                    y,
+                    width,
+                    height,
+                    weights,
+                    rowOut,
+                    WrapUnchanged);
+            }
+        }
+    }
+
+    public static float SlowSeparablePixel(
+        JxlImageF image,
+        Rectangle rect,
+        int x,
+        int y,
+        int radius,
+        ReadOnlySpan<float> horzWeights,
+        ReadOnlySpan<float> vertWeights)
+    {
+        int width = image.XSize;
+        int height = image.YSize;
+
+        float sum = 0;
+
+        for (int dy = -radius; dy <= radius; dy++)
+        {
+            float wy = vertWeights[Math.Abs(dy) * 4];
+            int sy = WrapMirror(rect.Y + y + dy, height);
+            ReadOnlySpan<float> row = image.GetRow(sy);
+
+            for (int dx = -radius; dx <= radius; dx++)
+            {
+                float wx = horzWeights[Math.Abs(dx) * 4];
+                int sx = WrapMirror(rect.X + x + dx, width);
+                sum += row[sx] * wx * wy;
+            }
+        }
+
+        return sum;
+    }
+
+    public static void SlowSeparable(
+        JxlImageF input,
+        Rectangle inputRect,
+        JxlWeightsSeparable5 weights,
+        JxlImageF output,
+        Rectangle outputRect,
+        int radius)
+    {
+        ReadOnlySpan<float> horz = weights.Horizontal;
+        ReadOnlySpan<float> vert = weights.Vertical;
+
+        for (int y = 0; y < inputRect.Height; y++)
+        {
+            Span<float> rowOut = output.GetRow(outputRect, y);
+
+            for (int x = 0; x < inputRect.Width; x++)
+            {
+                rowOut[x] = SlowSeparablePixel(
+                    input,
+                    inputRect,
+                    x,
+                    y,
+                    radius,
+                    horz,
+                    vert);
+            }
+        }
+    }
+
+    public static void SlowSeparable5(
+        JxlImageF input,
+        Rectangle inputRect,
+        JxlWeightsSeparable5 weights,
+        JxlImageF output,
+        Rectangle outputRect)
+        => SlowSeparable(input, inputRect, weights, output, outputRect, 2);
+
+    public static void FirstL1(ReadOnlySpan<float> c, Span<float> dst)
+    {
+        dst[0] = c[0];
+        for (int i = 1; i < dst.Length; i++)
+        {
+            dst[i] = c[i - 1];
+        }
+    }
+
+    public static void FirstL2(ReadOnlySpan<float> c, Span<float> dst)
+    {
+        dst[0] = c[1];
+        dst[1] = c[0];
+
+        for (int i = 2; i < dst.Length; i++)
+        {
+            dst[i] = c[i - 2];
+        }
+    }
+
+    /// <summary>
+    /// A SIMD utility method which takes in the 128 bit vector
+    /// and duplicates its values to fit in the CPU vector size.
+    /// For example,
+    ///
+    ///     128 bit vectors: A B C D    (as-is)
+    ///     256 bit vectors: A B C D A B C D (duplicate once)
+    ///     512 bit vectors: A B C D A B C D A B C D A B C D (duplicate three times)
+    ///
+    /// Vector&lt;T&gt; has support for arbitrarily large
+    /// vector sizes. For example, some ARM CPUs support 2048-bit
+    /// vectors through Vector&lt;T&gt;. In that specific case, this
+    /// method can be used for future-proofing.
+    ///
+    /// Note that this method, albeit future-proof, may be considered
+    /// slow for smaller vector sizes (think CPUs with 256bit vectors).
+    /// </summary>
+    /// <param name="vec">Vector to duplicate.</param>
+    /// <returns>New vector that is duplicated across the width.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector<float> LoadDuplicate128(Vector128<float> vec)
+    {
+        Span<float> value = stackalloc float[Vector<float>.Count];
+        for (int i = 0; i < Vector<float>.Count; i += 4)
+        {
+            vec.CopyTo(value[i..]);
+        }
+
+        return new(value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int RoundUpTo(int value, int multiple) => ((value + multiple - 1) / multiple) * multiple;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlEntropyCoder.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlEntropyCoder.cs
new file mode 100644
index 0000000000..b36517e30b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlEntropyCoder.cs
@@ -0,0 +1,121 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Helper functions for use in entropy coding.
+/// </summary>
+internal static class JxlEntropyCoder
+{
+    /// <summary>
+    /// Global DC threshold distributions
+    /// </summary>
+    public static readonly JxlU32Enc DcThresholdDistributions = new(
+        JxlFieldExpressions.Bits(4),
+        JxlFieldExpressions.BitsOffset(8, 16),
+        JxlFieldExpressions.BitsOffset(16, 272),
+        JxlFieldExpressions.BitsOffset(32, 65808));
+
+    /// <summary>
+    /// Global QF threshold distributions
+    /// </summary>
+    public static readonly JxlU32Enc QfThresholdDistributions = new(
+        JxlFieldExpressions.Bits(2),
+        JxlFieldExpressions.BitsOffset(3, 4),
+        JxlFieldExpressions.BitsOffset(5, 12),
+        JxlFieldExpressions.BitsOffset(8, 44));
+
+    /// <summary>
+    /// Predicts the entropy symbol using top and left neighboring pixels.
+    /// </summary>
+    /// <param name="rowTop">Above row; set to <see cref="Span{T}.Empty"/> if missing</param>
+    /// <param name="row">Current row</param>
+    /// <param name="x">The x coordinate offset</param>
+    /// <param name="defaultValue">Default value that's used if both current and above row cannot be used</param>
+    /// <returns>The predicted coefficient using neighboring pixels.</returns>
+    public static int PredictFromTopAndLeft(
+        ReadOnlySpan<int> rowTop,
+        ReadOnlySpan<int> row,
+        int x,
+        int defaultValue)
+    {
+        if (x == 0)
+        {
+            return rowTop.Length == 0 ? defaultValue : rowTop[x];
+        }
+
+        if (rowTop.Length == 0)
+        {
+            return row[x - 1];
+        }
+
+        return (rowTop[x] + rowTop[x - 1] + 1) / 2;
+    }
+
+    public static bool DecodeBlockContextMap(Configuration configuration, JxlBitReader reader, ref JxlBlockContextMap contextMap)
+    {
+        List<int>[] dct = contextMap.DcThresholds;
+        byte[] ctxMap = contextMap.ContextMap;
+
+        bool isDefaultContextMap = reader.ReadBoolean();
+
+        if (isDefaultContextMap)
+        {
+            contextMap = new();
+            return true;
+        }
+
+        contextMap.DcContextCount = 1;
+
+        for (int j = 0; j <= 2; j++)
+        {
+            int dcThresholdCount = (int)reader.ReadBits32(4u);
+
+            dct[j] = new List<int>(dcThresholdCount);
+
+            contextMap.DcContextCount = dcThresholdCount + 1;
+
+            for (int i = 0; i < dcThresholdCount; i++)
+            {
+                dct[j][i] = JxlPackSigned.UnpackSigned(JxlU32Coder.Read(DcThresholdDistributions, reader));
+            }
+        }
+
+        int qfThresholdCount = (int)reader.ReadBits32(4u);
+
+        List<uint> qft = new(qfThresholdCount);
+
+        for (int i = 0; i < qfThresholdCount; i++)
+        {
+            qft[i] = JxlU32Coder.Read(QfThresholdDistributions, reader) + 1;
+        }
+
+        contextMap.QfThresholds = qft;
+
+        if (contextMap.DcContextCount * qft.Count > 64)
+        {
+            throw new InvalidOperationException("Invalid block context map. It is too large.");
+        }
+
+        Array.Resize(ref ctxMap, 3 * JxlForwardCoefficientOrder.OrderCount * contextMap.DcContextCount * qft.Count);
+
+        contextMap.ContextMap = ctxMap;
+
+        if (!JxlDecoderCore.DecodeContextMap(configuration, ref ctxMap, contextMap.ContextCount, reader))
+        {
+            return false;
+        }
+
+        if (contextMap.ContextCount > 16)
+        {
+            throw new InvalidOperationException("Too many distinct contexts in block context map");
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlForwardCoefficientOrder.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlForwardCoefficientOrder.cs
new file mode 100644
index 0000000000..26a210e6fd
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlForwardCoefficientOrder.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+internal static class JxlForwardCoefficientOrder
+{
+    public const byte OrderCount = 13;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int CoefficientRows(int rows, int columns) => rows < columns ? rows : columns;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int CoefficientColumns(int rows, int columns) => rows < columns ? columns : rows;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void CoefficientLayout(ref int rows, ref int columns)
+    {
+        rows = CoefficientRows(rows, columns);
+        columns = CoefficientColumns(rows, columns);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlLoopFilter.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlLoopFilter.cs
new file mode 100644
index 0000000000..c7ea5b8365
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlLoopFilter.cs
@@ -0,0 +1,265 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// JPEG XL loop filter.
+/// </summary>
+internal sealed class JxlLoopFilter : IJxlFields
+{
+    private const int SigmaBorder = 1;
+    private const int SigmaPadding = 2;
+
+    /// <summary>
+    /// 4 * (sqrt(0.5)-1), so that Weight(sigma) = 0.5
+    /// </summary>
+    private const float InverseSigmaNum = -1.1715728752538099024f;
+
+    /// <summary>
+    /// <see cref="InverseSigmaNum"/> / 3
+    /// </summary>
+    public const float MinimumSigma = -3.90524291751269967465540850526868f;
+
+    /// <summary>
+    /// Gets the number of EPF (Edge-preserving filter) sharp entries.
+    /// </summary>
+    public const int EpfSharpEntries = 8;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether gaborish
+    /// convolution is preferred.
+    /// </summary>
+    public bool UseGaborishConvolution { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether custom
+    /// gaborish weights are used.
+    /// </summary>
+    public bool GaborishCustom { get; set; }
+
+    /// <summary>
+    /// Gets or sets the first custom X gaborish weight.
+    /// </summary>
+    public float GaborishXWeight1 { get; set; }
+
+    /// <summary>
+    /// Gets or sets the second custom X gaborish weight.
+    /// </summary>
+    public float GaborishXWeight2 { get; set; }
+
+    /// <summary>
+    /// Gets or sets the first custom Y gaborish weight.
+    /// </summary>
+    public float GaborishYWeight1 { get; set; }
+
+    /// <summary>
+    /// Gets or sets the second custom Y gaborish weight.
+    /// </summary>
+    public float GaborishYWeight2 { get; set; }
+
+    /// <summary>
+    /// Gets or sets the first custom B gaborish weight.
+    /// </summary>
+    public float GaborishBWeight1 { get; set; }
+
+    /// <summary>
+    /// Gets or sets the second custom B gaborish weight.
+    /// </summary>
+    public float GaborishBWeight2 { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of EPF (Edge-preserving filter) steps.
+    /// 0 means EPF is disabled, 1 applies only the first stage,
+    /// 2 applies both stages and 3 applies the first stage twice
+    /// and the second stage once.
+    /// </summary>
+    public int EpfIterations { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether custom EPF sharpness
+    /// is used.
+    /// </summary>
+    public bool EpfSharpCustom { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value with 8 elements representing EPF sharpness lookup tables (LUTs).
+    /// </summary>
+    public float[] EpfSharpLookup { get; set; } = new float[8];
+
+    /// <summary>
+    /// Gets or sets a value indicating whether custom EPF weights are used.
+    /// </summary>
+    public bool EpfCustomWeights { get; set; }
+
+    /// <summary>
+    /// Gets or sets the relative weight of each channel.
+    /// </summary>
+    public float[] EpfChannelScale { get; set; } = new float[3];
+
+    /// <summary>
+    /// Gets or sets the value that represents the minimum weight for first pass.
+    /// </summary>
+    public float EpfPass1ZeroFlush { get; set; }
+
+    /// <summary>
+    /// Gets or sets the value that represents the minimum weight for second pass.
+    /// </summary>
+    public float EpfPass2ZeroFlush { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether custom sigma parameters are used for EPF.
+    /// </summary>
+    public bool EpfCustomSigma { get; set; }
+
+    /// <summary>
+    /// Gets or sets the quant multiplier.
+    /// </summary>
+    public float EpfQuantMultiplier { get; set; }
+
+    /// <summary>
+    /// Gets or sets the multiplier for sigma in pass 0.
+    /// </summary>
+    public float EpfPass0SigmaScale { get; set; }
+
+    /// <summary>
+    /// Gets or sets the multiplier for sigma in pass 2.
+    /// </summary>
+    public float EpfPass2SigmaScale { get; set; }
+
+    /// <summary>
+    /// Gets or sets the inverse multiplier for sigma on borders.
+    /// </summary>
+    public float EpfBorderSadMul { get; set; }
+
+    /// <summary>
+    /// Gets or sets the EPF sigma for modular.
+    /// </summary>
+    // NOTE: This value is not documented by libjxl.
+    public float EpfSigmaForModular { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of extensions.
+    /// </summary>
+    public long Extensions { get; set; }
+
+    /// <summary>
+    /// Mirror n floats starting at *span and store them before span.
+    /// </summary>
+    private static void LeftMirror(Span<float> span, int n)
+    {
+        ref float p = ref MemoryMarshal.GetReference(span);
+        for (int i = 0; i < n; i++)
+        {
+            Unsafe.Add(ref p, -1 - i) = span[i];
+        }
+    }
+
+    /// <summary>
+    /// Mirror n floats starting at *(span - n) and store them at *span.
+    /// </summary>
+    private static void RightMirror(Span<float> span, int n)
+    {
+        ref float p = ref MemoryMarshal.GetReference(span);
+        for (int i = 0; i < n; i++)
+        {
+            span[i] = Unsafe.Add(ref p, -1 - i);
+        }
+    }
+
+    public bool ComputeSigma(Rectangle blockRect, JxlPassesDecoderState state)
+    {
+        if (this.EpfIterations <= 0)
+        {
+            return false;
+        }
+
+        JxlAcStrategyImage acStrategy = state.Shared.AcStrategy;
+        float quantScale = state.Shared.Quantizer.Scale;
+
+        int sigmaStride = state.Sigma!.PixelsPerRow;
+        int sharpnessStride = state.Shared.EpfSharpness.PixelsPerRow;
+
+        for (int by = 0; by < blockRect.Height; by++)
+        {
+            Span<float> sigmaRow = state.Sigma.GetRow(by);
+            Span<byte> sharpnessRow = state.Shared.EpfSharpness.GetRow(by);
+            JxlAcStrategyRow acsRow = acStrategy.GetRow(in blockRect, by);
+            Span<int> rowQuant = state.Shared.RawQuantField.GetRow(by);
+
+            for (int bx = 0; bx < blockRect.Width; bx++)
+            {
+                JxlAcStrategy acs = acsRow[bx];
+                int llfX = acs.CoveredBlocksX;
+
+                if (!acs.IsFirstBlock)
+                {
+                    continue;
+                }
+
+                float sigmaQuant = this.EpfQuantMultiplier / (quantScale * rowQuant[bx] * InverseSigmaNum);
+
+                for (int iy = 0; iy < acs.CoveredBlocksY; iy++)
+                {
+                    for (int ix = 0; ix < acs.CoveredBlocksY; ix++)
+                    {
+                        float sigma = sigmaQuant * this.EpfSharpLookup[sharpnessRow[bx + ix + iy + sharpnessStride]];
+                        sigma = MathF.Min(-1e-4f, sigma);
+                        sigmaRow[bx + ix + SigmaPadding + ((iy + SigmaPadding) * sigmaStride)] = 1.0f / sigma;
+                    }
+                }
+
+                if (bx + blockRect.X == 0)
+                {
+                    for (int iy = 0; iy < acs.CoveredBlocksY; iy++)
+                    {
+                        LeftMirror(sigmaRow[(SigmaPadding + ((iy + SigmaPadding) * sigmaStride))..], SigmaBorder);
+                    }
+                }
+
+                if (bx + blockRect.X + llfX == state.Shared.FrameDimensions.XSizeBlocks)
+                {
+                    for (int iy = 0; iy < acs.CoveredBlocksY; iy++)
+                    {
+                        RightMirror(sigmaRow[(SigmaPadding + bx + llfX + ((iy + SigmaPadding) * sigmaStride))..], SigmaBorder);
+                    }
+                }
+
+                int offsetBefore = bx + blockRect.X == 0 ? 1 : bx + SigmaPadding;
+                int offsetAfter = bx + blockRect.X + llfX == state.Shared.FrameDimensions.XSizeBlocks
+                    ? SigmaPadding + llfX + bx + SigmaBorder
+                    : SigmaPadding + llfX + bx;
+
+                int num = offsetAfter - offsetBefore;
+
+                if (by + blockRect.Y == 0)
+                {
+                    for (int iy = 0; iy < SigmaBorder; iy++)
+                    {
+                        sigmaRow.Slice(offsetBefore + ((SigmaPadding - 1 - iy) * sigmaStride), num)
+                                .CopyTo(sigmaRow[(offsetBefore + ((SigmaPadding + iy) * sigmaStride))..]);
+                    }
+                }
+
+                if (by + blockRect.Y + acs.CoveredBlocksX == state.Shared.FrameDimensions.YSizeBlocks)
+                {
+                    for (int iy = 0; iy < SigmaBorder; iy++)
+                    {
+                        sigmaRow[(offsetBefore + (sigmaStride * (acs.CoveredBlocksX + SigmaPadding + iy)))..]
+                                .CopyTo(sigmaRow[(offsetBefore + (sigmaStride * (acs.CoveredBlocksY + SigmaPadding - 1 - iy)))..]);
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public bool Visit(JxlVisitor visitor) => throw new NotImplementedException();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlMath.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlMath.cs
new file mode 100644
index 0000000000..f0ab04104e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlMath.cs
@@ -0,0 +1,720 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Common math functions used by the JPEG XL codec.
+/// </summary>
+internal static class JxlMath
+{
+    /// <summary>
+    /// Number of bits in a single byte.
+    /// </summary>
+    public const int BitsPerByte = 8;   // This makes it more clear than just typing the number 8
+
+    /// <summary>
+    /// Default intensity target constant.
+    /// </summary>
+    public const float DefaultIntensityTarget = 255f;
+
+    /// <summary>
+    /// Multiplier for conversion of log2(x) result to ln(x). The
+    /// value is derived by <c>1.0f / MathF.Log2(MathF.E).</c>
+    /// </summary>
+    public const float InverseLog2E = 0.6931471805599453f;
+
+    /// <summary>
+    /// Integer division by default is truncated toward zero. This
+    /// function performs division and ceiling without any floating-point
+    /// operations.
+    /// </summary>
+    /// <param name="a">Dividend</param>
+    /// <param name="b">Divisor</param>
+    /// <returns>
+    /// Result of the division with ceiling. It is equivalent to
+    /// <c>MathF.Ceiling(a / b)</c> without any floating-point usage.
+    /// </returns>
+    /// <remarks>
+    /// This function only works for positive values. Division will be
+    /// incorrect for negative values.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int DivCeil(int a, int b)
+    {
+        unchecked
+        {
+            // This is a wrapper for Numerics.DivideCeil but for
+            // int input values.
+            return (int)Numerics.DivideCeil((uint)a, (uint)b);
+        }
+    }
+
+    /// <summary>
+    /// Ensures that <paramref name="value"/> rounded to the multiple of <paramref name="align"/>.
+    /// </summary>
+    /// <param name="value">The value to round.</param>
+    /// <param name="align">The allowed step size.</param>
+    /// <returns>
+    /// <paramref name="value"/>, transformed to ensure that it stays within the step size of <paramref name="align"/>.
+    /// </returns>
+    /// <remarks>
+    ///   <para>
+    ///     If value=4, align=6, the result is 6. If value=7 and align=3 the result is 9.
+    ///   </para>
+    ///   <para>
+    ///     This will not work correctly for negative values.
+    ///   </para>
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int RoundUpTo(int value, int align) => DivCeil(value, align) * align;
+
+    /// <summary>
+    /// Ensures that <paramref name="value"/> rounded to the multiple of <paramref name="align"/>.
+    /// </summary>
+    /// <param name="value">The value to round.</param>
+    /// <param name="align">The allowed step size.</param>
+    /// <returns>
+    /// <paramref name="value"/>, transformed to ensure that it stays within the step size of <paramref name="align"/>.
+    /// </returns>
+    /// <remarks>
+    ///   <para>
+    ///     If value=4, align=6, the result is 6. If value=7 and align=3 the result is 9.
+    ///   </para>
+    ///   <para>
+    ///     This will not work correctly for negative values.
+    ///   </para>
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint RoundUpTo(uint value, uint align) => Numerics.DivideCeil(value, align) * align;
+
+    /// <summary>
+    /// Performs subtraction &amp; returns a boolean indicating whether or not did the subtraction
+    /// result in an overflow.
+    /// </summary>
+    /// <param name="a">The minuend.</param>
+    /// <param name="b">The subtrahend.</param>
+    /// <param name="c">Subtracted value.</param>
+    /// <returns>True if the subtraction led to an overflow.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool SubOverflow(uint a, uint b, out uint c)
+    {
+        c = a - b;
+        return (((a ^ b) & (a ^ c)) >> 31) != 0;
+    }
+
+    /// <summary>
+    /// Performs subtraction &amp; returns a boolean indicating whether or not did the subtraction
+    /// result in an overflow.
+    /// </summary>
+    /// <param name="a">The minuend.</param>
+    /// <param name="b">The subtrahend.</param>
+    /// <param name="c">Subtracted value.</param>
+    /// <returns>True if the subtraction led to an overflow.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool SubOverflow(int a, int b, out int c)
+    {
+        c = 0;
+        unchecked
+        {
+            return SubOverflow((uint)a, (uint)b, out Unsafe.As<int, uint>(ref c));
+        }
+    }
+
+    /// <summary>
+    /// A slow, but safe multiplication method which returns false on an overflow.
+    /// </summary>
+    /// <param name="a">The multiplier</param>
+    /// <param name="b">The multiplicand</param>
+    /// <param name="product">The resulting value (or 0 on error)</param>
+    /// <returns>
+    /// If the multiplication leads to an overflow returns false,
+    /// otherwise returns true and places the output in <paramref name="product"/>.
+    /// </returns>
+    /// <remarks>
+    /// This method is meant for unsigned multiplication only. Negative values
+    /// won't work properly.
+    /// </remarks>
+    public static bool SafeMultiply(int a, int b, out int product)
+    {
+        product = 0;
+
+        if (a == 0 || b == 0)
+        {
+            return true;
+        }
+
+        if (b > (int.MaxValue / a))
+        {
+            return false;
+        }
+
+        product = a * b;
+
+        return true;
+    }
+
+    /// <summary>
+    /// A slow, but safe multiplication method which returns false on an overflow.
+    /// </summary>
+    /// <param name="a">The multiplier</param>
+    /// <param name="b">The multiplicand</param>
+    /// <param name="product">The resulting value (or 0 on error)</param>
+    /// <returns>
+    /// If the multiplication leads to an overflow returns false,
+    /// otherwise returns true and places the output in <paramref name="product"/>.
+    /// </returns>
+    /// <remarks>
+    /// This method is meant for unsigned multiplication only. Negative values
+    /// won't work properly.
+    /// </remarks>
+    public static bool SafeMultiply(uint a, uint b, out uint product)
+    {
+        product = 0;
+
+        if (a == 0 || b == 0)
+        {
+            return true;
+        }
+
+        if (b > (uint.MaxValue / a))
+        {
+            return false;
+        }
+
+        product = a * b;
+
+        return true;
+    }
+
+    /// <summary>
+    /// Performs addition and returns a boolean indicating whether the addition led to
+    /// an overflow.
+    /// </summary>
+    /// <param name="a">The augend</param>
+    /// <param name="b">The addend</param>
+    /// <param name="sum">The resulting sum of addition.</param>
+    /// <returns>A boolean indicating whether the addition led to an overflow.</returns>
+    /// <remarks>
+    /// This method is meant for unsigned addition only. Negative values
+    /// won't work properly.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool SafeAdd(int a, int b, out int sum)
+    {
+        unchecked
+        {
+            sum = a + b;
+            return sum >= a;
+        }
+    }
+
+    /// <summary>
+    /// Performs addition and returns a boolean indicating whether the addition led to
+    /// an overflow.
+    /// </summary>
+    /// <param name="a">The augend</param>
+    /// <param name="b">The addend</param>
+    /// <param name="sum">The resulting sum of addition.</param>
+    /// <returns>A boolean indicating whether the addition led to an overflow.</returns>
+    /// <remarks>
+    /// This method is meant for unsigned addition only. Negative values
+    /// won't work properly.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool SafeAdd(long a, long b, out long sum)
+    {
+        unchecked
+        {
+            sum = a + b;
+            return sum >= a;
+        }
+    }
+
+    /// <summary>
+    /// Performs addition and returns a boolean indicating whether the addition led to
+    /// an overflow.
+    /// </summary>
+    /// <param name="a">The augend</param>
+    /// <param name="b">The addend</param>
+    /// <param name="sum">The resulting sum of addition.</param>
+    /// <returns>A boolean indicating whether the addition led to an overflow.</returns>
+    /// <remarks>
+    /// This method is meant for unsigned addition only. Negative values
+    /// won't work properly.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool SafeAdd(uint a, uint b, out uint sum)
+    {
+        unchecked
+        {
+            sum = a + b;
+            return sum >= a;
+        }
+    }
+
+    /// <summary>
+    /// Performs addition and returns a boolean indicating whether the addition led to
+    /// an overflow.
+    /// </summary>
+    /// <param name="a">The augend</param>
+    /// <param name="b">The addend</param>
+    /// <param name="sum">The resulting sum of addition.</param>
+    /// <returns>A boolean indicating whether the addition led to an overflow.</returns>
+    /// <remarks>
+    /// This method is meant for unsigned addition only. Negative values
+    /// won't work properly.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool SafeAdd(ulong a, ulong b, out ulong sum)
+    {
+        unchecked
+        {
+            sum = a + b;
+            return sum >= a;
+        }
+    }
+
+    /// <summary>
+    /// Ensures that the value stays within the specified range.
+    /// </summary>
+    /// <param name="value">The input value</param>
+    /// <param name="low">The lower bound</param>
+    /// <param name="high">The upper bound</param>
+    /// <returns>
+    /// <paramref name="low" /> if value is lower than <paramref name="low"/>. <paramref name="high"/>
+    /// if value is higher than <paramref name="high"/>. Otherwise, <paramref name="value"/> if it's within
+    /// the range.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Clamp1(int value, int low, int high) => Numerics.Clamp(value, low, high);
+
+    /// <summary>
+    /// Rounds the dimensions up to block dimensions.
+    /// </summary>
+    /// <param name="dim">The dimensions to round up to block dimensions.</param>
+    /// <returns>The rounded dimensions.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int RoundUpToBlockDimensions(int dim)
+    {
+        unchecked
+        {
+            return (dim + 7) & ~7;
+        }
+    }
+
+    /// <summary>
+    /// Rounds the dimensions up to block dimensions.
+    /// </summary>
+    /// <param name="dim">The dimensions to round up to block dimensions.</param>
+    /// <returns>The rounded dimensions.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint RoundUpToBlockDimensions(uint dim)
+    {
+        unchecked
+        {
+            return (dim + 7u) & ~7u;
+        }
+    }
+
+    /// <summary>
+    /// Rounds the specified number of bits to a multiple of bytes.
+    /// </summary>
+    /// <param name="bits">The input bits.</param>
+    /// <returns>Bits rounded to the multiples of bytes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int RoundUpBitsToByteMultiple(int bits)
+    {
+        unchecked
+        {
+            return (bits + 7) & ~7;
+        }
+    }
+
+    /// <summary>
+    /// Rounds the specified number of bits to a multiple of bytes.
+    /// </summary>
+    /// <param name="bits">The input bits.</param>
+    /// <returns>Bits rounded to the multiples of bytes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint RoundUpBitsToByteMultiple(uint bits)
+    {
+        unchecked
+        {
+            return (bits + 7u) & ~7u;
+        }
+    }
+
+    /// <summary>
+    /// Multiplies <paramref name="multiplier"/> by π.
+    /// </summary>
+    /// <param name="multiplier">The value to multiply.</param>
+    /// <returns>
+    ///   <c>multiplier * π</c>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float Pi(float multiplier) => multiplier * MathF.PI;
+
+    /// <summary>
+    /// Multiplies <paramref name="multiplier"/> by π.
+    /// </summary>
+    /// <param name="multiplier">The value to multiply.</param>
+    /// <returns>
+    ///   <c>multiplier * π</c>
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static double Pi(double multiplier) => multiplier * Math.PI;
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Num0BitsAboveMS1Bit_Nonzero(uint x)
+    {
+        DebugGuard.MustBeGreaterThan(x, 0u, nameof(x));
+
+        return BitOperations.LeadingZeroCount(x);
+    }
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Num0BitsAboveMS1Bit_Nonzero(int x)
+    {
+        unchecked
+        {
+            return Num0BitsAboveMS1Bit_Nonzero((uint)x);
+        }
+    }
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Num0BitsAboveMS1Bit_Nonzero(ulong x)
+    {
+        DebugGuard.MustBeGreaterThan(x, 0uL, nameof(x));
+
+        return BitOperations.LeadingZeroCount(x);
+    }
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Num0BitsAboveMS1Bit_Nonzero(long x)
+    {
+        unchecked
+        {
+            return Num0BitsAboveMS1Bit_Nonzero((ulong)x);
+        }
+    }
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit_Nonzero(uint x)
+    {
+        DebugGuard.MustBeGreaterThan(x, 0u, nameof(x));
+
+        return (uint)BitOperations.TrailingZeroCount(x);
+    }
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit_Nonzero(ulong x)
+    {
+        DebugGuard.MustBeGreaterThan(x, 0uL, nameof(x));
+
+        return (uint)BitOperations.TrailingZeroCount(x);
+    }
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit_Nonzero(int x) => Num0BitsBelowLS1Bit_Nonzero((uint)x);
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit_Nonzero(long x) => Num0BitsBelowLS1Bit_Nonzero((ulong)x);
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit(uint x) => x == 0 ? 32u : Num0BitsBelowLS1Bit_Nonzero(x);
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit(int x) => Num0BitsBelowLS1Bit_Nonzero((uint)x);
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit(ulong x) => x == 0 ? 64u : Num0BitsBelowLS1Bit_Nonzero(x);
+
+    /// <summary>
+    /// Returns the number of 0 bits to the right of the lowest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits after the lowest 1 bit. This is the equivalent
+    /// of trailing zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsBelowLS1Bit(long x) => Num0BitsBelowLS1Bit_Nonzero((ulong)x);
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Num0BitsAboveMS1Bit(int x) => x == 0 ? sizeof(int) * 8 : Num0BitsAboveMS1Bit_Nonzero(x);
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint Num0BitsAboveMS1Bit(uint x) => x == 0 ? sizeof(uint) * 8u : unchecked((uint)Num0BitsAboveMS1Bit_Nonzero((int)x));
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static long Num0BitsAboveMS1Bit(long x) => x == 0 ? sizeof(long) * 8L : Num0BitsAboveMS1Bit_Nonzero(x);
+
+    /// <summary>
+    /// Returns the amount of zero bits before the highest 1 bit.
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>
+    /// Number of zero bits before the highest 1 bit. This is the equivalent
+    /// of leading zero count.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong Num0BitsAboveMS1Bit(ulong x) => x == 0 ? sizeof(ulong) * 8uL : unchecked((ulong)Num0BitsAboveMS1Bit_Nonzero((long)x));
+
+    /// <summary>
+    /// Integer equivalent of MathF.Floor(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Floor(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint FloorLog2Nonzero(uint x) => (uint)(((sizeof(uint) * 8) - 1) ^ Num0BitsAboveMS1Bit_Nonzero(x));
+
+    /// <summary>
+    /// Integer equivalent of MathF.Floor(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Floor(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int FloorLog2Nonzero(int x) => ((sizeof(int) * 8) - 1) ^ Num0BitsAboveMS1Bit_Nonzero(x);
+
+    /// <summary>
+    /// Integer equivalent of MathF.Floor(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Floor(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static long FloorLog2Nonzero(long x) => ((sizeof(long) * 8) - 1) ^ Num0BitsAboveMS1Bit_Nonzero(x);
+
+    /// <summary>
+    /// Integer equivalent of MathF.Floor(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Floor(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong FloorLog2Nonzero(ulong x) => (ulong)(((sizeof(ulong) * 8) - 1) ^ Num0BitsAboveMS1Bit_Nonzero(x));
+
+    /// <summary>
+    /// Integer equivalent of MathF.Ceiling(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Ceil(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int CeilLog2Nonzero(int x)
+    {
+        int floorLog2 = FloorLog2Nonzero(x);
+
+        if ((x & (x - 1)) == 0)
+        {
+            return floorLog2;
+        }
+
+        return floorLog2 + 1;
+    }
+
+    /// <summary>
+    /// Integer equivalent of MathF.Ceiling(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Ceil(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint CeilLog2Nonzero(uint x)
+    {
+        uint floorLog2 = FloorLog2Nonzero(x);
+
+        if ((x & (x - 1)) == 0)
+        {
+            return floorLog2;
+        }
+
+        return floorLog2 + 1;
+    }
+
+    /// <summary>
+    /// Integer equivalent of MathF.Ceiling(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Ceil(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static long CeilLog2Nonzero(long x)
+    {
+        long floorLog2 = FloorLog2Nonzero(x);
+
+        if ((x & (x - 1)) == 0)
+        {
+            return floorLog2;
+        }
+
+        return floorLog2 + 1;
+    }
+
+    /// <summary>
+    /// Integer equivalent of MathF.Ceiling(MathF.Log2(x)).
+    /// </summary>
+    /// <param name="x">The input value.</param>
+    /// <returns>Ceil(Log2(x)) in integer form.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong CeilLog2Nonzero(ulong x)
+    {
+        ulong floorLog2 = FloorLog2Nonzero(x);
+
+        if ((x & (x - 1)) == 0)
+        {
+            return floorLog2;
+        }
+
+        return floorLog2 + 1;
+    }
+
+    /// <summary>
+    /// Computes the hypotenuse of x and y.
+    /// </summary>
+    /// <param name="x">X</param>
+    /// <param name="y">Y</param>
+    /// <returns>Hypotenuse of x and y</returns>
+    public static float Hypot(float x, float y) => Hypot<float>(x, y);
+
+    /// <summary>
+    /// Computes the hypotenuse of x and y.
+    /// </summary>
+    /// <param name="x">X</param>
+    /// <param name="y">Y</param>
+    /// <returns>Hypotenuse of x and y</returns>
+    public static double Hypot(double x, double y) => Hypot<double>(x, y);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static T Hypot<T>(T x, T y)
+        where T : INumber<T>, IRootFunctions<T>
+    {
+        x = T.Abs(x);
+        y = T.Abs(y);
+
+        if (x < y)
+        {
+            RuntimeUtility.Swap(ref x, ref y);
+        }
+
+        if (x == T.Zero)
+        {
+            return T.Zero;
+        }
+
+        T ratio = y / x;
+        return x * T.Sqrt(T.One + (ratio * ratio));
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlPassesSharedState.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlPassesSharedState.cs
new file mode 100644
index 0000000000..f56689382a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlPassesSharedState.cs
@@ -0,0 +1,118 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#pragma warning disable SA1401 // Fields should be private
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+internal class JxlPassesSharedState
+{
+    // Make this a field so we can get a ref to it
+    public JxlBlockContextMap BlockContextMap;
+
+    public JxlCodecMetadata CodecMetadata { get; set; } = new();
+
+    public JxlFrameDimensions FrameDimensions { get; set; }
+
+    public JxlAcStrategyImage AcStrategy { get; set; }
+
+    public JxlDequantMatrices Matrices { get; set; } = new();
+
+    public JxlQuantizer Quantizer { get; set; }
+
+    public JxlImageI RawQuantField { get; set; }
+
+    public JxlImageB EpfSharpness { get; set; }
+
+    public JxlColorCorrelationMap ColorMap { get; set; }
+
+    public JxlImageFeatures ImageFeatures { get; set; } = new();
+
+    public int CoeffOrderSize { get; set; }
+
+    public List<byte> CoeffOrders { get; set; } = [];
+
+    public JxlImageB QuantDc { get; set; }
+
+    public JxlImage3F DcStorage { get; set; }
+
+    public JxlImage3F Dc { get; set; }
+
+    public JxlImage3F[] DcFrames { get; set; } = new JxlImage3F[4];
+
+    public JxlReferenceFrame[] ReferenceFrames { get; set; } = new JxlReferenceFrame[4];
+
+    public int NumHistograms { get; set; }
+
+    public JxlPassesSharedState(Configuration configuration, JxlFrameHeader frameHeader, bool encoder)
+    {
+        if (frameHeader.Metadata is null)
+        {
+            throw new InvalidOperationException("The frame header metadata is missing");
+        }
+
+        this.CodecMetadata = frameHeader.Metadata;
+        this.FrameDimensions = frameHeader.FrameDimensions;
+        this.ImageFeatures.PatchDictionary.SetShared(this.ImageFeatures.ReferenceFrames);
+
+        JxlFrameDimensions dimensions = frameHeader.FrameDimensions;
+
+        this.AcStrategy = JxlAcStrategyImage.Create(configuration, dimensions.XSizeBlocks, dimensions.YSizeBlocks);
+        this.RawQuantField = new JxlImageI(configuration, dimensions.XSizeBlocks, dimensions.YSizeBlocks);
+        this.EpfSharpness = new JxlImageB(configuration, dimensions.XSizeBlocks, dimensions.YSizeBlocks);
+        this.ColorMap = JxlColorCorrelationMap.Create(configuration, dimensions.XSize, dimensions.YSize);
+
+        this.CoeffOrderSize = JxlCoefficientOrder.CoefficientOrderMaxSize;
+
+        if (encoder &&
+            this.CoeffOrders.Count < (frameHeader.Passes.NumPasses & JxlCoefficientOrder.CoefficientOrderMaxSize) &&
+            frameHeader.Encoding == JxlFrameEncoding.VarDct)
+        {
+            // we add the padding to CoeffOrders so its length is equal to the variable upperBound
+            int upperBound = frameHeader.Passes.NumPasses & JxlCoefficientOrder.CoefficientOrderMaxSize;
+            int length = this.CoeffOrders.Count;
+            int delta = upperBound - length;
+
+            for (int i = 0; i < delta; i++)
+            {
+                this.CoeffOrders.Add(0); // default constant
+            }
+        }
+
+        this.QuantDc = new JxlImageB(configuration, dimensions.XSizeBlocks, dimensions.YSizeBlocks);
+
+        bool useDcFrame = (frameHeader.Flags & (ulong)JxlFrameHeaderFlags.Dc) != 0;
+        if (!encoder && useDcFrame)
+        {
+            if (frameHeader.DcLevel == 4)
+            {
+                throw new InvalidOperationException("DC level for DC frames cannot be equal to 4");
+            }
+
+            this.DcStorage = new JxlImage3F();
+            this.Dc = this.DcFrames[(int)frameHeader.DcLevel];
+
+            if (this.Dc.XSize == 0)
+            {
+                throw new InvalidOperationException("DC frame was specified for DC Level = " + frameHeader.DcLevel + ", but frame wasn't decoded with level " + frameHeader.DcLevel + 1);
+            }
+
+            this.QuantDc.Clear();
+        }
+        else
+        {
+            this.DcStorage = new JxlImage3F(configuration, dimensions.XSizeBlocks, dimensions.YSizeBlocks);
+            this.Dc = this.DcStorage;
+        }
+
+        this.Quantizer = new(this.Matrices);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlPatchContext.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlPatchContext.cs
new file mode 100644
index 0000000000..a79a4720ef
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlPatchContext.cs
@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Context numbers for patch decoding
+/// </summary>
+internal enum JxlPatchContext : byte
+{
+    NumRefPatch = 0,
+
+    ReferenceFrame = 1,
+
+    PatchSize = 2,
+
+    PatchReferencePosition = 3,
+
+    PatchPosition = 4,
+
+    PatchBlendMode = 5,
+
+    PatchOffset = 6,
+
+    PatchCount = 7,
+
+    PatchAlphaChannel = 8,
+
+    PatchClamp = 9,
+
+    NumPatchDictionaryContexts
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlScopeGuard.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlScopeGuard.cs
new file mode 100644
index 0000000000..de553f17cd
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlScopeGuard.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Conditionally invokes the specified method when
+/// appropriate and when it goes out of scope.
+/// </summary>
+internal struct JxlScopeGuard(Action action) : IDisposable
+{
+    /// <summary>
+    /// When true the action will be invoked when Dispose() is called.
+    /// </summary>
+    private bool isArmed = true;
+
+    public void Disarm() => this.isArmed = false;
+
+    public readonly void Dispose()
+    {
+        if (this.isArmed)
+        {
+            action();
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlShared.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlShared.cs
new file mode 100644
index 0000000000..e8126bc4dc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlShared.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Shared JPEG XL constants
+/// </summary>
+internal static class JxlShared
+{
+    /// <summary>
+    /// Maximum number of passes in an image.
+    /// </summary>
+    public const int MaximumNumberOfPasses = 11;
+
+    /// <summary>
+    /// Maximum number of reference frames.
+    /// </summary>
+    public const int MaximumNumberOfReferenceFrames = 4;
+
+    /// <summary>
+    /// Reserved by ISO/IEC 10918-1. LF causes files opened in text mode
+    /// to be rejected because the marker changes to 0x0D instead. The
+    /// 0xFF prefix also ensures there were no 7-bit transmission limitations.
+    /// </summary>
+    public const byte CodestreamMarker = 0x0A;
+
+    /// <summary>
+    /// Gets the 12-byte signature (a.k.a. magic) for JPEG XL files.
+    /// </summary>
+    public static ReadOnlySpan<byte> SignatureBox =>
+    [
+        0x00, 0x00, 0x00, 0x0C,
+        (byte)'J', (byte)'X', (byte)'L', (byte)' ',
+        0x0D, 0x0A, 0x87, 0x0A
+    ];
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.StoreInterleaved.Generated.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.StoreInterleaved.Generated.cs
new file mode 100644
index 0000000000..8e4495e0f0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.StoreInterleaved.Generated.cs
@@ -0,0 +1,148 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+internal static partial class JxlSimdUtils
+{
+    public static unsafe void StoreInterleaved<T>(Vector<T> v1, Vector<T> v2, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector<T> v1, Vector<T> v2, Vector<T> v3, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector<T> v1, Vector<T> v2, Vector<T> v3, Vector<T> v4, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector<T> v1, Vector<T> v2, Vector<T> v3, Vector<T> v4, Vector<T> v5, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+        v5.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 4));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector<T> v1, Vector<T> v2, Vector<T> v3, Vector<T> v4, Vector<T> v5, Vector<T> v6, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+        v5.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 4));
+        v6.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 5));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector128<T> v1, Vector128<T> v2, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector128<T> v1, Vector128<T> v2, Vector128<T> v3, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector128<T> v1, Vector128<T> v2, Vector128<T> v3, Vector128<T> v4, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector128<T> v1, Vector128<T> v2, Vector128<T> v3, Vector128<T> v4, Vector128<T> v5, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+        v5.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 4));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector128<T> v1, Vector128<T> v2, Vector128<T> v3, Vector128<T> v4, Vector128<T> v5, Vector128<T> v6, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+        v5.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 4));
+        v6.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 5));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector256<T> v1, Vector256<T> v2, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector256<T> v1, Vector256<T> v2, Vector256<T> v3, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector256<T> v1, Vector256<T> v2, Vector256<T> v3, Vector256<T> v4, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector256<T> v1, Vector256<T> v2, Vector256<T> v3, Vector256<T> v4, Vector256<T> v5, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+        v5.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 4));
+    }
+
+    public static unsafe void StoreInterleaved<T>(Vector256<T> v1, Vector256<T> v2, Vector256<T> v3, Vector256<T> v4, Vector256<T> v5, Vector256<T> v6, ref T memory)
+        where T : unmanaged
+    {
+        v1.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 0));
+        v2.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 1));
+        v3.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 2));
+        v4.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 3));
+        v5.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 4));
+        v6.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * 5));
+    }
+
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.StoreInterleaved.tt b/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.StoreInterleaved.tt
new file mode 100644
index 0000000000..d4dff7ee41
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.StoreInterleaved.tt
@@ -0,0 +1,45 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".Generated.cs" #>
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+internal static partial class JxlSimdUtils
+{
+<#
+    string[] vectorTypes = [
+        "Vector<T>",
+        "Vector128<T>",
+        "Vector256<T>"
+    ];
+
+    const int maxVectorSize = 6;
+
+    foreach (string vect in vectorTypes) {
+        for (int i = 2; i <= maxVectorSize; i++) {
+            List<string> vectorParameters = [];
+            for (int j = 0; j < i; j++) {
+                vectorParameters.Add($"{vect} v{j + 1}");
+            }
+            string inlineParameters = string.Join(", ", vectorParameters) + ", ";
+#>
+    public static unsafe void StoreInterleaved<T>(<#= inlineParameters #>ref T memory)
+        where T : unmanaged
+    {
+<# for (int j = 0; j < i; j++) { #>
+        v<#= j + 1 #>.StoreUnsafe(ref Unsafe.Add(ref memory, Vector<T>.Count * <#= j #>));
+<# } #>
+    }
+
+<# } } #>
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.cs
new file mode 100644
index 0000000000..750f910383
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlSimdUtils.cs
@@ -0,0 +1,572 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Numerics.Tensors;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Shared SIMD-accelerated utilities.
+/// </summary>
+internal static partial class JxlSimdUtils
+{
+    public static int MaxVectorSize => Vector<float>.Count * sizeof(float);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<T> ConcatLowerLower<T>(Vector256<T> a, Vector256<T> b)
+        where T : unmanaged => Vector256.Create(a.GetLower(), b.GetLower());
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<T> ConcatUpperUpper<T>(Vector256<T> a, Vector256<T> b)
+        where T : unmanaged => Vector256.Create(a.GetUpper(), b.GetUpper());
+
+    public static void Transpose8x8Block(Span<int> fromSpan, Span<int> toSpan, int stride)
+    {
+        ref int from = ref MemoryMarshal.GetReference(fromSpan);
+        ref int to = ref MemoryMarshal.GetReference(toSpan);
+
+        if (Vector256.IsHardwareAccelerated)
+        {
+            Vector256<int> i0 = Vector256.LoadUnsafe(ref from);
+            Vector256<int> i1 = Vector256.LoadUnsafe(ref Unsafe.Add(ref from, stride));
+            Vector256<int> i2 = Vector256.LoadUnsafe(ref Unsafe.Add(ref from, 2 * stride));
+            Vector256<int> i3 = Vector256.LoadUnsafe(ref Unsafe.Add(ref from, 3 * stride));
+            Vector256<int> i4 = Vector256.LoadUnsafe(ref Unsafe.Add(ref from, 4 * stride));
+            Vector256<int> i5 = Vector256.LoadUnsafe(ref Unsafe.Add(ref from, 5 * stride));
+            Vector256<int> i6 = Vector256.LoadUnsafe(ref Unsafe.Add(ref from, 6 * stride));
+            Vector256<int> i7 = Vector256.LoadUnsafe(ref Unsafe.Add(ref from, 7 * stride));
+
+            Vector256<int> q0 = Vector256_.InterleaveLower(i0, i2);
+            Vector256<int> q1 = Vector256_.InterleaveLower(i1, i3);
+            Vector256<int> q2 = Vector256_.InterleaveUpper(i0, i2);
+            Vector256<int> q3 = Vector256_.InterleaveUpper(i1, i3);
+            Vector256<int> q4 = Vector256_.InterleaveLower(i4, i6);
+            Vector256<int> q5 = Vector256_.InterleaveLower(i5, i7);
+            Vector256<int> q6 = Vector256_.InterleaveUpper(i4, i6);
+            Vector256<int> q7 = Vector256_.InterleaveUpper(i5, i7);
+
+            Vector256<int> r0 = Vector256_.InterleaveLower(q0, q1);
+            Vector256<int> r1 = Vector256_.InterleaveUpper(q0, q1);
+            Vector256<int> r2 = Vector256_.InterleaveLower(q2, q3);
+            Vector256<int> r3 = Vector256_.InterleaveUpper(q2, q3);
+            Vector256<int> r4 = Vector256_.InterleaveLower(q4, q5);
+            Vector256<int> r5 = Vector256_.InterleaveUpper(q4, q5);
+            Vector256<int> r6 = Vector256_.InterleaveLower(q6, q7);
+            Vector256<int> r7 = Vector256_.InterleaveUpper(q6, q7);
+
+            i0 = ConcatLowerLower(r4, r0);
+            i1 = ConcatLowerLower(r5, r1);
+            i2 = ConcatLowerLower(r6, r2);
+            i3 = ConcatLowerLower(r7, r3);
+            i4 = ConcatUpperUpper(r4, r0);
+            i5 = ConcatUpperUpper(r5, r1);
+            i6 = ConcatUpperUpper(r6, r2);
+            i7 = ConcatUpperUpper(r7, r3);
+
+            i0.StoreUnsafe(ref to);
+            i1.StoreUnsafe(ref Unsafe.Add(ref to, 8));
+            i2.StoreUnsafe(ref Unsafe.Add(ref to, 16));
+            i3.StoreUnsafe(ref Unsafe.Add(ref to, 24));
+            i4.StoreUnsafe(ref Unsafe.Add(ref to, 32));
+            i5.StoreUnsafe(ref Unsafe.Add(ref to, 40));
+            i6.StoreUnsafe(ref Unsafe.Add(ref to, 48));
+            i7.StoreUnsafe(ref Unsafe.Add(ref to, 56));
+        }
+        else
+        {
+            // Vector128 fallback
+            for (int n = 0; n < 8; n += 4)
+            {
+                for (int m = 0; m < 8; m += 4)
+                {
+                    Vector128<int> p0 = Vector128.LoadUnsafe(ref Unsafe.Add(ref from, (n * stride) + m));
+                    Vector128<int> p1 = Vector128.LoadUnsafe(ref Unsafe.Add(ref from, ((n + 1) * stride) + m));
+                    Vector128<int> p2 = Vector128.LoadUnsafe(ref Unsafe.Add(ref from, ((n + 2) * stride) + m));
+                    Vector128<int> p3 = Vector128.LoadUnsafe(ref Unsafe.Add(ref from, ((n + 3) * stride) + m));
+
+                    Vector128<int> q0 = Vector128_.InterleaveLower(p0, p2);
+                    Vector128<int> q1 = Vector128_.InterleaveLower(p1, p3);
+                    Vector128<int> q2 = Vector128_.InterleaveUpper(p0, p2);
+                    Vector128<int> q3 = Vector128_.InterleaveUpper(p1, p3);
+
+                    Vector128<int> r0 = Vector128_.InterleaveLower(q0, q1);
+                    Vector128<int> r1 = Vector128_.InterleaveUpper(q0, q1);
+                    Vector128<int> r2 = Vector128_.InterleaveLower(q2, q3);
+                    Vector128<int> r3 = Vector128_.InterleaveUpper(q2, q3);
+
+                    r0.StoreUnsafe(ref Unsafe.Add(ref to, (m * 8) + n));
+                    r1.StoreUnsafe(ref Unsafe.Add(ref to, ((m + 1) * 8) + n));
+                    r2.StoreUnsafe(ref Unsafe.Add(ref to, ((m + 2) * 8) + n));
+                    r3.StoreUnsafe(ref Unsafe.Add(ref to, ((m + 3) * 8) + n));
+                }
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> Pow(Vector<float> @base, Vector<float> exponent)
+    {
+        Vector<float> vec = Vector.Log2(@base) * exponent;
+        return vec * vec;
+    }
+
+    /// <summary>
+    ///   <para>
+    ///     Fills the span so its first value is equal to <paramref name="start"/>
+    ///     and subsequent values increment by one. For example, with start=5,
+    ///     the span's values will be:
+    ///     <code>
+    ///       { start, start+1, start+2, start+3, start+4, ... to the end of the span }
+    ///     </code>
+    ///   </para>
+    ///   <para>
+    ///     or, more precisely:
+    ///     <code>
+    ///       { 5, 6, 7, 8, 9, 10, 11, ... to the end of the span }
+    ///     </code>
+    ///   </para>
+    ///   <seealso href="https://en.cppreference.com/cpp/algorithm/iota" />
+    /// </summary>
+    /// <param name="span">The span where the values are filled.</param>
+    /// <param name="start">Initial value.</param>
+    public static void Iota(Span<int> span, int start)
+    {
+        ref int spanRef = ref MemoryMarshal.GetReference(span);
+
+        // Using fixed-size vectors so we can construct an
+        // incrementMask more easily.
+        if (Vector512.IsHardwareAccelerated)
+        {
+            Vector512<int> incrementMask = Vector512.Create(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+            Vector512<int> v = Vector512.Create(start) + (incrementMask - Vector512<int>.One);
+
+            if ((span.Length % Vector512<int>.Count) == 0)
+            {
+                // Aligned length
+                for (int i = 0; i < span.Length; i += Vector512<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+            }
+            else
+            {
+                // We will need a scalar remainder
+                int vectorLength = span.Length - (span.Length % Vector512<int>.Count);
+
+                int i;
+                for (i = 0; i < vectorLength; i += Vector512<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+
+                int val = v.ToScalar();
+                for (; i < span.Length; i++)
+                {
+                    Unsafe.Add(ref spanRef, i) = val++;
+                }
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated)
+        {
+            Vector256<int> incrementMask = Vector256.Create(1, 2, 3, 4, 5, 6, 7, 8);
+            Vector256<int> v = Vector256.Create(start) + (incrementMask - Vector256<int>.One);
+
+            if ((span.Length % Vector256<int>.Count) == 0)
+            {
+                // Aligned length
+                for (int i = 0; i < span.Length; i += Vector256<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+            }
+            else
+            {
+                // We will need a scalar remainder
+                int vectorLength = span.Length - (span.Length % Vector256<int>.Count);
+
+                int i;
+                for (i = 0; i < vectorLength; i += Vector256<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+
+                int val = v.ToScalar();
+                for (; i < span.Length; i++)
+                {
+                    Unsafe.Add(ref spanRef, i) = val++;
+                }
+            }
+        }
+        else if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<int> incrementMask = Vector128.Create(1, 2, 3, 4);
+            Vector128<int> v = Vector128.Create(start) + (incrementMask - Vector128<int>.One);
+
+            if ((span.Length % Vector128<int>.Count) == 0)
+            {
+                // Aligned length
+                for (int i = 0; i < span.Length; i += Vector128<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+            }
+            else
+            {
+                // We will need a scalar remainder
+                int vectorLength = span.Length - (span.Length % Vector128<int>.Count);
+
+                int i;
+                for (i = 0; i < vectorLength; i += Vector128<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+
+                int val = v.ToScalar();
+                for (; i < span.Length; i++)
+                {
+                    Unsafe.Add(ref spanRef, i) = val++;
+                }
+            }
+        }
+        else if (Vector64.IsHardwareAccelerated)
+        {
+            Vector64<int> incrementMask = Vector64.Create(1, 2);
+            Vector64<int> v = Vector64.Create(start) + (incrementMask - Vector64<int>.One);
+
+            if ((span.Length % Vector64<int>.Count) == 0)
+            {
+                // Aligned length
+                for (int i = 0; i < span.Length; i += Vector64<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+            }
+            else
+            {
+                // We will need a scalar remainder
+                int vectorLength = span.Length - (span.Length % Vector64<int>.Count);
+
+                int i;
+                for (i = 0; i < vectorLength; i += Vector64<int>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+
+                int val = v.ToScalar();
+                for (; i < span.Length; i++)
+                {
+                    Unsafe.Add(ref spanRef, i) = val++;
+                }
+            }
+        }
+        else
+        {
+            // No SIMD
+            int value = start;
+            spanRef = value;
+            value++;
+            for (int i = 1; i < span.Length; i++)
+            {
+                Unsafe.Add(ref spanRef, i) = value++;
+            }
+        }
+    }
+
+    /// <summary>
+    ///   <para>
+    ///     Fills the span so its first value is equal to <paramref name="start"/>
+    ///     and subsequent values increment by one. For example, with start=5,
+    ///     the span's values will be:
+    ///     <code>
+    ///       { start, start+1, start+2, start+3, start+4, ... to the end of the span }
+    ///     </code>
+    ///   </para>
+    ///   <para>
+    ///     or, more precisely:
+    ///     <code>
+    ///       { 5, 6, 7, 8, 9, 10, 11, ... to the end of the span }
+    ///     </code>
+    ///   </para>
+    ///   <seealso href="https://en.cppreference.com/cpp/algorithm/iota" />
+    /// </summary>
+    /// <param name="span">The span where the values are filled.</param>
+    /// <param name="start">Initial value.</param>
+    public static void Iota<T>(Span<T> span, T start)
+        where T : unmanaged, INumber<T>
+    {
+        // Slightly slower than the int variant
+        ref T spanRef = ref MemoryMarshal.GetReference(span);
+
+        if (Vector<T>.IsSupported && Vector.IsHardwareAccelerated)
+        {
+            Vector<T> incrementMask = IotaMask<T>.IncrementMask;
+            Vector<T> v = Vector.Create(start) + (incrementMask - Vector<T>.One);
+
+            if ((span.Length % Vector<T>.Count) == 0)
+            {
+                // Aligned length
+                for (int i = 0; i < span.Length; i += Vector<T>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+            }
+            else
+            {
+                // Remainder needed
+                int vectorLength = span.Length - (span.Length % Vector<T>.Count);
+
+                int i;
+                for (i = 0; i < vectorLength; i += Vector<T>.Count)
+                {
+                    v.StoreUnsafe(ref Unsafe.Add(ref spanRef, i));
+                    v += incrementMask;
+                }
+
+                T val = v.ToScalar();
+                for (; i < span.Length; i++)
+                {
+                    Unsafe.Add(ref spanRef, i) = val++;
+                }
+            }
+        }
+        else
+        {
+            // Scalar (slow)
+            T value = start;
+            spanRef = value;
+            value++;
+            for (int i = 1; i < span.Length; i++)
+            {
+                Unsafe.Add(ref spanRef, i) = value++;
+            }
+        }
+    }
+
+    public static Vector<T> Iota<T>(T start)
+        where T : unmanaged, INumber<T>
+        => IotaMask<T>.IncrementMask + Vector.Create(start);
+
+    /// <summary>
+    /// Vectorized floating-point error function (precise approximate).
+    /// </summary>
+    /// <param name="x">Vector to compute error of.</param>
+    /// <returns>Vector whose each item is an error (similar to std::erf).</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> FastErff(Vector<float> x)
+    {
+        Vector<float> zero = Vector<float>.Zero;
+        Vector<float> one = Vector<float>.One;
+
+        Vector<int> xle0 = Vector.LessThanOrEqual(x, zero);
+        Vector<float> absx = Vector.Abs(x);
+
+        Vector<float> denom1 = (absx * new Vector<float>(0.0777394369f)) + new Vector<float>(0.000205260015f);
+        Vector<float> denom2 = (denom1 * absx) + new Vector<float>(0.232120216f);
+        Vector<float> denom3 = (denom2 * absx) + new Vector<float>(0.277820801f);
+        Vector<float> denom4 = (denom3 * absx) + one;
+        Vector<float> denom5 = denom4 * denom4;
+        Vector<float> invDenom5 = one / denom5;
+        Vector<float> result = one - Vector.Multiply(invDenom5, invDenom5);
+
+        // Change sign if x <= 0.
+        return Vector.ConditionalSelect(xle0, -result, result);
+    }
+
+    /// <summary>
+    /// Scalar floating-point error function (precise approximate).
+    /// </summary>
+    /// <param name="x">Value to compute error of.</param>
+    /// <returns>A scalar error value (similar to std::erf).</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float FastErff(float x)
+    {
+        float zero = 0.0f;
+        float one = 1.0f;
+
+        bool xle0 = x <= zero;
+        float absx = MathF.Abs(x);
+
+        float denom1 = (absx * 0.0777394369f) + 0.000205260015f;
+        float denom2 = (denom1 * absx) + 0.232120216f;
+        float denom3 = (denom2 * absx) + 0.277820801f;
+        float denom4 = (denom3 * absx) + one;
+        float denom5 = denom4 * denom4;
+        float invDenom5 = one / denom5;
+        float result = one - (invDenom5 * invDenom5);
+
+        // Change sign if x <= 0.
+        return xle0 ? -result : result;
+    }
+
+    // Raises 2 to the power of x
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<float> FastPow2f(Vector128<float> x)
+    {
+        Vector128<float> floorX = Vector128.Floor(x);
+        Vector128<int> exponent = Vector128.ConvertToInt32(floorX) + Vector128.Create(127);
+
+        Vector128<float> exp = exponent.AsSingle() << 23;
+        Vector128<float> frac = x - floorX;
+        Vector128<float> num = frac + Vector128.Create(1.01749063e+01f);
+
+        num = Vector128.FusedMultiplyAdd(
+            num,
+            frac,
+            Vector128.Create(4.88687798e+01f));
+
+        num = Vector128.FusedMultiplyAdd(
+            num,
+            frac,
+            Vector128.Create(9.85506591e+01f));
+
+        num *= exp;
+
+        Vector128<float> den =
+            Vector128.FusedMultiplyAdd(
+                frac,
+                Vector128.Create(2.10242958e-01f),
+                Vector128.Create(-2.22328856e-02f));
+
+        den = Vector128.FusedMultiplyAdd(
+            den,
+            frac,
+            Vector128.Create(-1.94414990e+01f));
+
+        den = Vector128.FusedMultiplyAdd(
+            den,
+            frac,
+            Vector128.Create(9.85506633e+01f));
+
+        return num / den;
+    }
+
+    // Raises 2 to the power of x
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> FastPow2f(Vector<float> x)
+    {
+        Vector<float> floorX = Vector.Floor(x);
+        Vector<int> exponent = Vector.ConvertToInt32(floorX) + Vector.Create(127);
+
+        Vector<float> exp = exponent.As<int, float>() << 23;
+        Vector<float> frac = x - floorX;
+        Vector<float> num = frac + Vector.Create(1.01749063e+01f);
+
+        num = Vector.FusedMultiplyAdd(
+            num,
+            frac,
+            Vector.Create(4.88687798e+01f));
+
+        num = Vector.FusedMultiplyAdd(
+            num,
+            frac,
+            Vector.Create(9.85506591e+01f));
+
+        num *= exp;
+
+        Vector<float> den =
+            Vector.FusedMultiplyAdd(
+                frac,
+                Vector.Create(2.10242958e-01f),
+                Vector.Create(-2.22328856e-02f));
+
+        den = Vector.FusedMultiplyAdd(
+            den,
+            frac,
+            Vector.Create(-1.94414990e+01f));
+
+        den = Vector.FusedMultiplyAdd(
+            den,
+            frac,
+            Vector.Create(9.85506633e+01f));
+
+        return num / den;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<float> FastPowf(
+        Vector128<float> @base,
+        Vector128<float> exponent)
+        => FastPow2f(Vector128.Log2(@base) * exponent);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector<float> FastPowf(
+        Vector<float> @base,
+        Vector<float> exponent)
+        => FastPow2f(Vector.Log2(@base) * exponent);
+
+    public static uint MaxValue(Span<uint> data)
+    {
+        int lanes = Vector<uint>.Count;
+        int lastFull = lanes * (data.Length / lanes);
+
+        Vector<uint> max = Vector<uint>.Zero;
+        ref uint dataRef = ref MemoryMarshal.GetReference(data);
+
+        for (int i = 0; i < lastFull; i += lanes)
+        {
+            max = Vector.Max(max, Vector.LoadUnsafe(ref Unsafe.Add(ref dataRef, i)));
+        }
+
+        if (lastFull < data.Length)
+        {
+            Vector<uint> stop = Vector.Create((uint)data.Length);
+            Vector<uint> fence = Iota((uint)lastFull);
+            Vector<uint> take = Vector.LessThan(fence, stop);
+            max = Vector.Max(
+                max,
+                Vector.ConditionalSelect(
+                    take,
+                    Vector.LoadUnsafe(ref Unsafe.Add(ref dataRef, lastFull)),
+                    Vector<uint>.Zero));
+        }
+
+        // The following part is to find the largest number in
+        // the vector.
+        Span<uint> copy = stackalloc uint[Vector<uint>.Count];
+        max.CopyTo(copy);
+        return TensorPrimitives.Max<uint>(copy);
+    }
+
+    /// <summary>
+    /// Incrementing values to compute the Iota function.
+    /// </summary>
+    /// <remarks>
+    /// Creating a Vector&lt;T&gt; incrementing values would be
+    /// slow as Vector&lt;T&gt; is not a fixed-size vector, leaving
+    /// no other option but a slow loop. This class caches these
+    /// vectors for significantly better performance, though still
+    /// not as fast as an int variant.
+    /// </remarks>
+    /// <typeparam name="T">Type of the vector.</typeparam>
+    private static class IotaMask<T>
+        where T : unmanaged, INumber<T>
+    {
+        public static readonly Vector<T> IncrementMask;
+
+        static IotaMask()
+        {
+            Span<T> values = stackalloc T[Vector<T>.Count];
+
+            for (int i = 0; i < Vector<T>.Count; i++)
+            {
+                values[i] = T.CreateSaturating(i + 1);
+            }
+
+            IncrementMask = Vector.Create<T>(values);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlToc.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlToc.cs
new file mode 100644
index 0000000000..d3de060b83
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlToc.cs
@@ -0,0 +1,192 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Table of Contents encoding
+/// </summary>
+internal static class JxlToc
+{
+    private const int BitsPerByte = 8;
+
+    private const int MaxTocEntries = 65536;
+
+    public static readonly JxlU32Enc TocDistribution = new(
+        JxlFieldExpressions.Bits(10),
+        JxlFieldExpressions.BitsOffset(14, 2024),
+        JxlFieldExpressions.BitsOffset(22, 17408),
+        JxlFieldExpressions.BitsOffset(30, 4211712));
+
+    public static int MaxBits(int numSizes)
+    {
+        int entryBits = JxlU32Coder.MaxEncodedBits(TocDistribution) * numSizes;
+        return 1 + JxlMath.BitsPerByte + entryBits + JxlMath.BitsPerByte;
+    }
+
+    public static int AcGroupIndex(int pass, int group, int numGroups, int numDcGroups)
+        => 2 + numDcGroups + (pass * numGroups) + group;
+
+    public static int NumberOfTocEntries(int numGroups, int numDcGroups, int numPasses)
+    {
+        if (numGroups == 1 && numPasses == 1)
+        {
+            return 1;
+        }
+
+        return AcGroupIndex(0, 0, numGroups, numDcGroups) + (numGroups * numPasses);
+    }
+
+    public static bool ReadToc(
+        Configuration configuration,
+        int tocEntries,
+        JxlBitReader reader,
+        List<uint> sizes,
+        List<byte> permutation)
+    {
+        if (tocEntries > MaxTocEntries)
+        {
+            return false; // too many TOC entries
+        }
+
+        sizes.Clear();
+        sizes.Capacity = tocEntries;
+
+        for (int i = 0; i < tocEntries; i++)
+        {
+            sizes.Add(0);
+        }
+
+        if (reader.TotalBitsConsumed >= reader.TotalBytes * BitsPerByte)
+        {
+            return false; // not enough bytes
+        }
+
+        bool CheckBitBudget(int numEntries)
+        {
+            long minimalBitCost = numEntries * (2 + 10);
+            long bitBudget = reader.TotalBytes * BitsPerByte;
+            long expenses = reader.TotalBitsConsumed;
+
+            return expenses <= bitBudget &&
+                minimalBitCost <= bitBudget - expenses;
+        }
+
+        if (tocEntries <= 0)
+        {
+            return false;
+        }
+
+        if (reader.ReadBits32(1) == 1)
+        {
+            if (!CheckBitBudget(tocEntries))
+            {
+                return false;
+            }
+
+            permutation.Clear();
+
+            for (int i = 0; i < tocEntries; i++)
+            {
+                permutation.Add(default);
+            }
+
+            if (!DecodePermutation(
+                    configuration,
+                    0,
+                    tocEntries,
+                    permutation,
+                    reader))
+            {
+                return false;
+            }
+        }
+
+        reader.JumpToByteBoundary();
+
+        if (!CheckBitBudget(tocEntries))
+        {
+            return false;
+        }
+
+        for (int i = 0; i < tocEntries; i++)
+        {
+            sizes[i] = JxlU32Coder.Read(TocDistribution, reader);
+        }
+
+        reader.JumpToByteBoundary();
+
+        return CheckBitBudget(0);
+    }
+
+    public static bool ReadGroupOffsets(
+        Configuration configuration,
+        int tocEntries,
+        JxlBitReader reader,
+        List<ulong> offsets,
+        List<uint> sizes,
+        out ulong totalSize)
+    {
+        totalSize = 0;
+
+        List<byte> permutation = [];
+
+        if (!ReadToc(
+                configuration,
+                tocEntries,
+                reader,
+                sizes,
+                permutation))
+        {
+            return false;
+        }
+
+        offsets.Clear();
+        offsets.Capacity = tocEntries;
+
+        for (int i = 0; i < tocEntries; i++)
+        {
+            offsets.Add(0);
+        }
+
+        ulong offset = 0;
+
+        for (int i = 0; i < tocEntries; i++)
+        {
+            ulong size = sizes[i];
+
+            if (offset + size < offset)
+            {
+                return false;
+            }
+
+            offsets[i] = offset;
+            offset += size;
+        }
+
+        totalSize = offset;
+
+        if (permutation.Count != 0)
+        {
+            List<ulong> permutedOffsets = new(tocEntries);
+            List<uint> permutedSizes = new(tocEntries);
+
+            foreach (byte index in permutation)
+            {
+                permutedOffsets.Add(offsets[index]);
+                permutedSizes.Add(sizes[index]);
+            }
+
+            offsets.Clear();
+            offsets.AddRange(permutedOffsets);
+
+            sizes.Clear();
+            sizes.AddRange(permutedSizes);
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlTranspose.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlTranspose.cs
new file mode 100644
index 0000000000..5797553f54
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlTranspose.cs
@@ -0,0 +1,135 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+/// <summary>
+/// Performs transpose on JPEG XL DCT blocks.
+/// </summary>
+internal static class JxlTranspose
+{
+    public static void Transpose(int r, int c, JxlDctSource from, JxlDctOutput to)
+    {
+        if (Vector256.IsHardwareAccelerated)
+        {
+            if (((r | c) & 7) == 0) // equivalent to (r % 8 == 0 && c % 8 == 0); micro-optimization, reduces one branch
+            {
+                // we can use SIMD
+                TransposeSimd256(r, c, from, to, r, c);
+                return;
+            }
+        }
+        else if (Vector128.IsHardwareAccelerated)
+        {
+            if (((r | c) & 3) == 0) // equivalent to (r % 4 == 0 && c % 4 == 0); micro-optimization, reduces one branch
+            {
+                // we can use SIMD
+                TransposeSimd128(r, c, from, to, r, c);
+                return;
+            }
+        }
+
+        // fallback: can't use SIMD (block size isn't aligned or
+        // there's no v128/v256 support)
+        for (int n = 0; n < r; n++)
+        {
+            for (int m = 0; m < c; m++)
+            {
+                to.Write(from.Read(n, m), m, n);
+            }
+        }
+    }
+
+    private static void TransposeSimd256(int rowsOr0, int colsOr0, JxlDctSource from, JxlDctOutput to, int rowsP, int colsP)
+    {
+        int rows = rowsOr0 == 0 ? rowsP : rowsOr0;
+        int cols = colsOr0 == 0 ? colsP : colsOr0;
+
+        for (int n = 0; n < rows; n += 8)
+        {
+            for (int m = 0; m < cols; m += 8)
+            {
+                Vector256<float> i0 = from.LoadPart256(n, m);
+                Vector256<float> i1 = from.LoadPart256(n + 1, m);
+                Vector256<float> i2 = from.LoadPart256(n + 2, m);
+                Vector256<float> i3 = from.LoadPart256(n + 3, m);
+                Vector256<float> i4 = from.LoadPart256(n + 4, m);
+                Vector256<float> i5 = from.LoadPart256(n + 5, m);
+                Vector256<float> i6 = from.LoadPart256(n + 6, m);
+                Vector256<float> i7 = from.LoadPart256(n + 7, m);
+
+                Vector256<float> q0 = Vector256_.InterleaveLower(i0, i2);
+                Vector256<float> q1 = Vector256_.InterleaveLower(i1, i3);
+                Vector256<float> q2 = Vector256_.InterleaveUpper(i0, i2);
+                Vector256<float> q3 = Vector256_.InterleaveUpper(i1, i3);
+                Vector256<float> q4 = Vector256_.InterleaveLower(i4, i6);
+                Vector256<float> q5 = Vector256_.InterleaveLower(i5, i7);
+                Vector256<float> q6 = Vector256_.InterleaveUpper(i4, i6);
+                Vector256<float> q7 = Vector256_.InterleaveUpper(i5, i7);
+
+                Vector256<float> r0 = Vector256_.InterleaveLower(q0, q1);
+                Vector256<float> r1 = Vector256_.InterleaveUpper(q0, q1);
+                Vector256<float> r2 = Vector256_.InterleaveLower(q2, q3);
+                Vector256<float> r3 = Vector256_.InterleaveUpper(q2, q3);
+                Vector256<float> r4 = Vector256_.InterleaveLower(q4, q5);
+                Vector256<float> r5 = Vector256_.InterleaveUpper(q4, q5);
+                Vector256<float> r6 = Vector256_.InterleaveLower(q6, q7);
+                Vector256<float> r7 = Vector256_.InterleaveUpper(q6, q7);
+
+                i0 = JxlSimdUtils.ConcatLowerLower(r4, r0);
+                i1 = JxlSimdUtils.ConcatLowerLower(r5, r1);
+                i2 = JxlSimdUtils.ConcatLowerLower(r6, r2);
+                i3 = JxlSimdUtils.ConcatLowerLower(r7, r3);
+                i4 = JxlSimdUtils.ConcatUpperUpper(r4, r0);
+                i5 = JxlSimdUtils.ConcatUpperUpper(r5, r1);
+                i6 = JxlSimdUtils.ConcatUpperUpper(r6, r2);
+                i7 = JxlSimdUtils.ConcatUpperUpper(r7, r3);
+
+                to.StorePart256(i0, m, n);
+                to.StorePart256(i1, m + 1, n);
+                to.StorePart256(i2, m + 2, n);
+                to.StorePart256(i3, m + 3, n);
+                to.StorePart256(i4, m + 4, n);
+                to.StorePart256(i5, m + 5, n);
+                to.StorePart256(i6, m + 6, n);
+                to.StorePart256(i7, m + 7, n);
+            }
+        }
+    }
+
+    private static void TransposeSimd128(int rowsOr0, int colsOr0, JxlDctSource from, JxlDctOutput to, int rowsP, int colsP)
+    {
+        int rows = rowsOr0 == 0 ? rowsP : rowsOr0;
+        int cols = colsOr0 == 0 ? colsP : colsOr0;
+
+        for (int n = 0; n < rows; n += 4)
+        {
+            for (int m = 0; m < cols; m += 4)
+            {
+                Vector128<float> p0 = from.LoadPart128(n, m);
+                Vector128<float> p1 = from.LoadPart128(n + 1, m);
+                Vector128<float> p2 = from.LoadPart128(n + 2, m);
+                Vector128<float> p3 = from.LoadPart128(n + 3, m);
+
+                Vector128<float> q0 = Vector128_.InterleaveLower(p0, p2);
+                Vector128<float> q1 = Vector128_.InterleaveLower(p1, p3);
+                Vector128<float> q2 = Vector128_.InterleaveUpper(p0, p2);
+                Vector128<float> q3 = Vector128_.InterleaveUpper(p1, p3);
+
+                Vector128<float> r0 = Vector128_.InterleaveLower(q0, q1);
+                Vector128<float> r1 = Vector128_.InterleaveUpper(q0, q1);
+                Vector128<float> r2 = Vector128_.InterleaveLower(q2, q3);
+                Vector128<float> r3 = Vector128_.InterleaveUpper(q2, q3);
+
+                to.StorePart128(r0, m, n);
+                to.StorePart128(r1, m + 1, n);
+                to.StorePart128(r2, m + 2, n);
+                to.StorePart128(r3, m + 3, n);
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/JxlUnsafe.cs b/src/ImageSharp/Formats/Jxl/Processing/JxlUnsafe.cs
new file mode 100644
index 0000000000..5060a08c66
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/JxlUnsafe.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+internal static unsafe class JxlUnsafe
+{
+    public static bool IsSimdAligned<T>(T* ptr)
+        where T : unmanaged
+        => IsAligned(ptr, Vector<T>.Count * sizeof(T));
+
+    public static bool IsAligned<T>(T* ptr, int alignment)
+        where T : unmanaged
+        => ((long)ptr % alignment) == 0;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlContextPrediction.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlContextPrediction.cs
new file mode 100644
index 0000000000..b2add731ad
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlContextPrediction.cs
@@ -0,0 +1,485 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Context prediction helper methods.
+/// </summary>
+internal static class JxlContextPrediction
+{
+    public const int ExtraPropertiesPerChannel = 4;
+
+    public const int NumberOfProperties = 1;
+
+    public static void SetPredictorMode(int i, JxlModularHeader header)
+    {
+        Span<uint> w = header.GetW();
+
+        switch (i)
+        {
+            case 0:
+                // ~ lossless16 predictor
+                w[0] = 0xd;
+                w[1] = 0xc;
+                w[2] = 0xc;
+                w[3] = 0xc;
+                header.P1C = 16;
+                header.P2C = 10;
+                header.P3Ca = 7;
+                header.P3Cb = 7;
+                header.P3Cc = 7;
+                header.P3Cd = 0;
+                header.P3Ce = 0;
+                break;
+
+            case 1:
+                // ~ default lossless8 predictor
+                w[0] = 0xd;
+                w[1] = 0xc;
+                w[2] = 0xc;
+                w[3] = 0xb;
+                header.P1C = 8;
+                header.P2C = 8;
+                header.P3Ca = 4;
+                header.P3Cb = 0;
+                header.P3Cc = 3;
+                header.P3Cd = 23;
+                header.P3Ce = 2;
+                break;
+
+            case 2:
+                // ~ west lossless8 predictor
+                w[0] = 0xd;
+                w[1] = 0xc;
+                w[2] = 0xd;
+                w[3] = 0xc;
+                header.P1C = 10;
+                header.P2C = 9;
+                header.P3Ca = 7;
+                header.P3Cb = 0;
+                header.P3Cc = 0;
+                header.P3Cd = 16;
+                header.P3Ce = 9;
+                break;
+
+            case 3:
+                // ~ north lossless8 predictor
+                w[0] = 0xd;
+                w[1] = 0xd;
+                w[2] = 0xc;
+                w[3] = 0xc;
+                header.P1C = 16;
+                header.P2C = 8;
+                header.P3Ca = 0;
+                header.P3Cb = 16;
+                header.P3Cc = 0;
+                header.P3Cd = 23;
+                header.P3Ce = 0;
+                break;
+
+            case 4:
+            default:
+                // something else, because why not
+                w[0] = 0xd;
+                w[1] = 0xc;
+                w[2] = 0xc;
+                w[3] = 0xc;
+                header.P1C = 10;
+                header.P2C = 10;
+                header.P3Ca = 5;
+                header.P3Cb = 5;
+                header.P3Cc = 5;
+                header.P3Cd = 12;
+                header.P3Ce = 4;
+                break;
+        }
+    }
+
+    /// <summary>
+    /// Returns true if the (meta)predictor makes use of the weighted predictor.
+    /// </summary>
+    /// <param name="predictor">The input predictor.</param>
+    /// <returns>Value indicating whether the predictor uses weighted prediction.</returns>
+    public static bool IsWeightedPredictor(JxlPredictor predictor) => predictor switch
+    {
+        JxlPredictor.Zero or
+            JxlPredictor.Left or
+            JxlPredictor.Top or
+            JxlPredictor.Average0 or
+            JxlPredictor.Select or
+            JxlPredictor.Gradient => false,
+
+        JxlPredictor.Weighted => true,
+
+        JxlPredictor.TopRight or
+            JxlPredictor.TopLeft or
+            JxlPredictor.LeftLeft or
+            JxlPredictor.Average1 or
+            JxlPredictor.Average2 or
+            JxlPredictor.Average3 or
+            JxlPredictor.Average4 => false,
+
+        JxlPredictor.Best or
+            JxlPredictor.Variable => true,
+
+        _ => false,
+    };
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int ClampedGradient(int n, int w, int l)
+    {
+        int min = Math.Min(n, w);
+        int max = Math.Max(n, w);
+
+        int gradient = n + w - l;
+
+        int clamp = l < min ? max : gradient;
+        return l > max ? min : clamp;
+    }
+
+    // This is actually a simple Paeth predictor, we'd often see
+    // this in PNG files
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Select(int a, int b, int c)
+    {
+        int p = a + b - c;
+        int pa = Numerics.Abs(p - a);
+        int pb = Numerics.Abs(p - b);
+        return pa < pb ? a : b;
+    }
+
+    public static void PrecomputeReferences(JxlModularChannel channel, int y, JxlModularImage image, int i, JxlModularChannel references)
+    {
+        references.Plane.Clear();
+        int offset = 0;
+        int numExtraProps = references.Width;
+        int oneRow = references.Plane.PixelsPerRow;
+        JxlModularChannel channelI = image.Channels[i];
+
+        for (int j = i - 1; i >= 0 && offset < numExtraProps; j--)
+        {
+            JxlModularChannel channelJ = image.Channels[j];
+
+            if (channelJ.Width != channelI.Width || channelJ.Height != channelI.Height)
+            {
+                continue;
+            }
+
+            if (channelJ.HorizontalShift != channelI.HorizontalShift ||
+                channelJ.VerticalShift != channelI.VerticalShift)
+            {
+                continue;
+            }
+
+            Span<int> rp = references.GetRow(0)[offset..];
+            Span<int> rpp = channelJ.GetRow(y);
+            Span<int> rpprev = channelJ.GetRow(y > 0 ? y - 1 : 0);
+
+            for (int x = 0; x < channel.Width; x++, rp = rp[oneRow..])
+            {
+                int v = rpp[x];
+                rp[0] = Numerics.Abs(v);
+                rp[1] = v;
+
+                // Neighboring variables
+                int vleft = x > 0 ? rpp[x - 1] : 0;
+                int vtop = y > 0 ? rpprev[x] : vleft;
+                int vtopleft = x > 0 && y > 0 ? rpprev[x - 1] : vleft;
+
+                // Prediction
+                int vpredicted = ClampedGradient(vleft, vtop, vtopleft);
+                rp[2] = Numerics.Abs(v - vpredicted);
+                rp[3] = v - vpredicted;
+            }
+
+            offset += ExtraPropertiesPerChannel;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void InitializePropertiesForRow(Span<int> p, InlineArray2<int> staticProperties, int y)
+    {
+        p[0] = staticProperties[0];
+        p[1] = staticProperties[1];
+        p[2] = y;
+        p[9] = 0; // Local gradient
+    }
+
+    // Prediction for one pixel using neighbors
+    [MethodImpl(InliningOptions.HotPath)] // This method is called frequently
+    public static int PredictOne(
+        JxlPredictor p,
+        int left,
+        int top,
+        int toptop,
+        int topleft,
+        int topright,
+        int leftleft,
+        int toprightright,
+        int wpPred) => p switch
+        {
+            JxlPredictor.Zero => 0,
+            JxlPredictor.Left => left,
+            JxlPredictor.Top => top,
+            JxlPredictor.Select => Select(left, top, topleft),
+            JxlPredictor.Weighted => wpPred,
+            JxlPredictor.Gradient => ClampedGradient(left, top, topleft),
+            JxlPredictor.TopLeft => topleft,
+            JxlPredictor.TopRight => topright,
+            JxlPredictor.LeftLeft => leftleft,
+            JxlPredictor.Average0 => (left + top) / 2,
+            JxlPredictor.Average1 => (left + topleft) / 2,
+            JxlPredictor.Average2 => (topleft + top) / 2,
+            JxlPredictor.Average3 => (top + topright) / 2,
+            JxlPredictor.Average4 => ((6 * top) - (2 * toptop) + (7 * left) + (1 * leftleft) +
+                                    (1 * toprightright) + (3 * topright) + 8) /
+                                   16,
+            _ => 0,
+        };
+
+    public static JxlPredictionResult Predict(
+        JxlPredictorMode mode,
+        Span<int> p, // contains properties
+        int w, // block width
+        ref int pp, // This is a reference to the output pixel stored in row-major order. Negative offsets are accessed to reference other pixels in the image, specifically neighboring pixles.
+        int oneRow, // Number of pixels on one row
+        int x,
+        int y,
+        JxlPredictor predictor,
+        JxlMaTreeLookup? lookup,
+        JxlModularChannel? references,
+        JxlModularState? wpState,
+        Span<int> predictions)
+    {
+        int offset = 3; // Start at position 3 because of 2 static properties + y
+
+        // Status flags
+        // computeProperties = should the p (properties) variable be updated?
+        // nec = are there no edge cases?
+        bool computeProperties = (mode & JxlPredictorMode.UseTree) != 0 || (mode & JxlPredictorMode.ForceComputeProperties) != 0;
+        bool nec = (mode & JxlPredictorMode.NoEdgeCases) != 0;
+
+        // The following variables are neighboring pixels relative to the pixel to predict.
+        // Pixels may be unavailable and therefore replaced with default values. For example,
+        // at Y=0, the top pixel may not be available because we're already at the very top
+        // of the image, there's no "above" of that.
+        int left = nec || x > 0 ? Unsafe.Subtract(ref pp, 1) : (y > 0 ? Unsafe.Subtract(ref pp, oneRow) : 0); // ⬅️ (or 0 if unavailable)
+        int top = nec || y > 0 ? Unsafe.Subtract(ref pp, oneRow) : left; // ⬆️ (or ⬅️ if unavailable)
+        int topleft = nec || (x > 0 && y > 0) ? Unsafe.Add(ref pp, -1 - oneRow) : left; // ↗️ (or ⬅️ if unavailable)
+        int topright = nec || (x + 1 < w && y > 0) ? Unsafe.Add(ref pp, 1 - oneRow) : top; // ↖️ (or ⬆️ if unavailable)
+        int leftleft = nec || x > 1 ? Unsafe.Subtract(ref pp, 2) : left; // ⬅️⬅️ (or ⬅️ if unavailable)
+        int toptop = nec || y > 1 ? Unsafe.Add(ref pp, -oneRow - oneRow) : top; // ⬆️⬆️ (or ⬆️ if unavailable)
+        int toprightright = nec || (x + 2 < w && y > 0) ? Unsafe.Add(ref pp, 2 - oneRow) : topright; // ↗️➡️ (or ↗️ if unavailable)
+
+        if (computeProperties)
+        {
+            p[offset++] = x;
+            p[offset++] = top > 0 ? top : -top;
+            p[offset++] = left > 0 ? left : -left;
+            p[offset++] = top;
+            p[offset++] = left;
+
+            // Local gradient
+            p[offset] = left - p[offset + 1];
+            offset++;
+
+            // Local gradient
+            p[offset++] = left + top - topleft;
+
+            // FFV1 context properties
+            p[offset++] = left - topleft;
+            p[offset++] = topleft - top;
+            p[offset++] = top - topright;
+            p[offset++] = top - toptop;
+            p[offset++] = left - leftleft;
+        }
+
+        // Predicted weighted prediction value
+        int wpPred = 0;
+
+        if ((mode & JxlPredictorMode.UseWeightedPrediction) != 0)
+        {
+            if (wpState is null)
+            {
+                throw new InvalidOperationException("Weighted prediction state is missing");
+            }
+
+            wpPred = unchecked((int)wpState.Predict(computeProperties, x, y, w, top, left, topright, topleft, toptop, p, offset));
+        }
+
+        if (!nec && computeProperties)
+        {
+            if (references is null)
+            {
+                throw new InvalidOperationException("References are missing");
+            }
+
+            offset += NumberOfProperties;
+
+            // Extra properties
+            Span<int> rp = references.GetRow(x);
+            for (int i = 0; i < references.Width; i++)
+            {
+                p[offset++] = rp[i];
+            }
+        }
+
+        JxlPredictionResult predResult = default;
+
+        if ((mode & JxlPredictorMode.UseTree) != 0)
+        {
+            if (lookup is null)
+            {
+                throw new InvalidOperationException("Lookup is missing");
+            }
+
+            JxlMaTreeLookupResult result = lookup.Lookup(p);
+            predictor = result.Predictor;
+            predResult = new((int)result.Context, result.Offset, default, result.Multiplier);
+        }
+
+        if ((mode & JxlPredictorMode.AllPredictions) != 0)
+        {
+            for (int i = 0; i < JxlPredictorFacts.ModularPredictors; i++)
+            {
+                predictions[i] = PredictOne((JxlPredictor)i, left, top, toptop, topleft, topright, leftleft, toprightright, wpPred);
+            }
+        }
+
+        predResult = new(
+            predResult.Context,
+            predResult.Guess + PredictOne(predictor, left, top, toptop, topleft, topright, leftleft, toprightright, wpPred),
+            predictor,
+            predResult.Multiplier);
+
+        return predResult;
+    }
+
+    // The following methods are just wrappers over the Predict
+    // method.
+    // See https://github.com/libjxl/libjxl/blob/main/lib/jxl/modular/encoding/context_predict.h#L593-L709
+    public static JxlPredictionResult PredictNoTreeNoWeightedPrediction(
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlPredictor predictor)
+        => Predict(0, [], w, ref pp, oneRow, x, y, predictor, null, null, null, []);
+
+    public static JxlPredictionResult PredictNoTreeWeightedPrediction(
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlPredictor predictor,
+        JxlModularState wpState)
+        => Predict(JxlPredictorMode.UseTree, [], w, ref pp, oneRow, x, y, predictor, null, null, wpState, []);
+
+    public static JxlPredictionResult PredictTreeNoWeightedPrediction(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlMaTreeLookup treeLookup,
+        JxlModularChannel references)
+        => Predict(JxlPredictorMode.UseTree, p, w, ref pp, oneRow, x, y, JxlPredictor.Zero, treeLookup, references, null, []);
+
+    public static JxlPredictionResult PredictTreeNoWeightedPredictionNoEdgeCases(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlMaTreeLookup treeLookup,
+        JxlModularChannel references)
+        => Predict(JxlPredictorMode.UseTree | JxlPredictorMode.NoEdgeCases, p, w, ref pp, oneRow, x, y, JxlPredictor.Zero, treeLookup, references, null, []);
+
+    public static JxlPredictionResult PredictTreeWeightedPrediction(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlMaTreeLookup treeLookup,
+        JxlModularChannel references,
+        JxlModularState wpState)
+        => Predict(JxlPredictorMode.UseTree | JxlPredictorMode.UseWeightedPrediction, p, w, ref pp, oneRow, x, y, JxlPredictor.Zero, treeLookup, references, wpState, []);
+
+    public static JxlPredictionResult PredictTreeWeightedPredictionNoEdgeCases(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlMaTreeLookup treeLookup,
+        JxlModularChannel references,
+        JxlModularState wpState)
+        => Predict(JxlPredictorMode.UseTree | JxlPredictorMode.UseWeightedPrediction | JxlPredictorMode.NoEdgeCases, p, w, ref pp, oneRow, x, y, JxlPredictor.Zero, treeLookup, references, wpState, []);
+
+    public static JxlPredictionResult PredictLearn(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlPredictor predictor,
+        JxlModularChannel references,
+        JxlModularState wpState)
+        => Predict(JxlPredictorMode.ForceComputeProperties | JxlPredictorMode.UseWeightedPrediction, p, w, ref pp, oneRow, x, y, predictor, null, references, wpState, []);
+
+    public static JxlPredictionResult PredictLearnAll(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlModularChannel references,
+        JxlModularState wpState,
+        Span<int> predictions)
+        => Predict(JxlPredictorMode.ForceComputeProperties | JxlPredictorMode.UseWeightedPrediction | JxlPredictorMode.AllPredictions, p, w, ref pp, oneRow, x, y, JxlPredictor.Zero, null, references, wpState, predictions);
+
+    public static JxlPredictionResult PredictLearnNoEdgeCases(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlPredictor predictor,
+        JxlModularChannel references,
+        JxlModularState wpState)
+        => Predict(JxlPredictorMode.ForceComputeProperties | JxlPredictorMode.UseWeightedPrediction | JxlPredictorMode.NoEdgeCases, p, w, ref pp, oneRow, x, y, predictor, null, references, wpState, []);
+
+    public static JxlPredictionResult PredictLearnAllNoEdgeCases(
+        Span<int> p,
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        JxlModularChannel references,
+        JxlModularState wpState,
+        Span<int> predictions)
+        => Predict(JxlPredictorMode.ForceComputeProperties | JxlPredictorMode.UseWeightedPrediction | JxlPredictorMode.AllPredictions | JxlPredictorMode.NoEdgeCases, p, w, ref pp, oneRow, x, y, JxlPredictor.Zero, null, references, wpState, predictions);
+
+    public static JxlPredictionResult PredictAllNoWeightedPrediction(
+        int w,
+        ref int pp,
+        int oneRow,
+        int x,
+        int y,
+        Span<int> predictions)
+        => Predict(JxlPredictorMode.AllPredictions, [], w, ref pp, oneRow, x, y, JxlPredictor.Zero, null, null, null, predictions);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlFlatDecisionNode.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlFlatDecisionNode.cs
new file mode 100644
index 0000000000..122f01befa
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlFlatDecisionNode.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Stores a node and its two children at the same time.
+/// </summary>
+internal struct JxlFlatDecisionNode
+{
+    public int Property0;
+    public int SplitValue0;
+    public JxlPredictor Predictor;
+    public InlineArray2<int> SplitValues;
+    public int Multiplier;
+    public uint ChildID;
+    public InlineArray2<short> Properties;
+    public int PredictorOffset;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlMaTreeLookup.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlMaTreeLookup.cs
new file mode 100644
index 0000000000..6496cc7d1b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlMaTreeLookup.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+internal sealed class JxlMaTreeLookup(List<JxlFlatDecisionNode> nodes)
+{
+    public JxlMaTreeLookupResult Lookup(Span<int> properties)
+    {
+        uint pos = 0;
+        while (true)
+        {
+            for (int i = 0; i < 2; i++)
+            {
+                JxlFlatDecisionNode node = nodes[(int)pos];
+                if (node.Property0 < 0)
+                {
+                    return new(node.ChildID, node.Predictor, node.PredictorOffset, node.Multiplier);
+                }
+
+                bool p0 = properties[node.Property0] <= node.SplitValue0;
+                uint off0 = properties[node.Properties[0]] <= node.SplitValues[0] ? 1u : 0u;
+                uint off1 = 2u | (properties[node.Properties[1]] <= node.SplitValues[1] ? 1u : 0u);
+
+                pos = node.ChildID + (p0 ? off1 : off0);
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlMaTreeLookupResult.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlMaTreeLookupResult.cs
new file mode 100644
index 0000000000..2609011449
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlMaTreeLookupResult.cs
@@ -0,0 +1,9 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// MA tree lookup result
+/// </summary>
+internal record struct JxlMaTreeLookupResult(uint Context, JxlPredictor Predictor, int Offset, int Multiplier);
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularHeader.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularHeader.cs
new file mode 100644
index 0000000000..bda4751e83
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularHeader.cs
@@ -0,0 +1,135 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Context prediction header
+/// </summary>
+internal sealed class JxlModularHeader : IJxlFields
+{
+    // Backing fields for properties so we can get
+    // a ref to them.
+    private bool allDefault;
+    private int p1C;
+    private int p2C;
+    private int p3Ca;
+    private int p3Cb;
+    private int p3Cc;
+    private int p3Cd;
+    private int p3Ce;
+    private InlineArray4<uint> w;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether all values are default.
+    /// </summary>
+    public bool AllDefault
+    {
+        get => this.allDefault;
+        set => this.allDefault = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the p1C coefficient.
+    /// </summary>
+    public int P1C
+    {
+        get => this.p1C;
+        set => this.p1C = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the p2C coefficient.
+    /// </summary>
+    public int P2C
+    {
+        get => this.p2C;
+        set => this.p2C = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the p3Ca coefficient.
+    /// </summary>
+    public int P3Ca
+    {
+        get => this.p3Ca;
+        set => this.p3Ca = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the p3Cb coefficient.
+    /// </summary>
+    public int P3Cb
+    {
+        get => this.p3Cb;
+        set => this.p3Cb = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the p3Cc coefficient.
+    /// </summary>
+    public int P3Cc
+    {
+        get => this.p3Cc;
+        set => this.p3Cc = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the p3Cd coefficient.
+    /// </summary>
+    public int P3Cd
+    {
+        get => this.p3Cd;
+        set => this.p3Cd = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the p3Ce coefficient.
+    /// </summary>
+    public int P3Ce
+    {
+        get => this.p3Ce;
+        set => this.p3Ce = value;
+    }
+
+    /// <summary>
+    /// Returns a span to the w array.
+    /// </summary>
+    /// <returns>Reference to w</returns>
+    public Span<uint> GetW() => this.w;
+
+    public bool Visit(JxlVisitor v)
+    {
+        if (v.AllDefault(this, ref this.allDefault))
+        {
+            v.SetDefault(this);
+            return true;
+        }
+
+        if (!VisitP(16, ref this.p1C) ||
+            !VisitP(10, ref this.p2C) ||
+            !VisitP(7, ref this.p3Ca) ||
+            !VisitP(7, ref this.p3Cb) ||
+            !VisitP(7, ref this.p3Cc) ||
+            !VisitP(0, ref this.p3Cd) ||
+            !VisitP(0, ref this.p3Ce) ||
+            !v.Bits(4, 0xD, ref this.w[0]) ||
+            !v.Bits(4, 0xC, ref this.w[1]) ||
+            !v.Bits(4, 0xC, ref this.w[2]) ||
+            !v.Bits(4, 0xC, ref this.w[3]))
+        {
+            return false;
+        }
+
+        return true;
+
+        bool VisitP(int value, ref int p)
+        {
+            ref uint unsignedP = ref Unsafe.As<int, uint>(ref p);
+            return v.Bits(5, (uint)value, ref unsignedP);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularMultiplierInfo.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularMultiplierInfo.cs
new file mode 100644
index 0000000000..2b0b35511f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularMultiplierInfo.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Information about a multiplier for Modular.
+/// </summary>
+/// <param name="Range">
+/// A static property range, with each item containing channel and group ID.
+/// </param>
+/// <param name="Multiplier">
+/// The multiplier.
+/// </param>
+internal record struct JxlModularMultiplierInfo(
+    InlineArray2<InlineArray2<uint>> Range,
+    uint Multiplier);
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularState.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularState.cs
new file mode 100644
index 0000000000..2b112ff3cc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlModularState.cs
@@ -0,0 +1,192 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// State for context prediction
+/// </summary>
+internal sealed class JxlModularState
+{
+    /// <summary>
+    /// Rounding constant for predictions.
+    /// </summary>
+    private const long PredictionRound = ((1 << 3) >> 1) - 1;
+
+    private InlineArray4<long> prediction;
+    private long pred;
+    private readonly uint[][] predErrors = new uint[4][];
+    private readonly int[] error;
+    private readonly JxlModularHeader header;
+
+    public JxlModularState(JxlModularHeader header, int width)
+    {
+        this.header = header;
+
+        for (int i = 0; i < 4; i++)
+        {
+            this.predErrors[i] = new uint[(width + 2) * 2];
+        }
+
+        this.error = new int[(width + 2) * 2];
+    }
+
+    /// <summary>
+    /// Gets a table for approximating division by a number from
+    /// 1 to 64. It is defined as follows.
+    /// <code>
+    /// for (int i = 0; i &lt; 64; i++)
+    /// {
+    ///     DivisionLookup[i] = (1u &lt;&lt; 24) / (i + 1);
+    /// }
+    /// </code>
+    /// </summary>
+    private static ReadOnlySpan<uint> DivisionLookup =>
+    [
+        16777216, 8388608, 5592405, 4194304, 3355443, 2796202, 2396745, 2097152,
+        1864135,  1677721, 1525201, 1398101, 1290555, 1198372, 1118481, 1048576,
+        986895,   932067,  883011,  838860,  798915,  762600,  729444,  699050,
+        671088,   645277,  621378,  599186,  578524,  559240,  541200,  524288,
+        508400,   493447,  479349,  466033,  453438,  441505,  430185,  419430,
+        409200,   399457,  390167,  381300,  372827,  364722,  356962,  349525,
+        342392,   335544,  328965,  322638,  316551,  310689,  305040,  299593,
+        294337,   289262,  284359,  279620,  275036,  270600,  266305,  262144
+    ];
+
+    /// <summary>
+    /// Adds extra bits to the prediction.
+    /// </summary>
+    /// <param name="x">The prediction</param>
+    /// <returns>3 extra bits added to the prediction</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static long AddBits(long x) => x << 3;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint ErrorWeight(int x, uint maxWeight)
+    {
+        int shift = Math.Max(0, JxlMath.FloorLog2Nonzero(x + 1) - 5); // Math.Max call ensures the value isn't negative
+        return 4 + ((maxWeight * DivisionLookup[x >> shift]) >> shift);
+    }
+
+    public static long WeightedAverage(Span<long> p, Span<uint> w)
+    {
+        uint weightSum = (w[0] + w[1]) + (w[2] + w[3]);
+
+        if (weightSum <= 15)
+        {
+            throw new InvalidOperationException("Weight sum is too low");
+        }
+
+        int logWeight = (int)JxlMath.FloorLog2Nonzero(weightSum);
+        weightSum = 0;
+
+        for (int i = 0; i < 4; i++)
+        {
+            w[i] >>= logWeight - 4;
+            weightSum += w[i];
+        }
+
+        long sum = (weightSum >> 1) - 1;
+        for (int i = 0; i < 4; i++)
+        {
+            // Dot product
+            sum += p[i] * w[i];
+        }
+
+        return (sum * DivisionLookup[(int)weightSum - 1]) >> 24;
+    }
+
+    public long Predict(bool computeProperties, int x, int y, int width, long n, long w, long ne, long nw, long nn, Span<int> properties, int offset)
+    {
+        bool yIsOdd = (y & 1) != 0;
+
+        int cur_row = yIsOdd ? 0 : (width + 2);
+        int prev_row = yIsOdd ? (width + 2) : 0;
+        int posN = prev_row + x;
+        int posNE = x < width - 1 ? posN + 1 : posN;
+        int posNW = x > 0 ? posN - 1 : posN;
+
+        Span<uint> weights = [0, 0, 0, 0];
+        Span<uint> headerW = this.header.GetW();
+
+        for (int i = 0; i < 4; i++)
+        {
+            Span<uint> error = this.predErrors[i].AsSpan();
+            weights[i] = error[posN] + error[posNE] + error[posNW];
+            weights[i] = ErrorWeight((int)weights[i], headerW[i]);
+        }
+
+        n = AddBits(n);
+        w = AddBits(w);
+        ne = AddBits(ne);
+        nw = AddBits(nw);
+        nn = AddBits(nn);
+
+        long teW = x == 0 ? 0 : this.error[cur_row + x - 1];
+        long teN = this.error[posN];
+        long teNW = this.error[posNW];
+        long sumWN = teN + teW;
+        long teNE = this.error[posNE];
+
+        if (computeProperties)
+        {
+            long p = teW;
+            long absP = Math.Abs(p);
+
+            if (Math.Abs(teN) > absP)
+            {
+                p = teN;
+            }
+
+            if (Math.Abs(teNW) > absP)
+            {
+                p = teNW;
+            }
+
+            if (Math.Abs(teNE) > absP)
+            {
+                p = teNE;
+            }
+
+            properties[offset++] = (int)p;
+        }
+
+        this.prediction[0] = w + ne - n;
+        this.prediction[1] = n - (((sumWN + teNE) * this.header.P1C) >> 5);
+        this.prediction[2] = w - (((sumWN + teNW) * this.header.P2C) >> 5);
+        this.prediction[3] =
+            n - (((teNW * this.header.P3Ca) + (teN * this.header.P3Cb) + (teNE * this.header.P3Cc) +
+                ((nn - n) * this.header.P3Cd) + ((nw - w) * this.header.P3Ce)) >>
+                5);
+
+        this.pred = WeightedAverage(this.prediction, weights);
+
+        if (((teN ^ teW) | (teN ^ teNW)) > 0)
+        {
+            return (this.pred + PredictionRound) >> 3;
+        }
+
+        long mx = Math.Max(w, Math.Max(ne, n));
+        long mn = Math.Min(w, Math.Min(ne, n));
+        this.pred = Math.Max(mn, Math.Min(mx, this.pred));
+        return (this.pred + PredictionRound) >> 3;
+    }
+
+    public void UpdatePredictionErrors(long value, int x, int y, int width)
+    {
+        bool yIsOdd = (y & 1) != 0;
+
+        long curRow = yIsOdd ? 0 : (width + 2);
+        long prevRow = yIsOdd ? (width + 2) : 0;
+        value = AddBits(value);
+        this.error[curRow + x] = (int)(this.pred - value);
+        for (int i = 0; i < 4; i++)
+        {
+            long err = (Math.Abs(this.prediction[i] - value) + PredictionRound) >> 3;
+            this.predErrors[i][curRow + x] = (uint)err;
+            this.predErrors[i][prevRow + x + 1] += (uint)err;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictionResult.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictionResult.cs
new file mode 100644
index 0000000000..f1822a2a07
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictionResult.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// The result of context prediction.
+/// </summary>
+/// <param name="Context">Context used in MA lookup.</param>
+/// <param name="Guess">Predicted coefficient.</param>
+/// <param name="Predictor">Kind of predictor mode used.</param>
+/// <param name="Multiplier">Multiplier used in MA lookup.</param>
+internal record struct JxlPredictionResult(int Context, int Guess, JxlPredictor Predictor, int Multiplier);
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictor.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictor.cs
new file mode 100644
index 0000000000..6b68b40ea5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictor.cs
@@ -0,0 +1,34 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Defines the type of the predictor using neighboring
+/// pixels, similar to intra prediction used in codecs like
+/// VP8, AV1 and H.264.
+/// </summary>
+internal enum JxlPredictor : uint
+{
+    Zero = 0,
+    Left = 1,
+    Top = 2,
+    Average0 = 3,
+    Select = 4,
+    Gradient = 5,
+    Weighted = 6,
+    TopRight = 7,
+    TopLeft = 8,
+    LeftLeft = 9,
+    Average1 = 10,
+    Average2 = 11,
+    Average3 = 12,
+    Average4 = 13,
+    Best = 14,
+    Variable = 15,
+
+    /// <summary>
+    /// Undefined predictor.
+    /// </summary>
+    Undefined = ~0u
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictorFacts.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictorFacts.cs
new file mode 100644
index 0000000000..797c95d68c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictorFacts.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Tools and constants for predictor types.
+/// </summary>
+internal static class JxlPredictorFacts
+{
+    /// <summary>
+    /// Number of modular predictors.
+    /// </summary>
+    public const int ModularPredictors = (int)JxlPredictor.Average4 + 1;
+
+    /// <summary>
+    /// Nearest power of 2 of modular predictors.
+    /// </summary>
+    public const int ModularPredictorsAlignment = 16;
+
+    /// <summary>
+    /// Number of modular encoder predictors.
+    /// </summary>
+    public const int ModularEncoderPredictors = (int)JxlPredictor.Variable + 1;
+
+    /// <summary>
+    /// Number of static properties.
+    /// </summary>
+    public const int StaticProperties = 2;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictorMode.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictorMode.cs
new file mode 100644
index 0000000000..5144f14cb6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlPredictorMode.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Flags for context prediction.
+/// </summary>
+[Flags]
+internal enum JxlPredictorMode : byte
+{
+    /// <summary>
+    /// Should tree-based prediction be used?
+    /// </summary>
+    UseTree = 1,
+
+    /// <summary>
+    /// Should the weighted predictor be used?
+    /// </summary>
+    UseWeightedPrediction = 2,
+
+    /// <summary>
+    /// Should properties be computed? (When this bit is 0,
+    /// the properties are not set and therefore have their
+    /// default values)
+    /// </summary>
+    ForceComputeProperties = 4,
+
+    /// <summary>
+    /// Try all predictors?
+    /// </summary>
+    AllPredictions = 8,
+
+    NoEdgeCases = 16
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlTreeKind.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlTreeKind.cs
new file mode 100644
index 0000000000..1906d7ec03
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlTreeKind.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Kind of tree to use.
+/// </summary>
+// TODO: this enum wasn't documented
+// https://github.com/libjxl/libjxl/blob/main/lib/jxl/modular/options.h#L100-L111
+internal enum JxlTreeKind : byte
+{
+    TrivialTreeNoPredictor,
+    Learn,
+    JpegTranscodeAcMeta,
+    FalconAcMeta,
+    AcMeta,
+    WpFixedDc,
+    GradientFixedDc
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlTreeMode.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlTreeMode.cs
new file mode 100644
index 0000000000..93eaa16f8d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ContextPrediction/JxlTreeMode.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+/// <summary>
+/// Decides which kinds of trees should be allowed.
+/// </summary>
+internal enum JxlTreeMode : byte
+{
+    /// <summary>
+    /// Gradient tree only
+    /// </summary>
+    GradientOnly,
+
+    /// <summary>
+    /// Weighted predictor only
+    /// </summary>
+    WpOnly,
+
+    /// <summary>
+    /// Disable weighted predictor
+    /// </summary>
+    NoWp,
+
+    /// <summary>
+    /// Default trees
+    /// </summary>
+    Default
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlGroupHeader.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlGroupHeader.cs
new file mode 100644
index 0000000000..e9d11b036f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlGroupHeader.cs
@@ -0,0 +1,64 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal sealed class JxlGroupHeader : IJxlFields
+{
+    private bool useGlobalTree;
+
+    public bool UseGlobalTree
+    {
+        get => this.useGlobalTree;
+        set => this.useGlobalTree = value;
+    }
+
+    internal JxlModularHeader WeightedHeader { get; set; } = new();
+
+    internal List<JxlTransform> Transforms { get; set; } = [];
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (!visitor.Boolean(false, ref this.useGlobalTree))
+        {
+            return false;
+        }
+
+        if (!visitor.VisitNested(this.WeightedHeader))
+        {
+            return false;
+        }
+
+        uint numTransforms = (uint)this.Transforms.Count;
+
+        _ = visitor.U32(
+            JxlFieldExpressions.Value(0),
+            JxlFieldExpressions.Value(1),
+            JxlFieldExpressions.BitsOffset(4, 2),
+            JxlFieldExpressions.BitsOffset(8, 18),
+            0,
+            ref numTransforms);
+
+        if (visitor.IsReading)
+        {
+            this.Transforms = new List<JxlTransform>((int)numTransforms);
+        }
+
+        Span<JxlTransform> sp = CollectionsMarshal.AsSpan(this.Transforms);
+
+        for (int i = 0; i < numTransforms; i++)
+        {
+            if (!visitor.VisitNested(sp[i]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaConstants.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaConstants.cs
new file mode 100644
index 0000000000..6e375e3da7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaConstants.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal static class JxlMaConstants
+{
+    /// <summary>
+    /// Total number of MA tree contexts.
+    /// </summary>
+    public const int NumTreeContexts = 6;
+
+    public const int MaxTreeSize = 1 << 22;
+
+    public const int PropertyRangeFast = 512 << 4;
+
+    public const int NumNonrefProperties = 2 + 13 + JxlContextPrediction.NumberOfProperties;
+
+    public const int WpProp = NumNonrefProperties - JxlContextPrediction.NumberOfProperties;
+
+    public const int GradientProp = 9;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaDecoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaDecoder.cs
new file mode 100644
index 0000000000..cfe5be459e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaDecoder.cs
@@ -0,0 +1,197 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using Tree = System.Collections.Generic.List<SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.JxlPropertyDecisionNode>;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal static class JxlMaDecoder
+{
+    private enum NextAction
+    {
+        CheckAndGoLeft,
+        GoRight,
+        Pop
+    }
+
+    public static void ValidateTree(Tree tree)
+    {
+        const int heightLimit = 2048;
+
+        if (tree.Count == 0)
+        {
+            return;
+        }
+
+        int numProperties = tree.Max(x => x.Property + 1);
+        Span<(int First, int Second)> propertyRanges = stackalloc (int First, int Second)[numProperties];
+
+        for (int i = 0; i < numProperties; i++)
+        {
+            propertyRanges[i].First = int.MinValue;
+            propertyRanges[i].Second = int.MaxValue;
+        }
+
+        Stack<WorkItem> stack = [];
+        stack.Push(new WorkItem(0, 0, 0, NextAction.CheckAndGoLeft));
+
+        while (stack.Count > 0)
+        {
+            if (stack.Count > heightLimit)
+            {
+                throw new InvalidOperationException("Tree too tall");
+            }
+
+            WorkItem item = stack.Peek();
+            JxlPropertyDecisionNode node = tree[item.NodeIndex];
+
+            switch (item.Action)
+            {
+                case NextAction.CheckAndGoLeft:
+                {
+                    int p = node.Property;
+                    if (p == -1)
+                    {
+                        _ = stack.Pop();
+                        continue;
+                    }
+
+                    int v = node.SplitValue;
+                    int l = propertyRanges[p].First;
+                    int u = propertyRanges[p].Second;
+
+                    if (l > v || u <= v)
+                    {
+                        throw new InvalidOperationException("Invalid tree");
+                    }
+
+                    item.OriginalL = l;
+                    item.OriginalU = u;
+                    item.Action = NextAction.GoRight;
+                    propertyRanges[node.Property].First = node.SplitValue + 1;
+
+                    stack.Push(new WorkItem(node.LeftChild, 0, 0, NextAction.CheckAndGoLeft));
+                    continue;
+                }
+
+                case NextAction.GoRight:
+                    item.Action = NextAction.Pop;
+                    propertyRanges[node.Property].First = item.OriginalL;
+                    propertyRanges[node.Property].Second = node.SplitValue;
+                    stack.Push(new WorkItem(node.LeftChild, 0, 0, NextAction.CheckAndGoLeft));
+                    continue;
+
+                case NextAction.Pop:
+                    propertyRanges[node.Property].Second = item.OriginalU;
+                    _ = stack.Pop();
+                    continue;
+            }
+        }
+    }
+
+    public static void DecodeTree(JxlBitReader br, JxlAnsSymbolReader reader, List<byte> contextMap, Tree tree, int treeSizeLimit)
+    {
+        int leafId = 0;
+        int toDecode = 1;
+        tree.Clear();
+
+        while (toDecode > 0)
+        {
+            if (tree.Count > treeSizeLimit)
+            {
+                throw new InvalidOperationException("Tree is too large");
+            }
+
+            toDecode--;
+            int prop1 = reader.ReadHybridUint(JxlMaTreeContext.Property, br, contextMap);
+            if (prop1 > 256)
+            {
+                throw new InvalidOperationException("Invalid tree property value");
+            }
+
+            int property = prop1 - 1;
+            if (property == -1)
+            {
+                int predictor = reader.ReadHybridUint(JxlMaTreeContext.Predictor, br, contextMap);
+
+                if (predictor >= JxlPredictorFacts.ModularPredictors)
+                {
+                    throw new InvalidOperationException("Invalid predictor");
+                }
+
+                int predictor_offset = JxlPackSigned.UnpackSigned(reader.ReadHybridUint(JxlMaTreeContext.Offset, br, contextMap));
+                int mul_log = reader.ReadHybridUint(JxlMaTreeContext.MultiplierLog, br, contextMap);
+
+                if (mul_log >= 31)
+                {
+                    throw new InvalidOperationException("Invalid multiplier logarithm");
+                }
+
+                int mul_bits = reader.ReadHybridUint(JxlMaTreeContext.MultiplierBits, br, contextMap);
+
+                if (mul_bits >= (1 << (31 - mul_log)) - 1)
+                {
+                    throw new InvalidOperationException("Invalid multiplier");
+                }
+
+                int multiplier = (mul_bits + 1) << mul_log;
+                JxlPredictor p = (JxlPredictor)predictor;
+
+                tree.Add(new JxlPropertyDecisionNode(-1, 0, leafId, 0, p, predictor_offset, multiplier));
+                leafId++;
+                continue;
+            }
+
+            int splitval = JxlPackSigned.UnpackSigned(reader.ReadHybridUint(JxlMaTreeContext.SplitValue, br, contextMap));
+            tree.Add(
+                new JxlPropertyDecisionNode(
+                    property,
+                    splitval,
+                    tree.Count + toDecode + 1,
+                    tree.Count + toDecode + 2,
+                    JxlPredictor.Zero,
+                    0,
+                    1));
+
+            toDecode += 2;
+        }
+
+        ValidateTree(tree);
+    }
+
+    public static void DecodeTree(Configuration configuration, JxlBitReader reader, Tree tree, int treeSizeLimit)
+    {
+        List<byte> treeContextMap = [];
+        JxlAnsCode code = new();
+
+        JxlAnsReader.DecodeHistograms(configuration, reader, JxlMaConstants.NumTreeContexts, code, treeContextMap);
+
+        if (code.DegenerateSymbols[treeContextMap[(int)JxlMaTreeContext.Property]] > 0)
+        {
+            throw new InvalidOperationException("Infinite tree");
+        }
+
+        JxlAnsSymbolReader symbolReader = JxlAnsSymbolReader.Create(code, reader);
+        DecodeTree(reader, symbolReader, treeContextMap, tree, Math.Min(treeSizeLimit, JxlMaConstants.MaxTreeSize));
+
+        if (!symbolReader.CheckAnsFinalState())
+        {
+            throw new InvalidOperationException("ANS decode final state failed");
+        }
+    }
+
+    private struct WorkItem(int nodeIndex, int origL, int origU, NextAction action)
+    {
+        public int NodeIndex { get; set; } = nodeIndex;
+
+        public int OriginalL { get; set; } = origL;
+
+        public int OriginalU { get; set; } = origU;
+
+        public NextAction Action { get; set; } = action;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaEncoder.cs
new file mode 100644
index 0000000000..115136b1bb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaEncoder.cs
@@ -0,0 +1,865 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Numerics;
+using System.Numerics.Tensors;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using StaticPropertyRange = System.Runtime.CompilerServices.InlineArray2<System.Runtime.CompilerServices.InlineArray2<int>>;
+using Tree = System.Collections.Generic.List<SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.JxlPropertyDecisionNode>;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal static class JxlMaEncoder
+{
+    internal enum IntersectionType : byte
+    {
+        None,
+        Partial,
+        Inside
+    }
+
+    private static int Padded(int x) => JxlMath.RoundUpTo(x, Vector<float>.Count);
+
+    public static float EstimateBits(Span<int> counts, int numSymbols)
+    {
+        int total = TensorPrimitives.Sum((ReadOnlySpan<int>)counts.Slice(0, numSymbols));
+
+        Vector<float> minprob = Vector.Create(1.0f / JxlAnsConstants.AnsTableSize);
+        Vector<float> inverseTotal = Vector.Create(1.0f / total);
+        Vector<float> bitsLanes = Vector<float>.Zero;
+
+        for (int i = 0; i < numSymbols; i += Vector<float>.Count)
+        {
+            Vector<int> countsIv = new(counts[i..]);
+            Vector<float> countsFv = Vector.ConvertToSingle(countsIv);
+            Vector<float> probs = countsFv * inverseTotal;
+            Vector<float> mprobs = probs * minprob;
+
+            Vector<float> nbps = Vector.ConditionalSelect(
+                Vector.Equals(countsIv, Vector.Create(total)),
+                Vector<float>.Zero,
+                Vector.Log2(mprobs));
+
+            bitsLanes -= countsFv * nbps;
+        }
+
+        return Vector.Sum(bitsLanes);
+    }
+
+    public static void MakeSplitNode(int pos, int property, int splitValue, JxlPredictor leftPredictor, int leftOffset, JxlPredictor rightPredictor, int rightOffset, Tree tree)
+    {
+        ref JxlPropertyDecisionNode treePos = ref CollectionsMarshal.AsSpan(tree)[pos];
+
+        treePos.LeftChild = tree.Count;
+        treePos.RightChild = tree.Count + 1;
+        treePos.SplitValue = splitValue;
+        treePos.Property = property;
+
+        JxlPropertyDecisionNode newRightNode = new()
+        {
+            Property = -1,
+            Predictor = rightPredictor,
+            PredictorOffset = rightOffset,
+            Multiplier = 1
+        };
+
+        JxlPropertyDecisionNode newLeftNode = new()
+        {
+            Property = -1,
+            Predictor = leftPredictor,
+            PredictorOffset = leftOffset,
+            Multiplier = 1
+        };
+
+        tree.Add(newRightNode);
+        tree.Add(newLeftNode);
+    }
+
+    public static IntersectionType BoxIntersects(StaticPropertyRange needle, StaticPropertyRange haystack, ref int partialAxis, ref int partialValue)
+    {
+        bool partial = false;
+
+        for (int i = 0; i < JxlPredictorFacts.StaticProperties; i++)
+        {
+            if (haystack[i][0] >= needle[i][1])
+            {
+                return IntersectionType.None;
+            }
+
+            if (haystack[i][1] <= needle[i][0])
+            {
+                return IntersectionType.None;
+            }
+
+            if (haystack[i][0] <= needle[i][0] && haystack[i][1] >= needle[i][1])
+            {
+                continue;
+            }
+
+            partial = true;
+            partialAxis = i;
+
+            int innerOffset = haystack[i][0] > needle[i][0] && haystack[i][0] < needle[i][1] ? 0 : 1; // yes, if true then 0 not 1
+            partialValue = haystack[i][innerOffset] - 1;
+        }
+
+        return partial ? IntersectionType.Partial : IntersectionType.Inside;
+    }
+
+    public static void SplitTreeSamples(bool s, JxlTreeSamples samples, int begin, int pos, int end, int prop, int value)
+    {
+        int beginPos = begin;
+        int endPos = pos;
+
+        do
+        {
+            while (beginPos < pos && samples.GetProperty(s, prop, beginPos) <= value)
+            {
+                beginPos++;
+            }
+
+            while (endPos < end && samples.GetProperty(s, prop, endPos) > value)
+            {
+                endPos++;
+            }
+
+            if (beginPos < pos && endPos < end)
+            {
+                samples.Swap(beginPos, endPos);
+            }
+
+            beginPos++;
+            endPos++;
+        }
+        while (beginPos < pos && endPos < end);
+    }
+
+    // Simple overload so we don't have to type out CollectionsMarshal.AsSpan all the time.
+    public static void CollectExtraBitsIncrease(bool s, JxlTreeSamples treeSamples, List<JxlResidualToken> residualTokens, List<int> countIncrease, List<int> extraBitsIncrease, int begin, int end, int propertyIndex, int maxSymbols)
+        => CollectExtraBitsIncrease(
+            s,
+            treeSamples,
+            residualTokens,
+            CollectionsMarshal.AsSpan(countIncrease),
+            CollectionsMarshal.AsSpan(extraBitsIncrease),
+            begin,
+            end,
+            propertyIndex,
+            maxSymbols);
+
+    public static void CollectExtraBitsIncrease(bool s, JxlTreeSamples treeSamples, List<JxlResidualToken> residualTokens, Span<int> countIncrease, Span<int> extraBitsIncrease, int begin, int end, int propertyIndex, int maxSymbols)
+    {
+        for (int i2 = begin; i2 < end; i2++)
+        {
+            JxlResidualToken rt = residualTokens[i2];
+
+            int cnt = treeSamples.GetCount(i2);
+            int p = treeSamples.GetProperty(s, propertyIndex, i2);
+            int sym = rt.Token;
+            int ebi = rt.NumberOfBits * cnt;
+
+            countIncrease[(p * maxSymbols) + sym] += cnt;
+            extraBitsIncrease[p] += ebi;
+        }
+    }
+
+    public static unsafe void FindBestSplit(JxlTreeSamples treeSamples, float threshold, List<JxlModularMultiplierInfo> mulInfo, StaticPropertyRange initialStaticPropertyRange, float fastDecodeMultiplier, Tree tree)
+    {
+        Stack<NodeInfo> nodes = [];
+        nodes.Push(new(0, 0, treeSamples.NumberOfDistinctSamples, initialStaticPropertyRange));
+
+        int numPred = treeSamples.NumberOfPredictors;
+        int numProp = treeSamples.NumberOfProperties;
+
+        Span<int> totalExtraBits = stackalloc int[numPred];
+
+        while (nodes.Count > 0)
+        {
+            NodeInfo last = nodes.Peek();
+
+            int pos = last.Pos;
+            int begin = last.Begin;
+            int end = last.End;
+            StaticPropertyRange staticPropertyRange = last.StaticPropertyRange;
+
+            _ = nodes.Pop();
+
+            if (begin == end)
+            {
+                continue;
+            }
+
+            SplitInfo bestSplitStaticConstant = default;
+            SplitInfo bestSplitStatic = default;
+            SplitInfo bestSplitNonStatic = default;
+            SplitInfo bestSplitNoWeightedPrediction = default;
+
+            if (begin > end)
+            {
+                throw new InvalidOperationException("Begin should be <= end");
+            }
+
+            if (end > treeSamples.NumberOfDistinctSamples)
+            {
+                throw new InvalidOperationException("End index out of range");
+            }
+
+            int maxSymbols = 0;
+
+            for (int pred = 0; pred < numPred; pred++)
+            {
+                for (int i = begin; i < end; i++)
+                {
+                    int token = treeSamples.GetToken(pred, i);
+                    maxSymbols = maxSymbols > token + 1 ? maxSymbols : token + 1;
+                }
+            }
+
+            maxSymbols = Padded(maxSymbols);
+
+            int[] counts = ArrayPool<int>.Shared.Rent(maxSymbols * numPred);
+
+            for (int pred = 0; pred < numPred; pred++)
+            {
+                int extraBits = 0;
+                List<JxlResidualToken> rtokens = treeSamples.GetResidualTokensForPrediction(pred);
+
+                for (int i = begin; i < end; i++)
+                {
+                    JxlResidualToken rt = rtokens[i];
+
+                    int count = treeSamples.GetCount(i);
+                    int eb = rt.NumberOfBits * count;
+
+                    counts[(pred * maxSymbols) + rt.Token] += count;
+                    extraBits += eb;
+                }
+
+                totalExtraBits[pred] = extraBits;
+            }
+
+            float baseBits = 0;
+            {
+                int pred = treeSamples.FindPredictorIndex(tree[pos].Predictor);
+                baseBits = EstimateBits(counts.AsSpan(pred * maxSymbols), maxSymbols) + totalExtraBits[pred];
+            }
+
+            ref SplitInfo best = ref bestSplitNonStatic;
+
+            SplitInfo forcedSplit = default;
+
+            foreach (JxlModularMultiplierInfo mmi in mulInfo)
+            {
+                int axis = 0;
+                int val = 0;
+                IntersectionType t = BoxIntersects(staticPropertyRange, mmi.Range, ref axis, ref val);
+
+                if (t == IntersectionType.None)
+                {
+                    continue;
+                }
+
+                if (t == IntersectionType.Inside)
+                {
+                    CollectionsMarshal.AsSpan(tree)[pos].Multiplier = (int)mmi.Multiplier;
+                    break;
+                }
+
+                if (t == IntersectionType.Partial)
+                {
+                    forcedSplit.Value = treeSamples.QuantizeStaticProperty(axis, val);
+                    forcedSplit.Property = axis;
+                    forcedSplit.LeftCost = forcedSplit.RightCost = (baseBits / 2) - threshold;
+                    forcedSplit.LeftPredictor = forcedSplit.RightPredictor = CollectionsMarshal.AsSpan(tree)[pos].Predictor;
+                    best = ref forcedSplit;
+                    best.Position = begin;
+
+                    if (best.Property != treeSamples.PropertyFromIndex(best.Property))
+                    {
+                        throw new InvalidOperationException("Invalid property");
+                    }
+
+                    if (best.Property < treeSamples.NumberOfStaticProperties)
+                    {
+                        for (int x = begin; x < end; x++)
+                        {
+                            if (treeSamples.GetProperty(true, best.Property, x) <= best.Value)
+                            {
+                                best.Position++;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        int prop = best.Property - treeSamples.NumberOfStaticProperties;
+
+                        for (int x = begin; x < end; x++)
+                        {
+                            if (treeSamples.GetProperty(false, prop, x) <= best.Value)
+                            {
+                                best.Position++;
+                            }
+                        }
+                    }
+
+                    break;
+                }
+            }
+
+            if (!Unsafe.AreSame(ref best, ref forcedSplit))
+            {
+                List<int> countsIncrease = [];
+                List<int> extraBitsIncrease = [];
+
+                List<CostInfo> leftCosts = [];
+                List<CostInfo> rightCosts = [];
+
+                int[] aboveCounts = ArrayPool<int>.Shared.Rent(maxSymbols);
+                int[] belowCounts = ArrayPool<int>.Shared.Rent(maxSymbols);
+
+                float changePredictionPenalty = 800.0f / (100.0f + threshold);
+
+                for (int prop = 0; prop < numProp && baseBits > threshold; prop++)
+                {
+                    leftCosts.Clear();
+                    rightCosts.Clear();
+
+                    int propertySize = treeSamples.CountPropertyValues(prop);
+
+                    if (extraBitsIncrease.Count < propertySize)
+                    {
+                        countsIncrease.Grow(0, propertySize * maxSymbols);
+                        extraBitsIncrease.Grow(0, propertySize);
+                    }
+
+                    int[] propertyValueUsedCount = ArrayPool<int>.Shared.Rent(propertySize);
+                    propertyValueUsedCount.AsSpan().Clear();
+
+                    int firstUsed = propertySize;
+                    int lastUsed = 0;
+
+                    if (prop < treeSamples.NumberOfStaticProperties)
+                    {
+                        for (int i = begin; i < end; i++)
+                        {
+                            int p = treeSamples.GetProperty(true, prop, i);
+                            propertyValueUsedCount[p]++;
+                            lastUsed = Math.Max(lastUsed, p);
+                            firstUsed = Math.Max(firstUsed, p);
+                        }
+                    }
+                    else
+                    {
+                        int prop_idx = prop - treeSamples.NumberOfStaticProperties;
+
+                        for (int i = begin; i < end; i++)
+                        {
+                            int p = treeSamples.GetProperty(false, prop_idx, i);
+                            propertyValueUsedCount[p]++;
+                            lastUsed = Math.Max(lastUsed, p);
+                            firstUsed = Math.Max(firstUsed, p);
+                        }
+                    }
+
+                    leftCosts.Grow(default, lastUsed - firstUsed);
+                    rightCosts.Grow(default, lastUsed - firstUsed);
+
+                    for (int pred = 0; pred < numPred; pred++)
+                    {
+                        List<JxlResidualToken> rtokens = treeSamples.GetResidualTokensForPrediction(pred);
+
+                        if (prop < treeSamples.NumberOfStaticProperties)
+                        {
+                            CollectExtraBitsIncrease(true, treeSamples, rtokens, countsIncrease, extraBitsIncrease, begin, end, prop, maxSymbols);
+                        }
+                        else
+                        {
+                            CollectExtraBitsIncrease(false, treeSamples, rtokens, countsIncrease, extraBitsIncrease, begin, end, prop - treeSamples.NumberOfStaticProperties, maxSymbols);
+                        }
+
+                        counts.AsSpan().Slice(pred * maxSymbols, maxSymbols).CopyTo(aboveCounts);
+                        belowCounts.AsSpan().Slice(0, maxSymbols).Clear();
+
+                        int extraBitsBelow = 0;
+
+                        for (int i = firstUsed; i < lastUsed; i++)
+                        {
+                            if (propertyValueUsedCount[i] == 0)
+                            {
+                                continue;
+                            }
+
+                            extraBitsBelow += extraBitsIncrease[i];
+                            extraBitsIncrease[i] = 0;
+
+                            for (int sym = 0; sym < maxSymbols; sym++)
+                            {
+                                aboveCounts[sym] -= countsIncrease[(i * maxSymbols) + sym];
+                                belowCounts[sym] += countsIncrease[(i * maxSymbols) + sym];
+                                countsIncrease[(i * maxSymbols) + sym] = 0;
+                            }
+
+                            float rightCost = EstimateBits(aboveCounts.AsSpan(), maxSymbols) + totalExtraBits[pred] - extraBitsBelow;
+                            float leftCost = EstimateBits(belowCounts.AsSpan(), maxSymbols) + extraBitsBelow;
+
+                            if (extraBitsBelow > totalExtraBits[pred])
+                            {
+                                throw new InvalidOperationException("Too many extra bits");
+                            }
+
+                            float penalty = 0;
+
+                            if (treeSamples.PredictorFromIndex(pred) != tree[pos].Predictor &&
+                                tree[pos].Predictor != JxlPredictor.Weighted)
+                            {
+                                penalty = changePredictionPenalty;
+                            }
+
+                            if (treeSamples.PredictorFromIndex(pred) == JxlPredictor.Weighted)
+                            {
+                                penalty += 1e-8f;
+                            }
+
+                            if (treeSamples.PredictorFromIndex(pred) == JxlPredictor.Zero)
+                            {
+                                penalty -= 1e-8f;
+                            }
+
+                            if (rightCost + penalty < rightCosts[i - firstUsed].TotalCost)
+                            {
+                                CostInfo cost = rightCosts[i - firstUsed];
+                                cost.Cost = rightCost;
+                                cost.ExtraCost = penalty;
+                                cost.Predictor = treeSamples.PredictorFromIndex(pred);
+                                rightCosts[i - firstUsed] = cost;
+                            }
+
+                            if (leftCost + penalty < leftCosts[i - firstUsed].TotalCost)
+                            {
+                                CostInfo cost = leftCosts[i - firstUsed];
+                                cost.Cost = leftCost;
+                                cost.ExtraCost = penalty;
+                                cost.Predictor = treeSamples.PredictorFromIndex(pred);
+                                leftCosts[i - firstUsed] = cost;
+                            }
+                        }
+                    }
+
+                    int split = begin;
+
+                    for (int i = firstUsed; i < lastUsed; i++)
+                    {
+                        if (propertyValueUsedCount[i] == 0)
+                        {
+                            continue;
+                        }
+
+                        split += propertyValueUsedCount[i];
+
+                        float rightCost = rightCosts[i - firstUsed].Cost;
+                        float leftCost = leftCosts[i - firstUsed].Cost;
+
+                        bool usesWeightedPrediction = treeSamples.PropertyFromIndex(prop) == JxlMaConstants.WpProp ||
+                                leftCosts[i - firstUsed].Predictor == JxlPredictor.Weighted ||
+                                rightCosts[i - firstUsed].Predictor == JxlPredictor.Weighted;
+
+                        bool zeroEntropySide = rightCost == 0 || leftCost == 0;
+
+                        // Using pointer specifically for this variable instead of
+                        // ref, as we can't assign a ref variable conditionally.
+                        SplitInfo* referenceToBest =
+                            treeSamples.PropertyFromIndex(prop) < JxlPredictorFacts.StaticProperties
+                                ? (zeroEntropySide ? &bestSplitStaticConstant : &bestSplitStatic)
+                                : (usesWeightedPrediction ? &bestSplitNonStatic : &bestSplitNoWeightedPrediction);
+
+                        if (leftCost + rightCost < referenceToBest->Cost)
+                        {
+                            referenceToBest->Property = prop;
+                            referenceToBest->Value = i;
+                            referenceToBest->Position = split;
+                            referenceToBest->LeftCost = leftCost;
+                            referenceToBest->LeftPredictor = leftCosts[i - firstUsed].Predictor;
+                            referenceToBest->RightCost = rightCost;
+                            referenceToBest->RightPredictor = rightCosts[i - firstUsed].Predictor;
+                        }
+                    }
+
+                    extraBitsIncrease[lastUsed] = 0;
+
+                    for (int sym = 0; sym < maxSymbols; sym++)
+                    {
+                        countsIncrease[(lastUsed * maxSymbols) + sym] = 0;
+                    }
+                }
+
+                if (bestSplitNoWeightedPrediction.Cost + threshold < baseBits &&
+                    bestSplitNoWeightedPrediction.Cost <= fastDecodeMultiplier * best.Cost)
+                {
+                    best = ref bestSplitNoWeightedPrediction;
+                }
+
+                if (bestSplitStatic.Cost + threshold < baseBits &&
+                    bestSplitStatic.Cost <= fastDecodeMultiplier * best.Cost)
+                {
+                    best = ref bestSplitStatic;
+                }
+
+                if (bestSplitStaticConstant.Cost + threshold < baseBits)
+                {
+                    best = ref bestSplitStaticConstant;
+                }
+
+                ArrayPool<int>.Shared.Return(aboveCounts);
+                ArrayPool<int>.Shared.Return(belowCounts);
+            }
+
+            if (best.Cost + threshold < baseBits)
+            {
+                int p = treeSamples.PropertyFromIndex(best.Property);
+                int dequant = treeSamples.UnquantizeProperty(best.Property, best.Value);
+
+                MakeSplitNode(pos, p, dequant, best.LeftPredictor, 0, best.RightPredictor, 0, tree);
+
+                if (best.Property < treeSamples.NumberOfStaticProperties)
+                {
+                    SplitTreeSamples(true, treeSamples, begin, best.Position, end, best.Property, best.Value);
+                }
+                else
+                {
+                    SplitTreeSamples(false, treeSamples, begin, best.Position, end, best.Property - treeSamples.NumberOfStaticProperties, best.Value);
+                }
+
+                StaticPropertyRange newStaticPropertyRange = staticPropertyRange;
+
+                if (p < JxlPredictorFacts.StaticProperties)
+                {
+                    if (dequant + 1 > newStaticPropertyRange[p][1])
+                    {
+                        throw new InvalidOperationException("Dequantized coefficient is out of range");
+                    }
+
+                    newStaticPropertyRange[p][1] = dequant + 1;
+
+                    if (newStaticPropertyRange[p][0] >= newStaticPropertyRange[p][1])
+                    {
+                        throw new InvalidOperationException("Static property is out of range");
+                    }
+                }
+
+                nodes.Push(new(tree[pos].RightChild, begin, best.Position, newStaticPropertyRange));
+                newStaticPropertyRange = staticPropertyRange;
+
+                if (p < JxlPredictorFacts.StaticProperties)
+                {
+                    if (newStaticPropertyRange[p][0] > dequant + 1)
+                    {
+                        throw new InvalidOperationException("Static property must be <= dequantized coefficient");
+                    }
+
+                    newStaticPropertyRange[p][0] = dequant + 1;
+
+                    if (newStaticPropertyRange[p][0] >= newStaticPropertyRange[p][1])
+                    {
+                        throw new InvalidOperationException("Static property is out of range");
+                    }
+                }
+
+                nodes.Push(new NodeInfo(tree[pos].LeftChild, best.Position, end, newStaticPropertyRange));
+            }
+
+            ArrayPool<int>.Shared.Return(counts);
+        }
+    }
+
+    public static void ComputeBestTree(JxlTreeSamples treeSamples, float threshold, List<JxlModularMultiplierInfo> mulInfo, StaticPropertyRange staticPropertyRange, float fastDecodeMultiplier, Tree tree)
+    {
+        JxlPropertyDecisionNode node = new()
+        {
+            Property = -1,
+            Predictor = treeSamples.PredictorFromIndex(0),
+            PredictorOffset = 0,
+            Multiplier = 1
+        };
+
+        tree.Add(node);
+
+        if (treeSamples.NumberOfProperties >= 64)
+        {
+            throw new InvalidOperationException($"Too many properties: {treeSamples.NumberOfPredictors}");
+        }
+
+        FindBestSplit(treeSamples, threshold, mulInfo, staticPropertyRange, fastDecodeMultiplier, tree);
+    }
+
+    public static List<int> QuantizeHistogram(ReadOnlySpan<int> histogram, int numChunks)
+    {
+        if (histogram.Length == 0 || numChunks == 0)
+        {
+            return [];
+        }
+
+        int sum = TensorPrimitives.Sum(histogram);
+
+        if (sum == 0)
+        {
+            return [];
+        }
+
+        List<int> thresholds = [];
+
+        long cumulativeSum = 0;
+        long threshold = 1;
+
+        for (int i = 0; i < histogram.Length; i++)
+        {
+            cumulativeSum += histogram[i];
+
+            if (cumulativeSum * numChunks >= threshold * sum)
+            {
+                thresholds.Add(i);
+
+                while (cumulativeSum * numChunks >= threshold * sum)
+                {
+                    threshold++;
+                }
+            }
+        }
+
+        if (thresholds.Count > numChunks)
+        {
+            throw new InvalidOperationException("Too many thresholds");
+        }
+
+        thresholds.RemoveAt(thresholds.Count - 1);
+
+        return thresholds;
+    }
+
+    public static List<int> QuantizeSamples(ReadOnlySpan<int> samples, int numChunks)
+    {
+        const int range = 512;
+
+        if (samples.Length == 0)
+        {
+            return [];
+        }
+
+        int min = Math.Clamp(TensorPrimitives.Min(samples), -range, range);
+
+        Span<int> counts = stackalloc int[2048].Slice(0, (2 * range) + 1);
+
+        for (int i = 0; i < samples.Length; i++)
+        {
+            int s = samples[i];
+            int sampleOffset = Math.Clamp(s, -range, range) - min;
+            counts[sampleOffset]++;
+        }
+
+        List<int> thresholds = QuantizeHistogram(counts, numChunks);
+
+        // For fast processing via TensorPrimitives
+        Span<int> thresholdsSpan = CollectionsMarshal.AsSpan(thresholds);
+        TensorPrimitives.Add(thresholdsSpan, min, thresholdsSpan);
+
+        return thresholds;
+    }
+
+    public static void QuantMap(Span<int> from, Span<int> to, int numPegs, int bias)
+    {
+        int mapped = 0;
+
+        for (int i = 0; i < numPegs; i++)
+        {
+            while (mapped < from.Length && i - bias > from[mapped])
+            {
+                mapped++;
+            }
+
+            to[i] = mapped;
+        }
+    }
+
+    public static void CollectPixelSamples(Configuration configuration, JxlModularImage image, JxlModularOptions options, int groupId, Span<int> groupPixelCount, Span<int> channelPixelCount, List<int> pixelSamples, List<int> diffSamples)
+    {
+        if (options.NumberOfRepeats == 0)
+        {
+            throw new InvalidOperationException("No repeats");
+        }
+
+        // Power of 2 size is unknown.
+        Span<int> alignedGroupPixelCount = stackalloc int[groupPixelCount.Length <= groupId ? groupId + 1 : groupPixelCount.Length];
+        groupPixelCount.CopyTo(alignedGroupPixelCount);
+
+        Span<int> alignedChannelPixelCount = stackalloc int[channelPixelCount.Length < image.Channels.Count ? image.Channels.Count : channelPixelCount.Length];
+        channelPixelCount.CopyTo(alignedGroupPixelCount);
+
+        Rng rng = new((ulong)groupId);
+
+        float fraction = MathF.Min(options.NumberOfRepeats * 0.1f, 0.99f);
+        Rng.GeometricDistribution dist = new(fraction);
+
+        int totalPixels = 0;
+        List<int> channelIds = [];
+
+        int i;
+        for (i = 0; i < image.Channels.Count; i++)
+        {
+            JxlModularChannel channel = image.Channels[i];
+
+            if (i >= image.MetaChannels && (channel.Width > options.MaxChannelSize || channel.Height > options.MaxChannelSize))
+            {
+                break;
+            }
+
+            if (channel.Width <= 1 || channel.Height == 0)
+            {
+                continue;
+            }
+
+            channelIds.Add(i);
+
+            groupPixelCount[groupId] += channel.Width * channel.Height;
+            channelPixelCount[i] += channel.Width * channel.Height;
+            totalPixels += channel.Width * channel.Height;
+        }
+
+        if (channelIds.Count == 0)
+        {
+            throw new InvalidOperationException("No channel IDs");
+        }
+
+        pixelSamples.Grow(0, (int)(pixelSamples.Count + (fraction * totalPixels)));
+        diffSamples.Grow(0, (int)(diffSamples.Count + (fraction * totalPixels)));
+
+        i = 0;
+        int y = 0;
+        int x = 0;
+
+        void Advance(uint amount)
+        {
+            x += (int)amount;
+
+            while (x >= image.Channels[channelIds[i]].Width)
+            {
+                x -= image.Channels[channelIds[i]].Width;
+                y++;
+
+                if (y == image.Channels[channelIds[i]].Height)
+                {
+                    i++;
+                    y = 0;
+
+                    if (i >= channelIds.Count)
+                    {
+                        return;
+                    }
+                }
+            }
+        }
+
+        Advance(rng.Geometric(in dist));
+
+        for (; i < channelIds.Count; Advance(rng.Geometric(in dist) + 1))
+        {
+            Span<int> row = image.Channels[channelIds[i]].GetRow(y);
+            pixelSamples.Add(row[x]);
+
+            int xp = x == 0 ? 1 : x - 1;
+            diffSamples.Add(row[x] - row[xp]);
+        }
+    }
+
+    public static void TokenizeTree(Tree tree, List<JxlToken> tokens, Tree decoderTree)
+    {
+        if (tree.Count > JxlMaConstants.MaxTreeSize)
+        {
+            throw new InvalidOperationException("Too many tree nodes");
+        }
+
+        Queue<int> q = [];
+        q.Enqueue(0);
+
+        int leafId = 0;
+        decoderTree.Clear();
+
+        while (q.Count > 0)
+        {
+            int cur = q.Peek();
+            _ = q.Dequeue();
+
+            if (tree[cur].Property < -1)
+            {
+                throw new InvalidOperationException("Property value is too small");
+            }
+
+            tokens.Add(new JxlToken(JxlMaTreeContext.Property, (uint)tree[cur].Property + 1));
+
+            if (tree[cur].Property == -1)
+            {
+                tokens.Add(new JxlToken(JxlMaTreeContext.Predictor, (uint)tree[cur].Predictor));
+                tokens.Add(new JxlToken(JxlMaTreeContext.Offset, JxlPackSigned.PackUnsigned((int)tree[cur].PredictorOffset)));
+
+                uint mulLog = JxlMath.Num0BitsBelowLS1Bit_Nonzero(tree[cur].Multiplier);
+                int mulBits = (tree[cur].Multiplier >> (int)mulLog) - 1;
+
+                tokens.Add(new JxlToken(JxlMaTreeContext.MultiplierLog, mulLog));
+                tokens.Add(new JxlToken(JxlMaTreeContext.MultiplierBits, (uint)mulBits));
+
+                if (tree[cur].Predictor >= JxlPredictor.Best)
+                {
+                    throw new InvalidOperationException("Invalid predictor");
+                }
+
+                decoderTree.Add(new JxlPropertyDecisionNode(-1, 0, leafId, 0, tree[cur].Predictor, tree[cur].PredictorOffset, tree[cur].Multiplier));
+                leafId++;
+
+                continue;
+            }
+
+            decoderTree.Add(new JxlPropertyDecisionNode(tree[cur].Property, tree[cur].SplitValue, decoderTree.Count + q.Count + 1, decoderTree.Count + q.Count + 2, JxlPredictor.Zero, 0, 1));
+
+            q.Enqueue(tree[cur].LeftChild);
+            q.Enqueue(tree[cur].RightChild);
+
+            tokens.Add(new JxlToken(JxlMaTreeContext.SplitValue, JxlPackSigned.PackUnsigned(tree[cur].SplitValue)));
+        }
+    }
+
+    private readonly record struct NodeInfo(int Pos, int Begin, int End, StaticPropertyRange StaticPropertyRange);
+
+    private struct SplitInfo()
+    {
+        public int Property { get; set; }
+
+        public int Value { get; set; }
+
+        public int Position { get; set; }
+
+        public float LeftCost { get; set; } = float.MaxValue;
+
+        public float RightCost { get; set; } = float.MaxValue;
+
+        public JxlPredictor LeftPredictor { get; set; } = JxlPredictor.Zero;
+
+        public JxlPredictor RightPredictor { get; set; } = JxlPredictor.Zero;
+
+        public readonly float Cost => this.LeftCost + this.RightCost;
+    }
+
+    private struct CostInfo()
+    {
+        public float Cost { get; set; } = float.MaxValue;
+
+        public float ExtraCost { get; set; }
+
+        public JxlPredictor Predictor { get; set; }
+
+        public readonly float TotalCost => this.Cost + this.ExtraCost;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaTreeContext.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaTreeContext.cs
new file mode 100644
index 0000000000..8c04283516
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlMaTreeContext.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal enum JxlMaTreeContext : byte
+{
+    SplitValue,
+
+    Property,
+
+    Predictor,
+
+    Offset,
+
+    MultiplierLog,
+
+    MultiplierBits
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlModularEncoding.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlModularEncoding.cs
new file mode 100644
index 0000000000..a63960f038
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlModularEncoding.cs
@@ -0,0 +1,867 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using FlatTree = System.Collections.Generic.List<SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction.JxlFlatDecisionNode>;
+using Tree = System.Collections.Generic.List<SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.JxlPropertyDecisionNode>;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal static class JxlModularEncoding
+{
+    public static bool TreeToLookupTable<T>(FlatTree tree, JxlTreeLut<T> lut)
+    {
+        bool hasOffsets = lut.Offsets.Length > 0;
+        bool hasMultipliers = lut.Multipliers.Length > 0;
+
+        Stack<TreeRange> ranges = [];
+        ranges.Push(new(-JxlMaConstants.PropertyRangeFast - 1, JxlMaConstants.PropertyRangeFast - 1, 0));
+        while (ranges.Count > 0)
+        {
+            TreeRange cur = ranges.Peek();
+            _ = ranges.Pop();
+
+            if (cur.Begin < -JxlMaConstants.PropertyRangeFast - 1 || cur.begin >= JxlMaConstants.PropertyRangeFast - 1 || cur.end > JxlMaConstants.PropertyRangeFast - 1)
+            {
+                // Tree is outside the allowed range, exit.
+                return false;
+            }
+
+            JxlFlatDecisionNode node = tree[cur.Pos];
+
+            // Leaf.
+            if (node.Property0 == -1)
+            {
+                if (node.PredictorOffset is < sbyte.MinValue or > sbyte.MaxValue)
+                {
+                    return false;
+                }
+
+                if (node.Multiplier is < sbyte.MinValue or > sbyte.MaxValue)
+                {
+                    return false;
+                }
+
+                if (!hasMultipliers && node.Multiplier != 1)
+                {
+                    return false;
+                }
+
+                if (!hasOffsets && node.PredictorOffset != 0)
+                {
+                    return false;
+                }
+
+                for (int i = cur.Begin + 1; i < cur.End + 1; i++)
+                {
+                    lut.ContextLookup[i + JxlMaConstants.PropertyRangeFast] = node.ChildID;
+
+                    if (hasMultipliers)
+                    {
+                        lut.Multipliers[i + JxlMaConstants.PropertyRangeFast] = node.Multiplier;
+                    }
+
+                    if (hasOffsets)
+                    {
+                        lut.Offsets[i + JxlMaConstants.PropertyRangeFast] = node.PredictorOffset;
+                    }
+                }
+
+                continue;
+            }
+
+            if (node.Properties[0] >= JxlPredictorFacts.StaticProperties)
+            {
+                ranges.Push(new(node.SplitValues[0], cur.End, node.ChildID));
+                ranges.Push(new(node.SplitValue0, node.SplitValues[0], node.ChildID + 1));
+            }
+            else
+            {
+                ranges.Push(new(node.SplitValue0, cur.End, node.ChildID));
+            }
+
+            // <= side
+            if (node.Properties[1] >= JxlPredictorFacts.StaticProperties)
+            {
+                ranges.Push(
+                    new(node.SplitValues[1], node.SplitValue0, node.ChildID + 2));
+                ranges.Push(
+                    new(cur.Begin, node.SplitValues[1], node.ChildID + 3));
+            }
+            else
+            {
+                ranges.Push(new(cur.Begin, node.SplitValue0, node.ChildID + 2));
+            }
+        }
+
+        return true;
+    }
+
+    public static FlatTree FilterTree(Tree globalTree, Span<int> staticProps, ref int numProps, ref bool useWp, ref bool wpOnly, ref bool gradientOnly)
+    {
+        numProps = 0;
+        bool hasWeightedPrediction = false;
+        bool hasNonWeighted = false;
+        gradientOnly = true;
+
+        void MarkProperty(int p, ref bool gradientOnly)
+        {
+            if (p == WpProp)
+            {
+                hasWeightedPrediction = true;
+            }
+            else if (p >= JxlPredictorFacts.StaticProperties)
+            {
+                hasNonWeighted = true;
+            }
+
+            if (p >= JxlPredictorFacts.StaticProperties && p != GradientProp)
+            {
+                gradientOnly = false;
+            }
+        }
+
+        FlatTree output = [];
+        Queue<int> nodes = [];
+        nodes.Enqueue(0);
+
+        while (nodes.Count > 0)
+        {
+            int cur = nodes.Peek();
+            _ = nodes.Dequeue();
+
+            while (globalTree[cur].Property is < JxlPredictorFacts.StaticProperties and not -1)
+            {
+                if (staticProps[globalTree[cur].Property] > globalTree[cur].SplitValue)
+                {
+                    cur = globalTree[cur].LeftChild;
+                }
+                else
+                {
+                    cur = globalTree[cur].RightChild;
+                }
+            }
+
+            JxlFlatDecisionNode flat = default;
+
+            if (globalTree[cur].Property == -1)
+            {
+                flat.Property0 = -1;
+                flat.ChildID = (uint)globalTree[cur].LeftChild;
+                flat.Predictor = globalTree[cur].Predictor;
+                flat.PredictorOffset = (int)globalTree[cur].PredictorOffset;
+                flat.Multiplier = globalTree[cur].Multiplier;
+
+                gradientOnly &= flat.Predictor == JxlPredictor.Gradient;
+
+                hasWeightedPrediction |= flat.Predictor == JxlPredictor.Weighted;
+                hasNonWeighted |= flat.Predictor != JxlPredictor.Weighted;
+                output.Add(flat);
+                continue;
+            }
+
+            flat.ChildID = (uint)(output.Count + nodes.Count + 1);
+
+            flat.Property0 = globalTree[cur].Property;
+            numProps = Math.Max(flat.Property0 + 1, numProps);
+            flat.SplitValue0 = globalTree[cur].SplitValue;
+
+            for (int i = 0; i < 2; i++)
+            {
+                int currentChild = i == 0 ? globalTree[cur].LeftChild : globalTree[cur].RightChild;
+
+                while (globalTree[currentChild].Property < JxlPredictorFacts.StaticProperties && globalTree[currentChild].Property != -1)
+                {
+                    if (staticProps[globalTree[currentChild].Property] >
+                        globalTree[currentChild].SplitValue)
+                    {
+                        currentChild = globalTree[currentChild].LeftChild;
+                    }
+                    else
+                    {
+                        currentChild = globalTree[currentChild].RightChild;
+                    }
+                }
+
+                if (globalTree[currentChild].Property == -1)
+                {
+                    flat.Properties[i] = 0;
+                    flat.SplitValues[i] = 0;
+                    nodes.Enqueue(currentChild);
+                    nodes.Enqueue(currentChild);
+                }
+                else
+                {
+                    flat.Properties[i] = globalTree[currentChild].Property;
+                    flat.SplitValues[i] = globalTree[currentChild].SplitValue;
+                    nodes.Enqueue(globalTree[currentChild].LeftChild);
+                    nodes.Enqueue(globalTree[currentChild].RightChild);
+
+                    numProps = Math.Max(flat.Properties[i] + 1, numProps);
+                }
+            }
+
+            for (int i = 0; i < 2; i++)
+            {
+                short property = flat.Properties[i];
+                MarkProperty(property, ref gradientOnly);
+            }
+
+            MarkProperty(flat.Property0, ref gradientOnly);
+
+            output.Add(flat);
+        }
+
+        if (numProps > JxlMaConstants.NumTreeContexts)
+        {
+            numProps = (JxlMath.DivCeil(numProps - JxlMaConstants.NumTreeContexts, JxlContextPrediction.ExtraPropertiesPerChannel) * JxlContextPrediction.ExtraPropertiesPerChannel) + JxlMaConstants.NumTreeContexts;
+        }
+        else
+        {
+            numProps = JxlMaConstants.NumTreeContexts;
+        }
+
+        useWp = hasWeightedPrediction;
+        wpOnly = hasWeightedPrediction && !hasNonWeighted;
+
+        return output;
+    }
+
+    public static void DecodeModularChannelMAANS(Configuration configuration, bool usesLz77, JxlBitReader bitReader, JxlAnsSymbolReader reader, List<byte> contextMap, Tree globalTree, JxlModularHeader wpHeader, int channelIdx, int groupId, JxlTreeLut<byte> treeLookup, JxlModularImage image, ref uint flRun, ref uint flV)
+    {
+        JxlModularChannel channel = image.Channels[channelIdx];
+
+        InlineArray2<int> staticProps = default;
+        staticProps[0] = channelIdx;
+        staticProps[1] = groupId;
+
+        if ((channel.Width & channel.Height) == 0) // equivalent to (channel.Width == 0 || channel.Height == 0)
+        {
+            return;
+        }
+
+        bool treeHasWeightedPredictionPropOrPred = false;
+        bool isWeightedPredictionOnly = false;
+        bool isGradientOnly = false;
+        int numProps = 0;
+
+        FlatTree tree = FilterTree(globalTree, staticProps, ref numProps, ref treeHasWeightedPredictionPropOrPred, ref isWeightedPredictionOnly, ref isGradientOnly);
+        Span<JxlFlatDecisionNode> span = CollectionsMarshal.AsSpan(tree);
+
+        for (int i = 0; i < span.Length; i++)
+        {
+            ref JxlFlatDecisionNode node = ref span[i];
+
+            if (node.Property0 == -1)
+            {
+                node.ChildID = contextMap[(int)node.ChildID];
+            }
+        }
+
+        int MakePixel(uint v, int multiplier, int offset)
+        {
+            int value = JxlPackSigned.UnpackSigned(v);
+            return (value * multiplier) + offset;
+        }
+
+        bool GlobalTreeIsAllGradientNoOp()
+        {
+            foreach (JxlPropertyDecisionNode n in globalTree)
+            {
+                if (n.Property == -1)
+                {
+                    if (n.Predictor != JxlPredictor.Gradient || n.PredictorOffset != 0 || n.Multiplier != 1)
+                    {
+                        return false;
+                    }
+                }
+                else if (n.Property >= JxlPredictorFacts.StaticProperties)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        if (tree.Count == 1)
+        {
+            JxlPredictor predictor = tree[0].Predictor;
+            int offset = tree[0].PredictorOffset;
+            int multiplier = tree[0].Multiplier;
+            uint ctx_id = tree[0].ChildID;
+
+            if (predictor == JxlPredictor.Zero)
+            {
+                if (reader.IsSingleValueAndAdvance(ctx_id, channel.Width * channel.Height, out uint value))
+                {
+                    int v = MakePixel(value, multiplier, offset);
+
+                    for (int y = 0; y < channel.Height; y++)
+                    {
+                        Span<int> r = channel.GetRow(y);
+                        r[..channel.Width].Fill(v);
+                    }
+                }
+                else
+                {
+                    if (multiplier == 1 && offset == 0)
+                    {
+                        for (int y = 0; y < channel.Height; y++)
+                        {
+                            Span<int> r = channel.GetRow(y);
+
+                            for (int x = 0; x < channel.Width; x++)
+                            {
+                                uint v = reader.ReadHybridUintClusteredInlined(usesLz77, ctx_id, bitReader);
+
+                                r[x] = JxlPackSigned.UnpackSigned(v);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        for (int y = 0; y < channel.Height; y++)
+                        {
+                            Span<int> r = channel.GetRow(y);
+
+                            for (int x = 0; x < channel.Width; x++)
+                            {
+                                uint v = reader.ReadHybridUintClusteredMaybeInlined(usesLz77, ctx_id, bitReader);
+
+                                r[x] = MakePixel(v, multiplier, offset);
+                            }
+                        }
+                    }
+                }
+
+                return;
+            }
+            else if (usesLz77 && reader.IsHuffRleOnly && GlobalTreeIsAllGradientNoOp())
+            {
+                int sv = JxlPackSigned.UnpackSigned(flV);
+
+                for (int y = 0; y < channel.Height; y++)
+                {
+                    Span<int> r = channel.GetRow(y);
+                    Span<int> rtop = y > 0 ? channel.GetRow(y - 1) : channel.GetRowMinus(y, 1);
+                    Span<int> rtopleft = y > 0 ? channel.GetRowMinus(y - 1, 1) : channel.GetRowMinus(y, 1);
+                    int guess0 = y > 0 ? rtop[0] : 0;
+
+                    if (flRun == 0)
+                    {
+                        reader.ReadHybridUintClusteredHuffRleOnly(ctx_id, bitReader, ref flV, ref flRun);
+                        sv = JxlPackSigned.UnpackSigned(flV);
+                    }
+                    else
+                    {
+                        flRun--;
+                    }
+
+                    r[0] = sv + guess0;
+
+                    for (int x = 1; x < channel.Width; x++)
+                    {
+                        int left = r[x - 1];
+                        int top = rtop[x];
+                        int topleft = rtopleft[x];
+                        int guess = JxlContextPrediction.ClampedGradient(top, left, topleft);
+
+                        if (flRun == 0)
+                        {
+                            reader.ReadHybridUintClusteredHuffRleOnly(ctx_id, bitReader, ref flV, ref flRun);
+                            sv = JxlPackSigned.UnpackSigned(flV);
+                        }
+                        else
+                        {
+                            flRun--;
+                        }
+
+                        r[x] = sv + guess;
+                    }
+                }
+
+                return;
+            }
+            else if (predictor == JxlPredictor.Gradient && offset == 0 && multiplier == 1)
+            {
+                int onerow = channel.Plane.PixelsPerRow;
+
+                for (int y = 0; y < channel.Height; y++)
+                {
+                    Span<int> r = channel.GetRow(y);
+
+                    for (int x = 0; x < channel.Width; x++)
+                    {
+                        // Neighbors
+                        int left = x > 0 ? r[x - 1] : y > 0 ? channel.GetRowMinus(y, x - onerow)[0] : 0;
+                        int top = y > 0 ? channel.GetRowMinus(y, x - onerow)[0] : left;
+                        int topleft = x > 0 && y > 0 ? channel.GetRowMinus(y, x - 1 - onerow)[0] : left;
+
+                        int guess = JxlContextPrediction.ClampedGradient(top, left, topleft);
+                        uint v = reader.ReadHybridUintClusteredMaybeInlined>(
+                            usesLz77,
+                            ctx_id,
+                            bitReader);
+
+                        r[x] = MakePixel(v, 1, guess);
+                    }
+                }
+
+                return;
+            }
+        }
+
+        if (isWeightedPredictionOnly)
+        {
+            isWeightedPredictionOnly = TreeToLookupTable(tree, treeLookup);
+        }
+
+        if (isGradientOnly)
+        {
+            isGradientOnly = TreeToLookupTable(tree, treeLookup);
+        }
+
+        if (isGradientOnly)
+        {
+            int onerow = channel.Plane.PixelsPerRow;
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> r = channel.GetRow(y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    // Neighbors
+                    int left = x > 0 ? channel.GetRowPlus(y, x - 1)[0] : y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : 0;
+                    int top = y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : left;
+                    int topleft = x > 0 && y > 0 ? channel.GetRowPlus(y, x - 1 - onerow)[0] : left;
+
+                    int guess = JxlContextPrediction.ClampedGradient(top, left, topleft);
+                    int pos =
+                        JxlMaConstants.PropertyRangeFast +
+                        Math.Min(
+                            Math.Max(-JxlMaConstants.PropertyRangeFast, top + left - topleft),
+                            JxlMaConstants.PropertyRangeFast - 1);
+
+                    uint ctx_id = treeLookup.ContextLookup[pos];
+                    uint v = reader.ReadHybridUintClusteredMaybeInlined(usesLz77, ctx_id, br);
+                    r[x] = MakePixel(v, 1, guess);
+                }
+            }
+        }
+        else if (!usesLz77 && isWeightedPredictionOnly && channel.Width > 8)
+        {
+            JxlModularState wpState = new(wpHeader, channel.Width);
+            Span<int> properties = [0];
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> r = channel.GetRow(y);
+                Span<int> rtop = y > 0 ? channel.GetRow(y - 1) : channel.GetRowMinus(y, 1);
+                Span<int> rtoptop = y > 1 ? channel.GetRow(y - 2) : rtop;
+                Span<int> rtopleft = y > 0 ? channel.GetRowMinus(y - 1, 1) : channel.GetRowMinus(y, 1);
+                Span<int> rtopright = y > 0 ? channel.GetRow(y - 1)[1..] : channel.GetRowMinus(y, 1);
+
+                int x = 0;
+                {
+                    int offset = 0;
+                    int left = y > 0 ? rtop[x] : 0;
+                    int toptop = y > 0 ? rtoptop[x] : 0;
+                    int topright = x + 1 < channel.Width && y > 0 ? rtop[x + 1] : left;
+
+                    int guess = (int)wpState.Predict(true, x, y, channel.Width, left, left, topright, left, toptop, properties, offset);
+                    int pos = JxlMaConstants.PropertyRangeFast + Math.Clamp(properties[0], -JxlMaConstants.PropertyRangeFast, JxlMaConstants.PropertyRangeFast - 1);
+
+                    uint ctx_id = treeLookup.ContextLookup[pos];
+                    uint v = reader.ReadHybridUintClusteredInlined(usesLz77, ctx_id, bitReader);
+
+                    r[x] = MakePixel(v, 1, guess);
+                    wpState.UpdatePredictionErrors(r[x], x, y, channel.Width);
+                }
+
+                for (x = 1; x + 1 < channel.Width; x++)
+                {
+                    int offset = 0;
+                    int guess = (int)wpState.Predict(true, x, y, channel.Width, rtop[x], r[x - 1], rtopright[x], rtopleft[x], rtoptop[x], properties, offset);
+                    int pos = JxlMaConstants.PropertyRangeFast + Math.Clamp(properties[0], -JxlMaConstants.PropertyRangeFast, JxlMaConstants.PropertyRangeFast - 1);
+
+                    int ctx_id = treeLookup.ContextLookup[pos];
+                    uint v = reader.ReadHybridUintClusteredInlined(usesLz77, ctx_id, bitReader);
+
+                    r[x] = MakePixel(v, 1, guess);
+                    wpState.UpdatePredictionErrors(r[x], x, y, channel.Width);
+                }
+
+                {
+                    int offset = 0;
+                    int guess = (int)wpState.Predict(true, x, y, channel.Width, rtop[x], r[x - 1], rtop[x], rtopleft[x], rtoptop[x], properties, offset);
+                    int pos = JxlMaConstants.PropertyRangeFast + Math.Clamp(properties[0], -JxlMaConstants.PropertyRangeFast, JxlMaConstants.PropertyRangeFast - 1);
+
+                    int ctx_id = treeLookup.ContextLookup[pos];
+                    uint v = reader.ReadHybridUintClusteredInlined(usesLz77, ctx_id, bitReader);
+
+                    r[x] = MakePixel(v, 1, guess);
+                    wpState.UpdatePredictionErrors(r[x], x, y, channel.Width);
+                }
+            }
+        }
+        else if (!treeHasWeightedPredictionPropOrPred)
+        {
+            JxlMaTreeLookup tree_lookup = new(tree);
+            Span<int> properties = stackalloc int[numProps];
+            int onerow = channel.Plane.PixelsPerRow;
+
+            JxlModularChannel references = new(configuration, properties.Length - NumNonrefProperties, channel.Width, 0, 0);
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> p = channel.GetRow(y);
+                PrecomputeReferences(channel, y, image, channelIdx, references);
+                InitPropsRow(properties, staticProps, y);
+
+                if (y > 1 && channel.Width > 8 && references.Width == 0)
+                {
+                    for (int x = 0; x < 2; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeNoWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references);
+                        uint v = reader.ReadHybridUintClustered(usesLz77, res.Context, bitReader);
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                    }
+
+                    for (int x = 2; x < channel.Width - 2; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeNoWeightedPredictionNoEdgeCases(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references);
+                        uint v = reader.ReadHybridUintClusteredInlined(usesLz77, res.Context, bitReader);
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                    }
+
+                    for (int x = channel.Width - 2; x < channel.Width; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeNoWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references);
+                        uint v = reader.ReadHybridUintClustered(usesLz77, res.Context, bitReader);
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                    }
+                }
+                else
+                {
+                    for (int x = 0; x < channel.Width; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeNoWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references);
+                        uint v = reader.ReadHybridUintClusteredMaybeInlined(usesLz77, res.Context, bitReader);
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                    }
+                }
+            }
+        }
+        else
+        {
+            JxlMaTreeLookup tree_lookup = new(tree);
+            Span<int> properties = stackalloc int[numProps];
+            int onerow = channel.Plane.PixelsPerRow;
+
+            JxlModularChannel references = new(configuration, properties.Length - NumNonrefProperties, channel.Width, 0, 0);
+            JxlModularState wpState = new(wpHeader, channel.Width);
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> p = channel.GetRow(y);
+                InitPropsRow(properties, staticProps, y);
+                PrecomputeReferences(channel, y, image, channelIdx, references);
+
+                if (!usesLz77 && y > 1 && channel.Width > 8 && references.Width == 0)
+                {
+                    for (int x = 0; x < 2; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references, wpState);
+                        uint v = reader.ReadHybridUintClustered(usesLz77, res.Context, bitReader);
+
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                        wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+                    }
+
+                    for (int x = 2; x < channel.Width - 2; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeWeightedPredictionNoEdgeCases(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references, wpState);
+                        uint v = reader.ReadHybridUintClusteredInlined(usesLz77, res.Context, bitReader);
+
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                        wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+                    }
+
+                    for (int x = channel.Width - 2; x < channel.Width; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references, wpState);
+                        uint v = reader.ReadHybridUintClustered(usesLz77, res.Context, bitReader);
+
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                        wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+                    }
+                }
+                else
+                {
+                    for (int x = 0; x < channel.Width; x++)
+                    {
+                        JxlPredictionResult res = JxlContextPrediction.PredictTreeWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, tree_lookup, references, wpState);
+                        uint v = reader.ReadHybridUintClustered(usesLz77, res.Context, bitReader);
+
+                        p[x] = MakePixel(v, res.Multiplier, res.Guess);
+                        wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void DecodeModularChannelMAANS(JxlBitReader bitReader, JxlAnsSymbolReader reader, List<byte> contextMap, Tree globalTree, JxlModularHeader wpHeader, int channelIdx, int groupId, JxlTreeLut<byte> treeLut, JxlModularImage image, ref uint flRun, ref uint flV)
+        => DecodeModularChannelMAANS(reader.UsesLz77, bitReader, reader, contextMap, globalTree, wpHeader, channelIdx, groupId, treeLut, image, ref flRun, ref flV);
+
+    public static void ValidateChannelDimensions(JxlModularImage image, JxlModularOptions options)
+    {
+        int nbChannels = image.Channels.Count;
+
+        foreach (bool isDc in (bool[])[true, false])
+        {
+            int groupDimensions = options.group_dim * (isDc ? JxlFrameDimensions.BlockDimensions : 1);
+            int c = image.MetaChannels;
+
+            for (; c < nbChannels; c++)
+            {
+                JxlModularChannel ch = image.Channels[c];
+                if (ch.Width > options.group_dim || ch.Height > options.group_dim)
+                {
+                    break;
+                }
+            }
+
+            for (; c < nbChannels; c++)
+            {
+                JxlModularChannel ch = image.Channels[c];
+                if (ch.Width == 0 || ch.Height == 0)
+                {
+                    continue;
+                }
+
+                bool isDcChannel = Math.Min(ch.HorizontalShift, ch.VerticalShift) >= 3;
+                if (isDcChannel != isDc)
+                {
+                    continue;
+                }
+
+                int tileDimensions = groupDimensions >> Math.Max(ch.HorizontalShift, ch.VerticalShift);
+                if (tileDimensions == 0)
+                {
+                    throw new InvalidOperationException("Inconsistent transforms");
+                }
+            }
+        }
+    }
+
+    public static bool ModularDecode(Configuration configuration, JxlBitReader br, JxlModularImage image, JxlGroupHeader header, int groupId, JxlModularOptions options, Tree globalTree, JxlAnsCode globalCode, List<byte> globalContextMap, bool allowTruncatedGroup)
+    {
+        if (image.Channels.Count == 0)
+        {
+            return true;
+        }
+
+        if (!JxlBundle.Read(br, header) && !allowTruncatedGroup)
+        {
+            throw new InvalidOperationException("Could not read a bundle");
+        }
+
+        image.Transforms = header.Transforms;
+
+        foreach (JxlTransform transform in image.Transforms)
+        {
+            transform.MetaApply(image);
+        }
+
+        if (image.IsInvalid)
+        {
+            throw new InvalidOperationException("Corrupt file. Aborting.");
+        }
+
+        ValidateChannelDimensions(image, options);
+
+        int numberOfChannels = image.Channels.Count;
+        int numChannels = 0;
+        int distanceMultiplier = 0;
+
+        for (int i = 0; i < numberOfChannels; i++)
+        {
+            JxlModularChannel channel = image.Channels[i];
+            if (i >= image.MetaChannels && (channel.Width > options.MaxChannelSize || channel.Height > options.MaxChannelSize))
+            {
+                break;
+            }
+
+            if (channel.Width == 0 || channel.Height == 0)
+            {
+                continue;  // skip empty channels
+            }
+
+            if (channel.Width > distanceMultiplier)
+            {
+                distanceMultiplier = channel.Width;
+            }
+
+            numChannels++;
+        }
+
+        if (numChannels == 0)
+        {
+            return true;
+        }
+
+        int nextChannel = 0;
+        using JxlScopeGuard clearGuard = new(() =>
+        {
+            for (int c = nextChannel; c < image.Channels.Count; c++)
+            {
+                image.Channels[c].Plane.Clear();
+            }
+        });
+
+        if (allowTruncatedGroup)
+        {
+            clearGuard.Disarm();
+        }
+
+        Tree treeStorage = [];
+        List<byte> contextMapStorage = [];
+        JxlAnsCode codeStorage = new();
+
+        Tree tree = treeStorage;
+        JxlAnsCode code = codeStorage;
+        List<byte> contextMap = contextMapStorage;
+
+        if (!header.UseGlobalTree)
+        {
+            ulong maxTreeSize = 1024;
+
+            for (int i = 0; i < numberOfChannels; i++)
+            {
+                JxlModularChannel channel = image.Channels[i];
+                if (i >= image.MetaChannels && (channel.Width > options.MaxChannelSize || channel.Height > options.MaxChannelSize))
+                {
+                    break;
+                }
+
+                ulong pixels = (ulong)channel.Width * (ulong)channel.Height;
+                maxTreeSize += pixels;
+            }
+
+            maxTreeSize = Math.Min(1uL << 20, maxTreeSize);
+            DecodeTree(configuration, br, treeStorage, maxTreeSize));
+            DecodeHistograms(
+                configuration,
+                br,
+                (treeStorage.Count + 1) / 2,
+                codeStorage,
+                contextMapStorage);
+        }
+        else
+        {
+            if (globalTree.Count == 0)
+            {
+                throw new InvalidOperationException("No global tree available but one was requested");
+            }
+
+            tree = globalTree;
+            code = globalCode;
+            contextMap = globalContextMap;
+        }
+
+        JxlAnsSymbolReader reader = new(code, br, distanceMultiplier);
+        JxlTreeLut<byte> treeLut = new(false, false);
+
+        uint flRun = 0;
+        uint flV = 0;
+
+        for (; nextChannel < numberOfChannels; nextChannel++)
+        {
+            JxlModularChannel channel = image.Channels[nextChannel];
+            if (nextChannel >= image.MetaChannels &&
+                (channel.Width > options.MaxChannelSize ||
+                 channel.Height > options.MaxChannelSize))
+            {
+                break;
+            }
+
+            if (channel.Width == 0 || channel.Height == 0)
+            {
+                continue;  // skip empty channels
+            }
+
+            DecodeModularChannelMAANS(br, reader, contextMap, tree, header.WeightedHeader, nextChannel, groupId, treeLut, image, ref flRun, ref flV);
+        }
+
+        clearGuard.Disarm();
+
+        if (!reader.CheckAnsFinalState())
+        {
+            throw new InvalidOperationException("ANS decode final state failed");
+        }
+
+        return true;
+    }
+
+    public static bool ModularGenericDecompress(Configuration configuration. JxlBitReader br, JxlModularImage image, JxlGroupHeader header, int groupId, JxlModularOptions options, bool undoTransforms, Tree tree, JxlAnsCode code, List<byte> contextMap, bool allowTruncatedGroup)
+    {
+        List<Size> reqSizes = new(capacity: image.Channels.Count);
+
+        foreach (JxlModularChannel c in image.Channels)
+        {
+            reqSizes.Add(new(c.Width, c.Height));
+        }
+
+        header ??= new JxlGroupHeader();
+
+        bool decStatus = ModularDecode(configuration, br, image, header, groupId, options, tree, code, contextMap, allowTruncatedGroup);
+
+        if (!allowTruncatedGroup)
+        {
+            if (!decStatus)
+            {
+                return false;
+            }
+        }
+
+        if (undoTransforms)
+        {
+            image.UndoTransforms(header.WeightedHeader);
+        }
+
+        if (image.IsInvalid)
+        {
+            throw new InvalidOperationException("Corrupt file. Aborting");
+        }
+
+        if (undoTransforms)
+        {
+            if (image.Channels.Count != reqSizes.Count)
+            {
+                return false;
+            }
+
+            for (int c = 0; c < reqSizes.Count; c++)
+            {
+                if (reqSizes[c].Width != image.Channels[c].Width || reqSizes[c].Height != image.Channels[c].Height)
+                {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    private readonly record struct TreeRange(int Begin, int End, int Pos);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlModularEncodingEncoder.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlModularEncodingEncoder.cs
new file mode 100644
index 0000000000..c69e2addf2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlModularEncodingEncoder.cs
@@ -0,0 +1,865 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using FlatTree = System.Collections.Generic.List<SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction.JxlFlatDecisionNode>;
+using StaticPropertyRange = System.Runtime.CompilerServices.InlineArray2<System.Runtime.CompilerServices.InlineArray2<int>>;
+using Tree = System.Collections.Generic.List<SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.JxlPropertyDecisionNode>;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+/// <summary>
+/// Modular-based coding encoder.
+/// </summary>
+internal static class JxlModularEncodingEncoder
+{
+    public static InlineArray3<byte> PredictorColor(JxlPredictor p)
+    {
+        InlineArray3<byte> result = default;
+
+        switch (p)
+        {
+            case JxlPredictor.Zero:
+                break; // result is all 0 by default
+
+            case JxlPredictor.Left:
+                result[0] = 255; // [255, 0, 0]
+                break;
+
+            case JxlPredictor.Top:
+                result[1] = 255; // [0, 255, 0]
+                break;
+
+            case JxlPredictor.Average0:
+                result[2] = 255; // [0, 0, 255]
+                break;
+
+            case JxlPredictor.Average4:
+                // [192, 128, 128]
+                result[0] = 192;
+                result[1] = 128;
+                result[2] = 128;
+                break;
+
+            case JxlPredictor.Select:
+                // [255, 255, 0]
+                result[0] = 255;
+                result[1] = 255;
+                break;
+
+            case JxlPredictor.Gradient:
+                // [255, 0, 255]
+                result[1] = 255;
+                result[2] = 255;
+                break;
+
+            case JxlPredictor.Weighted:
+                // [0, 255, 255]
+                result[1] = 255;
+                result[2] = 255;
+                break;
+
+            default:
+                // [255, 255, 255]
+                result[0] = 255;
+                result[1] = 255;
+                result[2] = 255;
+                break;
+        }
+
+        return result;
+    }
+
+    public static Tree MakeFixedTree(int property, Span<int> cutoffs, JxlPredictor pred, int numPixels, int bitDepth)
+    {
+        int logPx = JxlMath.CeilLog2Nonzero(numPixels);
+        int minGap = 0;
+
+        if (logPx < 14)
+        {
+            minGap = 8 * (14 - logPx);
+        }
+
+        int shift = bitDepth > 11 ? Math.Min(4, bitDepth - 11) : 0;
+        int mul = 1 << shift;
+
+        Tree tree = [];
+        Queue<NodeInfo> q = [];
+
+        tree.Add(JxlPropertyDecisionNode.Leaf(pred));
+        q.Enqueue(new NodeInfo(0, cutoffs.Length, 0));
+
+        while (q.Count > 0)
+        {
+            NodeInfo info = q.Peek();
+            _ = q.Dequeue();
+
+            if (info.Begin + minGap >= info.End)
+            {
+                continue;
+            }
+
+            int split = (info.Begin + info.End) / 2;
+            int cutoff = cutoffs[split] * mul;
+
+            tree[info.Pos] = JxlPropertyDecisionNode.Split(property, cutoff, tree.Count);
+
+            q.Enqueue(new NodeInfo(split + 1, info.End, tree.Count));
+            tree.Add(JxlPropertyDecisionNode.Leaf(pred));
+
+            q.Enqueue(new NodeInfo(info.Begin, split, tree.Count));
+            tree.Add(JxlPropertyDecisionNode.Leaf(pred));
+        }
+
+        return tree;
+    }
+
+    public static void GatherTreeData(Configuration configuration, JxlModularImage image, int channelIndex, int groupId, JxlModularHeader wpHeader, JxlModularOptions options, JxlTreeSamples treeSamples, ref int totalPixels)
+    {
+        JxlModularChannel channel = image.Channels[channelIndex];
+
+        InlineArray2<int> staticProperties = default;
+        staticProperties[0] = channelIndex;
+        staticProperties[1] = groupId;
+
+        Span<int> properties = stackalloc int[JxlMaConstants.NumNonrefProperties + (JxlContextPrediction.ExtraPropertiesPerChannel * options.MaxProperties)];
+
+        double pixelFraction = Math.Min(1.0f, options.NumberOfRepeats);
+
+        if (pixelFraction > 0)
+        {
+            pixelFraction = Math.Max(pixelFraction, Math.Min(1.0, 1024.0 / (channel.Width * channel.Height)));
+        }
+
+        ulong threshold = (ulong)((ulong.MaxValue >> 32) * pixelFraction);
+
+        ulong s1 = 0x94D049BB133111EBuL;
+        ulong s2 = 0xBF58476D1CE4E5B9uL;
+
+        bool UseSample()
+        {
+            ulong bits = s2 + s1;
+            s1 = s2;
+            s1 ^= s1 << 23;
+            s1 ^= s2 ^ (s1 >> 18) ^ (s2 >> 5);
+            s2 = s1;
+            return (bits >> 32) <= threshold;
+        }
+
+        int pixelsPerRow = channel.Plane.PixelsPerRow;
+        using JxlModularChannel references = new(configuration, properties.Length - JxlMaConstants.NumNonrefProperties, channel.Width, 0, 0);
+        JxlModularState wpState = new(wpHeader, channel.Width);
+
+        treeSamples.PrepareForSamples((int)(pixelFraction * channel.Height * channel.Width) + 64);
+        bool haveMultiplePredictors = treeSamples.NumberOfPredictors != 1;
+
+        void ComputeSample(Span<int> p, int x, int y, Span<int> properties, ref int totalPixels)
+        {
+            Span<int> pred = stackalloc int[JxlPredictorFacts.ModularPredictorsAlignment].Slice(0, JxlPredictorFacts.ModularPredictors);
+
+            if (haveMultiplePredictors)
+            {
+                _ = JxlContextPrediction.PredictLearnAll(properties, channel.Width, ref p[x], pixelsPerRow, x, y, references, wpState, pred);
+            }
+            else
+            {
+                pred[(int)treeSamples.PredictorFromIndex(0)] = JxlContextPrediction.PredictLearn(properties, channel.Width, ref p[x], pixelsPerRow, x, y, treeSamples.PredictorFromIndex(0), references, wpState).Guess;
+            }
+
+            totalPixels++;
+
+            if (UseSample())
+            {
+                treeSamples.AddSample(p[x], properties, pred);
+            }
+
+            wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+        }
+
+        Span<int> pred = stackalloc int[JxlPredictorFacts.ModularPredictorsAlignment].Slice(0, JxlPredictorFacts.ModularPredictors);
+
+        for (int y = 0; y < channel.Height; y++)
+        {
+            Span<int> p = channel.GetRow(y);
+            JxlContextPrediction.PrecomputeReferences(channel, y, image, channelIndex, references);
+            JxlContextPrediction.InitializePropertiesForRow(properties, staticProperties, y);
+
+            if (y > 1 && channel.Width > 8 && references.Width == 0)
+            {
+                for (int x = 0; x < 2; x++)
+                {
+                    ComputeSample(p, x, y, properties, ref totalPixels);
+                }
+
+                for (int x = 2; x < channel.Width - 2; x++)
+                {
+                    if (haveMultiplePredictors)
+                    {
+                        _ = JxlContextPrediction.PredictLearnAllNoEdgeCases(properties, channel.Width, ref p[x], pixelsPerRow, x, y, references, wpState, pred);
+                    }
+                    else
+                    {
+                        pred[(int)treeSamples.PredictorFromIndex(0)] = JxlContextPrediction.PredictLearnNoEdgeCases(properties, channel.Width, ref p[x], pixelsPerRow, x, y, treeSamples.PredictorFromIndex(0), references, wpState).Guess;
+                    }
+
+                    totalPixels++;
+
+                    if (UseSample())
+                    {
+                        treeSamples.AddSample(p[x], properties, pred);
+                    }
+
+                    wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+                }
+
+                for (int x = channel.Width - 2; x < channel.Width; x++)
+                {
+                    ComputeSample(p, x, y, properties, ref totalPixels);
+                }
+            }
+            else
+            {
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    ComputeSample(p, x, y, properties, ref totalPixels);
+                }
+            }
+        }
+    }
+
+    public static Tree LearnTree(JxlTreeSamples treeSamples, int totalPixels, JxlModularOptions options, List<JxlModularMultiplierInfo>? info = null, StaticPropertyRange staticPropertyRange = default)
+    {
+        Tree tree = [];
+
+        for (int i = 0; i < 2; i++)
+        {
+            if (staticPropertyRange[i][1] == 0)
+            {
+                staticPropertyRange[i][1] = int.MaxValue;
+            }
+        }
+
+        if (!treeSamples.HasSamples)
+        {
+            JxlPropertyDecisionNode node = new()
+            {
+                Predictor = treeSamples.PredictorFromIndex(0),
+                Property = -1,
+                PredictorOffset = 0,
+                Multiplier = 1
+            };
+
+            tree.Add(node);
+            return tree;
+        }
+
+        float pixelFraction = treeSamples.NumberOfSamples * 1.0f / totalPixels;
+        float requiredCost = (pixelFraction * 0.9f) + 0.1f;
+
+        treeSamples.AllSamplesDone();
+
+        JxlMaEncoder.ComputeBestTree(treeSamples, options.SplittingHeuristicsNodeThreshold * requiredCost, info, staticPropertyRange, options.FastDecodeMultiplier, tree);
+        return tree;
+    }
+
+    public static void EncodeModularChannelMAANS(Configuration configuration, JxlModularImage image, int channelIndex, JxlModularHeader wpHeader, Tree globalTree, Span<JxlToken> tokens, int groupId, bool skipEncoderFastPath)
+    {
+        JxlModularChannel channel = image.Channels[channelIndex];
+
+        if (channel.Width == 0 || channel.Height == 0)
+        {
+            throw new InvalidOperationException("Width or height is 0");
+        }
+
+        InlineArray2<int> staticProperties = default;
+        staticProperties[0] = channelIndex;
+        staticProperties[1] = groupId;
+
+        bool useWp = false;
+        bool isWpOnly = false;
+        bool isGradientOnly = false;
+        int numProps = 0;
+
+        FlatTree tree = JxlModularEncoding.FilterTree(globalTree, staticProperties, ref numProps, ref useWp, ref isWpOnly, ref isGradientOnly);
+        JxlMaTreeLookup treeLookup = new(tree);
+
+        JxlTreeLut<ushort> treeLut = new(false, false);
+        int tokenp = 0; // Pointer to next token
+
+        if (isWpOnly)
+        {
+            isWpOnly = JxlModularEncoding.TreeToLookupTable(tree, treeLut);
+        }
+
+        if (isGradientOnly)
+        {
+            isGradientOnly = JxlModularEncoding.TreeToLookupTable(tree, treeLut);
+        }
+
+        int onerow = channel.Plane.PixelsPerRow;
+        int treeCount = tree.Count;
+
+        if (isWpOnly && !skipEncoderFastPath)
+        {
+            JxlModularState wpState = new(wpHeader, channel.Width);
+            Span<int> properties = [0];
+            bool unhealthy = false;
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> r = channel.GetRow(y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    int offset = 0;
+
+                    // Neighbors
+                    int left = x > 0 ? channel.GetRowPlus(y, x - 1)[0] : y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : 0;
+                    int top = y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : left;
+                    int topleft = x > 0 && y > 0 ? channel.GetRowPlus(y, x - 1 - onerow)[0] : left;
+                    int topright = x + 1 < channel.Width && y > 0 ? channel.GetRowPlus(y, x + 1 - onerow)[0] : top;
+                    int toptop = y > 1 ? channel.GetRowPlus(y, x - onerow - onerow)[0] : top;
+
+                    int guess = (int)wpState.Predict(true, x, y, channel.Width, top, left, topright, topleft, toptop, properties, offset);
+                    int pos = JxlMaConstants.PropertyRangeFast + Math.Clamp(properties[0], -JxlMaConstants.PropertyRangeFast, JxlMaConstants.PropertyRangeFast - 1);
+
+                    int ctxId = treeLut.ContextLookup[pos];
+                    unhealthy |= JxlMath.SubOverflow(r[x], guess, out int residual);
+
+                    tokens[tokenp++] = new JxlToken((JxlMaTreeContext)ctxId, JxlPackSigned.PackUnsigned(residual));
+                    wpState.UpdatePredictionErrors(r[x], x, y, channel.Width);
+                }
+            }
+
+            ThrowIfResidualUnderflow(unhealthy);
+        }
+        else if (treeCount == 1 && tree[0].Predictor == JxlPredictor.Gradient && tree[0].Multiplier == 1 && tree[0].PredictorOffset == 0 && !skipEncoderFastPath)
+        {
+            bool unhealthy = false;
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> r = channel.GetRow(y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    int left = x > 0 ? channel.GetRowPlus(y, x - 1)[0] : y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : 0;
+                    int top = y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : left;
+                    int topleft = x > 0 && y > 0 ? channel.GetRowPlus(y, x - 1 - onerow)[0] : left;
+
+                    int guess = JxlContextPrediction.ClampedGradient(top, left, topleft);
+                    unhealthy |= JxlMath.SubOverflow(r[x], guess, out int residual);
+
+                    tokens[tokenp++] = new JxlToken((JxlMaTreeContext)tree[0].ChildID, JxlPackSigned.PackUnsigned(residual));
+                }
+            }
+
+            ThrowIfResidualUnderflow(unhealthy);
+        }
+        else if (isGradientOnly && !skipEncoderFastPath)
+        {
+            bool unhealthy = false;
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> r = channel.GetRow(y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    int left = x > 0 ? channel.GetRowPlus(y, x - 1)[0] : y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : 0;
+                    int top = y > 0 ? channel.GetRowPlus(y, x - onerow)[0] : left;
+                    int topleft = x > 0 && y > 0 ? channel.GetRowPlus(y, x - 1 - onerow)[0] : left;
+
+                    int guess = JxlContextPrediction.ClampedGradient(top, left, topleft);
+                    int pos = JxlMaConstants.PropertyRangeFast + Math.Min(
+                            Math.Max(-JxlMaConstants.PropertyRangeFast, top + left - topleft),
+                            JxlMaConstants.PropertyRangeFast - 1);
+
+                    uint ctxId = treeLut.ContextLookup[pos];
+                    unhealthy |= JxlMath.SubOverflow(r[x], guess, out int residual);
+
+                    tokens[tokenp++] = new JxlToken((JxlMaTreeContext)ctxId, JxlPackSigned.PackUnsigned(residual));
+                }
+            }
+
+            ThrowIfResidualUnderflow(unhealthy);
+        }
+        else if (treeCount == 1 && tree[0].Predictor == JxlPredictor.Zero && tree[0].Multiplier == 1 && tree[0].PredictorOffset == 0 && !skipEncoderFastPath)
+        {
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> p = channel.GetRow(y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    tokens[tokenp++] = new JxlToken((JxlMaTreeContext)tree[0].ChildID, JxlPackSigned.PackUnsigned(p[x]));
+                }
+            }
+        }
+        else if (treeCount == 1 && tree[0].Predictor != JxlPredictor.Weighted && (tree[0].Multiplier & (tree[0].Multiplier - 1)) == 0 && tree[0].PredictorOffset == 0 && !skipEncoderFastPath)
+        {
+            uint mulShift = JxlMath.FloorLog2Nonzero((uint)tree[0].Multiplier);
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> r = channel.GetRow(y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    JxlPredictionResult pred = JxlContextPrediction.PredictNoTreeNoWeightedPrediction(channel.Width, ref r[x], onerow, x, y, tree[0].Predictor);
+                    int residual = r[x] - pred.Guess;
+
+                    if ((residual >> (int)mulShift) * tree[0].Multiplier != residual)
+                    {
+                        throw new InvalidOperationException("Residual coefficient is not valid");
+                    }
+
+                    tokens[tokenp++] = new JxlToken((JxlMaTreeContext)tree[0].ChildID, JxlPackSigned.PackUnsigned(residual >> (int)mulShift));
+                }
+            }
+        }
+        else if (!useWp && !skipEncoderFastPath)
+        {
+            Span<int> properties = stackalloc int[numProps];
+            using JxlModularChannel references = new(configuration, properties.Length - JxlMaConstants.NumNonrefProperties, channel.Width, 0, 0);
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> p = channel.GetRow(y);
+
+                JxlContextPrediction.PrecomputeReferences(channel, y, image, channelIndex, references);
+                JxlContextPrediction.InitializePropertiesForRow(properties, staticProperties, y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    JxlPredictionResult res = JxlContextPrediction.PredictTreeNoWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, treeLookup, references);
+                    int residual = p[x] - res.Guess;
+
+                    if ((residual % res.Multiplier) != 0)
+                    {
+                        throw new InvalidOperationException("Residual coefficient is invalid");
+                    }
+
+                    tokens[tokenp++] = new JxlToken((JxlMaTreeContext)res.Context, JxlPackSigned.PackUnsigned(residual / res.Multiplier));
+                }
+            }
+        }
+        else
+        {
+            Span<int> properties = stackalloc int[numProps];
+            using JxlModularChannel references = new(configuration, properties.Length - JxlMaConstants.NumNonrefProperties, channel.Width, 0, 0);
+
+            JxlModularState wpState = new(wpHeader, channel.Width);
+
+            for (int y = 0; y < channel.Height; y++)
+            {
+                Span<int> p = channel.GetRow(y);
+                JxlContextPrediction.PrecomputeReferences(channel, y, image, channelIndex, references);
+                JxlContextPrediction.InitializePropertiesForRow(properties, staticProperties, y);
+
+                for (int x = 0; x < channel.Width; x++)
+                {
+                    JxlPredictionResult res = JxlContextPrediction.PredictTreeWeightedPrediction(properties, channel.Width, ref p[x], onerow, x, y, treeLookup, references, wpState);
+
+                    int residual = p[x] - res.Guess;
+
+                    if ((residual % res.Multiplier) != 0)
+                    {
+                        throw new InvalidOperationException("Residual coefficient is invalid");
+                    }
+
+                    tokens[tokenp++] = new JxlToken((JxlMaTreeContext)res.Context, JxlPackSigned.PackUnsigned(residual / res.Multiplier));
+                    wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+                }
+            }
+        }
+    }
+
+    public static Tree PredefinedTree(JxlTreeKind treeKind, int totalPixels, int bitDepth, int prevProp)
+    {
+        switch (treeKind)
+        {
+            case JxlTreeKind.JpegTranscodeAcMeta:
+                return [JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero)];
+
+            case JxlTreeKind.TrivialTreeNoPredictor:
+                return [JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero)];
+
+            case JxlTreeKind.FalconAcMeta:
+                return [JxlPropertyDecisionNode.Leaf(JxlPredictor.Left)];
+
+            case JxlTreeKind.AcMeta:
+            {
+                if (totalPixels < 1024)
+                {
+                    return [JxlPropertyDecisionNode.Leaf(JxlPredictor.Left)];
+                }
+
+                Tree tree = [];
+
+                tree.Add(JxlPropertyDecisionNode.Split(0, 1, 1));
+                tree.Add(JxlPropertyDecisionNode.Split(0, 2, 3));
+                tree.Add(JxlPropertyDecisionNode.Split(0, 0, 5));
+                tree.Add(JxlPropertyDecisionNode.Split(6, 3, 21));
+                tree.Add(JxlPropertyDecisionNode.Split(2, 0, 7));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Gradient));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Gradient));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 5, 9));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 5, 15));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 11, 11));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 3, 13));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Left));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Left));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Left));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Left));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 11, 17));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 3, 19));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 3, 23));
+                tree.Add(JxlPropertyDecisionNode.Split(7, 3, 25));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+                tree.Add(JxlPropertyDecisionNode.Leaf(JxlPredictor.Zero));
+
+                return tree;
+            }
+
+            case JxlTreeKind.WpFixedDc:
+            {
+                Span<int> cutoffs = [
+                    -500, -392, -255, -191, -127, -95, -63, -47, -31, -23, -15,
+                    -11,  -7,   -4,   -3,   -1,   0,   1,   3,   5,   7,   11,
+                    15,   23,   31,   47,   63,   95,  127, 191, 255, 392, 500];
+
+                return MakeFixedTree(JxlMaConstants.WpProp, cutoffs, JxlPredictor.Weighted, totalPixels, bitDepth);
+            }
+
+            case JxlTreeKind.GradientFixedDc:
+            {
+                Span<int> cutoffs = [
+                    -500, -392, -255, -191, -127, -95, -63, -47, -31, -23, -15,
+                    -11,  -7,   -4,   -3,   -1,   0,   1,   3,   5,   7,   11,
+                    15,   23,   31,   47,   63,   95,  127, 191, 255, 392, 500];
+
+                return MakeFixedTree(prevProp > 0 ? JxlMaConstants.NumNonrefProperties + 2 : JxlMaConstants.GradientProp, cutoffs, JxlPredictor.Gradient, totalPixels, bitDepth);
+            }
+
+            case JxlTreeKind.Learn:
+            {
+                throw new InvalidOperationException($"{nameof(JxlTreeKind.Learn)} is not a predefined tree");
+            }
+        }
+
+        throw new InvalidOperationException("Invalid tree type: " + treeKind);
+    }
+
+    public static Tree LearnTree(Configuration configuration, JxlModularImage[] images, Span<JxlModularOptions> options, int start, int stop, List<JxlModularMultiplierInfo>? multiplierInfo = null)
+    {
+        multiplierInfo ??= [];
+
+        JxlTreeSamples samples = new();
+        samples.SetPredictor(options[start].Predictor, options[start].WpTreeMode);
+        samples.SetProperties(options[start].SplittingHeuristicsProperties, options[start].WpTreeMode);
+
+        int maxC = 0;
+
+        List<int> pixelSamples = [];
+        List<int> diffSamples = [];
+        List<int> groupPixelCount = [];
+        List<int> channelPixelCount = [];
+
+        for (int i = start; i < stop; i++)
+        {
+            maxC = Math.Max(images[i].Channels.Count, maxC);
+            JxlMaEncoder.CollectPixelSamples(configuration, images[i], options[i], i, groupPixelCount, channelPixelCount, pixelSamples, diffSamples);
+        }
+
+        // StaticPropRange range;
+        // range[0] = { { 0, max_c } };
+        // range[1] = { { start, stop } };
+        StaticPropertyRange range = default;
+        InlineArray2<int> currRange = default;
+        currRange[0] = 0;
+        currRange[1] = maxC;
+        range[0] = currRange;
+        currRange[0] = start;
+        currRange[1] = stop;
+        range[1] = currRange;
+
+        samples.PreQuantizeProperties(configuration, range, multiplierInfo, groupPixelCount, channelPixelCount, pixelSamples, diffSamples, options[start].MaxPropertyValues);
+
+        int totalPixels = 0;
+
+        for (int i = 0; i < images[start].Channels.Count; i++)
+        {
+            if (i >= images[start].MetaChannels &&
+                (images[start].Channels[i].Width > options[start].MaxChannelSize ||
+                 images[start].Channels[i].Height > options[start].MaxChannelSize))
+            {
+                break;
+            }
+
+            totalPixels += images[start].Channels[i].Width * images[start].Channels[i].Height;
+        }
+
+        totalPixels = Math.Max(totalPixels, 1);
+
+        JxlModularHeader wpHeader = new();
+
+        for (int i = start; i < stop; i++)
+        {
+            int numChannels = images[i].Channels.Count;
+
+            if (images[i].Width == 0 || images[i].Height == 0 || numChannels < 1)
+            {
+                continue;
+            }
+
+            if (images[i].IsInvalid)
+            {
+                throw new InvalidOperationException("Invalid image");
+            }
+
+            if (options[i].TreeKind != JxlTreeKind.Learn)
+            {
+                throw new InvalidOperationException("Tree type must be Learn");
+            }
+
+            JxlBundle.Init(wpHeader);
+
+            if (JxlContextPrediction.IsWeightedPredictor(options[i].Predictor))
+            {
+                JxlContextPrediction.SetPredictorMode(options[i].WpMode, wpHeader);
+            }
+
+            for (int c = 0; c < numChannels; c++)
+            {
+                if (c >= images[i].MetaChannels &&
+                    (images[i].Channels[c].Width > options[i].MaxChannelSize ||
+                     images[i].Channels[c].Height > options[i].MaxChannelSize))
+                {
+                    break;
+                }
+
+                if (images[i].Channels[c].Width == 0 || images[i].Channels[c].Height == 0)
+                {
+                    continue;  // skip empty channels
+                }
+
+                GatherTreeData(configuration, images[i], c, i, wpHeader, options[i], samples, totalPixels);
+            }
+        }
+
+        Tree tree = LearnTree(samples, totalPixels, options[start], multiplierInfo, range);
+
+        return tree;
+    }
+
+    public static void ModularCompress(JxlModularImage image, JxlModularOptions options, int groupId, Tree tree, JxlGroupHeader header, List<JxlToken> tokens, ref int width)
+    {
+        int numChannels = image.Channels.Count;
+
+        if (image.Width == 0 || image.Height == 0 || numChannels < 1)
+        {
+            return;
+        }
+
+        if (image.IsInvalid)
+        {
+            throw new InvalidOperationException("Invalid image");
+        }
+
+        JxlBundle.Init(header);
+
+        if (JxlContextPrediction.IsWeightedPredictor(options.Predictor))
+        {
+            JxlContextPrediction.SetPredictorMode(options.WpMode, header.WeightedHeader);
+        }
+
+        header.Transforms = image.Transforms;
+        header.UseGlobalTree = true;
+
+        int imageWidth = 0;
+        int totalTokens = 0;
+
+        for (int i = 0; i < numChannels; i++)
+        {
+            if (i >= image.MetaChannels &&
+                (image.Channels[i].Width > options.MaxChannelSize ||
+                 image.Channels[i].Height > options.MaxChannelSize))
+            {
+                break;
+            }
+
+            if (image.Channels[i].Width > imageWidth)
+            {
+                imageWidth = image.Channels[i].Width;
+            }
+
+            totalTokens += image.Channels[i].Width * image.Channels[i].Height;
+        }
+
+        if (options.ZeroTokens)
+        {
+            tokens.Grow(default, tokens.Count + totalTokens);
+        }
+        else
+        {
+            int pos = tokens.Count;
+            tokens.Grow(default, pos + totalTokens);
+
+            int tokenp = pos;
+
+            for (int i = 0; i < numChannels; i++)
+            {
+                if (i >= image.MetaChannels &&
+                    (image.Channels[i].Width > options.MaxChannelSize ||
+                     image.Channels[i].Height > options.MaxChannelSize))
+                {
+                    break;
+                }
+
+                if (image.Channels[i].Width == 0 || image.Channels[i].Height == 0)
+                {
+                    continue;
+                }
+
+                EncodeModularChannelMAANS(configuration, image, i, header.WeightedHeader, tree, CollectionsMarshal.AsSpan(tokens)[tokenp..], groupId, options.SkipEncoderFastPath);
+            }
+
+            if (tokenp != tokens.Count)
+            {
+                throw new InvalidOperationException("Tokens were not written");
+            }
+        }
+
+        width = imageWidth;
+    }
+
+    public static void ModularGenericCompress(Configuration configuration, JxlModularImage image, JxlModularOptions options, JxlBitWriter writer, JxlAuxiliaryOutput auxOut, JxlLayerType layerType, int groupId)
+    {
+        int numChannels = image.Channels.Count;
+
+        if (image.Width == 0 || image.Height == 0 || numChannels < 1)
+        {
+            return;
+        }
+
+        if (image.IsInvalid)
+        {
+            throw new InvalidOperationException("Invalid image");
+        }
+
+        JxlModularOptions modularOptions = options.DeepClone(); // Make a copy to modify it
+
+        if (modularOptions.Predictor == JxlPredictor.Undefined)
+        {
+            modularOptions.Predictor = JxlPredictor.Gradient;
+        }
+
+        long bits = writer.BitsWritten;
+
+        JxlGroupHeader groupHeader = new();
+        JxlBundle.Init(groupHeader);
+
+        if (JxlContextPrediction.IsWeightedPredictor(modularOptions.Predictor))
+        {
+            JxlContextPrediction.SetPredictorMode(modularOptions.WpMode, groupHeader.WeightedHeader);
+        }
+
+        groupHeader.Transforms = image.Transforms;
+
+        JxlBundle.Write(groupHeader, writer, layerType, auxOut);
+
+        Tree tree = [];
+
+        if (modularOptions.TreeKind == JxlTreeKind.Learn)
+        {
+            tree = LearnTree(configuration, image, options, 0, 1);
+        }
+        else
+        {
+            // It's a predefined tree.
+            int totalPixels = 0;
+
+            for (int i = 0; i < numChannels; i++)
+            {
+                if (i >= image.MetaChannels &&
+                    (image.Channels[i].Width > options.MaxChannelSize
+                    || image.Channels[i].Height > options.MaxChannelSize))
+                {
+                    break;
+                }
+
+                totalPixels += image.Channels[i].Width * image.Channels[i].Height;
+            }
+
+            totalPixels = Math.Max(totalPixels, 1);
+
+            tree = PredefinedTree(options.TreeKind, totalPixels, image.BitDepth, options.MaxProperties);
+        }
+
+        Tree decodedTree = [];
+        List<List<JxlToken>> treeTokens = [[]];
+
+        JxlMaEncoder.TokenizeTree(tree, treeTokens[0], decodedTree);
+
+        if (tree.Count != decodedTree.Count)
+        {
+            throw new InvalidOperationException("Tree lengths mismatch");
+        }
+
+        tree = decodedTree;
+
+        // TODO: missing types here
+        JxlEntropyEncodingData code = default;
+        int cost = BuildAndEncodeHistograms(configuration, options.HistogramParameters, JxlMaConstants.NumTreeContexts, treeTokens, code, writer, JxlLayerType.ModularTree, auxOut);
+        WriteTokens(treeTokens[0], code, 0, writer, JxlLayerType.ModularTree, auxOut);
+
+        int imageWidth = 0;
+        List<List<JxlToken>> tokens = [[]];
+        ModularCompress(image, options, groupId, tree, groupHeader, tokens[0], ref imageWidth);
+
+        code = default;
+        JxlHistogramParameters histoParameters = options.HistogramParameters;
+        histoParameters.ImageWidths.Add(imageWidth);
+        _ = BuildAndEncodeHistograms(configuration, histoParameters, (tree.Count + 1) / 2, tokens, ref code, writer, layerType, auxOut);
+
+        WriteTokens(tokens[0], code, 0, writer, layerType, auxOut);
+        bits = writer.BitsWritten - bits;
+    }
+
+    private static void ThrowIfResidualUnderflow(bool isUnderflow)
+    {
+        if (isUnderflow)
+        {
+            throw new InvalidOperationException("Residual coefficient underflow");
+        }
+    }
+
+    private struct NodeInfo
+    {
+        public NodeInfo(int begin, int end, int pos)
+        {
+            this.Begin = begin;
+            this.End = end;
+            this.Pos = pos;
+        }
+
+        public int Begin { get; set; }
+
+        public int End { get; set; }
+
+        public int Pos { get; set; }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlPropertyDecisionNode.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlPropertyDecisionNode.cs
new file mode 100644
index 0000000000..b0fda7efd9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlPropertyDecisionNode.cs
@@ -0,0 +1,46 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal struct JxlPropertyDecisionNode
+{
+    public int SplitValue;
+    public int Property;
+    public int LeftChild;
+    public int RightChild;
+    public JxlPredictor Predictor;
+    public long PredictorOffset;
+    public int Multiplier;
+
+    public JxlPropertyDecisionNode(int property, int splitValue, int leftChild, int rightChild, JxlPredictor predictor, long predictorOffset, int multiplier)
+    {
+        this.SplitValue = splitValue;
+        this.Property = property;
+        this.LeftChild = leftChild;
+        this.RightChild = rightChild;
+        this.Predictor = predictor;
+        this.PredictorOffset = predictorOffset;
+        this.Multiplier = multiplier;
+    }
+
+    public JxlPropertyDecisionNode()
+        : this(0, -1, 0, 0, JxlPredictor.Zero, 0, 1)
+    {
+    }
+
+    public static JxlPropertyDecisionNode Leaf(JxlPredictor predictor, long offset = 0, int multiplier = 1)
+        => new(-1, 0, 0, 0, predictor, offset, multiplier);
+
+    public static JxlPropertyDecisionNode Split(int p, int splitValue, int leftChild, int rightChild = -1)
+    {
+        if (rightChild == -1)
+        {
+            rightChild = leftChild + 1;
+        }
+
+        return new(p, splitValue, leftChild, rightChild, JxlPredictor.Zero, 0, 1);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlResidualToken.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlResidualToken.cs
new file mode 100644
index 0000000000..8a8b387200
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlResidualToken.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal struct JxlResidualToken
+{
+    public int Token;
+    public int NumberOfBits;
+
+    public JxlResidualToken(int token, int numberOfBits)
+    {
+        this.Token = token;
+        this.NumberOfBits = numberOfBits;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlTreeLut.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlTreeLut.cs
new file mode 100644
index 0000000000..5b33e6ad7d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlTreeLut.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal sealed class JxlTreeLut<T>(bool hasOffsets, bool hasMultipliers)
+{
+    public T[] ContextLookup { get; } = new T[2 * JxlMaConstants.PropertyRangeFast];
+
+    public byte[] Offsets { get; } = new byte[hasOffsets ? (2 * JxlMaConstants.PropertyRangeFast) : 0];
+
+    public byte[] Multipliers { get; } = new byte[hasMultipliers ? (2 * JxlMaConstants.PropertyRangeFast) : 0];
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlTreeSamples.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlTreeSamples.cs
new file mode 100644
index 0000000000..1d25122266
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/JxlTreeSamples.cs
@@ -0,0 +1,884 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics.Tensors;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using StaticPropertyRange = System.Runtime.CompilerServices.InlineArray2<System.Runtime.CompilerServices.InlineArray2<int>>;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+/// <summary>
+/// Contains all the necessary data needed to build a tree.
+/// </summary>
+internal sealed class JxlTreeSamples
+{
+    /// <summary>
+    /// This deduplication table entry marks an unused entry.
+    /// </summary>
+    private const int DeduplicationEntryUnused = -1;
+
+    private const int PropertyRange = 511;
+
+    /// <summary>
+    /// Residual information: token and number of extra bits per predictor.
+    /// </summary>
+    private List<List<JxlResidualToken>> residuals = [];
+
+    /// <summary>
+    /// Number of occurrences of each sample.
+    /// </summary>
+    private readonly List<int> sampleCounts = [];
+
+    /// <summary>
+    /// Quantized static property values.
+    /// </summary>
+    private InlineArray2<List<int>> staticProperties;
+
+    /// <summary>
+    /// Property values, quantized to at most 256 distinct values.
+    /// </summary>
+    private readonly List<List<byte>> properties = [];
+
+    /// <summary>
+    /// Decompactification info for <see cref="properties"/>.
+    /// </summary>
+    private readonly List<List<int>> compactProperties = [];
+
+    /// <summary>
+    /// List of properties to use.
+    /// </summary>
+    private List<int> propertiesToUse = [];
+
+    /// <summary>
+    /// List of predictors to use.
+    /// </summary>
+    private List<JxlPredictor> predictors = [];
+
+    /// <summary>
+    /// Mapping property value -> quantized property value.
+    /// </summary>
+    private InlineArray2<List<int>> staticPropertyMapping;
+
+    private readonly List<List<int>> propertyMapping = [];
+
+    /// <summary>
+    /// Table for deduplication.
+    /// </summary>
+    private List<int> deduplicationTable = [];
+
+    /// <summary>
+    /// Gets a value indicating whether there are any residual samples.
+    /// </summary>
+    public bool HasSamples => this.residuals.Count > 0 && this.residuals[0].Count > 0;
+
+    /// <summary>
+    /// Gets the total number of distinct samples.
+    /// </summary>
+    public int NumberOfDistinctSamples => this.sampleCounts.Count;
+
+    /// <summary>
+    /// Gets the total number of samples.
+    /// </summary>
+    public int NumberOfSamples { get; private set; }
+
+    /// <summary>
+    /// Gets the number of quantized static property values.
+    /// </summary>
+    public int NumberOfStaticProperties { get; private set; }
+
+    /// <summary>
+    /// Gets the total number of predictors.
+    /// </summary>
+    public int NumberOfPredictors => this.predictors.Count;
+
+    /// <summary>
+    /// Gets the total number of properties.
+    /// </summary>
+    public int NumberOfProperties => this.propertiesToUse.Count;
+
+    /// <summary>
+    /// Returns a List of residual tokens for the specified kind of prediction.
+    /// </summary>
+    /// <param name="prediction">The type of prediction.</param>
+    /// <returns>Residual tokens corresponding to the prediction specified by the parameter <paramref name="prediction"/>.</returns>
+    public List<JxlResidualToken> GetResidualTokensForPrediction(int prediction) => this.residuals[prediction];
+
+    /// <summary>
+    /// Returns a reference to the residual token.
+    /// </summary>
+    /// <param name="pred">Kind of prediction.</param>
+    /// <param name="i">Index of the residual token within that prediction.</param>
+    /// <returns>The residual token for prediction <paramref name="pred"/> indexed <paramref name="i"/>.</returns>
+    public ref JxlResidualToken GetResidualToken(int pred, int i) => ref CollectionsMarshal.AsSpan(this.residuals[pred])[i];
+
+    /// <summary>
+    /// Returns a token of the residual for prediction <paramref name="prediction"/> index <paramref name="index"/>.
+    /// </summary>
+    /// <param name="prediction">The kind of prediction.</param>
+    /// <param name="index">Index of the residual token within that prediction.</param>
+    /// <returns>For residual token whose prediction is <paramref name="prediction"/> and index is <paramref name="index"/>, returns its token coefficient.</returns>
+    public int GetToken(int prediction, int index) => this.residuals[prediction][index].Token;
+
+    /// <summary>
+    /// Returns the number of occurrences for sample <paramref name="i"/>.
+    /// </summary>
+    /// <param name="i">The index of the sample.</param>
+    /// <returns>Number of times <paramref name="i"/> appears.</returns>
+    public int GetCount(int i) => this.sampleCounts[i];
+
+    /// <summary>
+    /// Finds the index of the predictor <paramref name="predictor"/>.
+    /// </summary>
+    /// <param name="predictor">The predictor to find the index for.</param>
+    /// <returns>Index of the predictor in the predictors storage.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the predictor can't be found.</exception>
+    public int FindPredictorIndex(JxlPredictor predictor)
+    {
+        ReadOnlySpan<JxlPredictor> span = CollectionsMarshal.AsSpan(this.predictors);
+
+        int index = span.IndexOf(predictor);
+
+        if (index < 0)
+        {
+            // Should not happen.
+            throw new InvalidOperationException("Cannot find the index of the predictor");
+        }
+
+        return index;
+    }
+
+    /// <summary>
+    /// Finds the index of the property <paramref name="property"/>.
+    /// </summary>
+    /// <param name="property">The property to find the index for.</param>
+    /// <returns>Index of the property in the properties storage.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the property isn't valid.</exception>
+    public int FindPropertyIndex(int property)
+    {
+        ReadOnlySpan<int> span = CollectionsMarshal.AsSpan(this.propertiesToUse);
+
+        int index = span.IndexOf(property);
+
+        if (index != this.propertiesToUse[^1])
+        {
+            // Should not happen.
+            throw new InvalidOperationException("Invalid property");
+        }
+
+        return index;
+    }
+
+    /// <summary>
+    /// Returns the number of properties for a <paramref name="propertyIndex"/>.
+    /// </summary>
+    /// <param name="propertyIndex">Index of the property.</param>
+    /// <returns>Number of property values for property with index <paramref name="propertyIndex"/>.</returns>
+    public int CountPropertyValues(int propertyIndex) => this.compactProperties[propertyIndex].Count + 1;
+
+    /// <summary>
+    /// Returns the value of a property.
+    /// </summary>
+    /// <param name="useStaticProperty">Prefer a static property?</param>
+    /// <param name="propertyIndex">The index of the properties table.</param>
+    /// <param name="i">The index of the property.</param>
+    /// <returns>
+    /// Property for index <paramref name="i" /> within table <paramref name="propertyIndex"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int GetProperty(bool useStaticProperty, int propertyIndex, int i)
+    {
+        if (useStaticProperty)
+        {
+            return this.staticProperties[propertyIndex][i];
+        }
+        else
+        {
+            return this.properties[propertyIndex][i];
+        }
+    }
+
+    /// <summary>
+    /// Returns the dequantized property.
+    /// </summary>
+    /// <param name="propertyIndex">Index of the target property.</param>
+    /// <param name="quant">Property quantizer.</param>
+    /// <returns>The dequantized property.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the quant is out of range.</exception>
+    public int UnquantizeProperty(int propertyIndex, int quant)
+    {
+        List<int> compactProperties = this.compactProperties[propertyIndex];
+
+        if (quant >= compactProperties.Count)
+        {
+            throw new InvalidOperationException("Quant is out of range");
+        }
+
+        return compactProperties[quant];
+    }
+
+    /// <summary>
+    /// Returns a predictor for index <paramref name="index"/>.
+    /// </summary>
+    /// <param name="index">The index of the predictor.</param>
+    /// <returns>Predictor at index <paramref name="index"/>.</returns>
+    public JxlPredictor PredictorFromIndex(int index)
+    {
+        DebugGuard.MustBeLessThan(index, this.predictors.Count, nameof(index));
+
+        return this.predictors[index];
+    }
+
+    /// <summary>
+    /// Returns a property for index <paramref name="index"/>.
+    /// </summary>
+    /// <param name="index">The index of the property.</param>
+    /// <returns>Property at index <paramref name="index"/>.</returns>
+    public int PropertyFromIndex(int index)
+    {
+        DebugGuard.MustBeLessThan(index, this.propertiesToUse.Count, nameof(index));
+
+        return this.propertiesToUse[index];
+    }
+
+    /// <summary>
+    /// Invoked after processing samples completed.
+    /// </summary>
+    public void AllSamplesDone() => this.deduplicationTable = [];
+
+    /// <summary>
+    /// Returns the quantized property value of <paramref name="v"/>.
+    /// </summary>
+    /// <param name="property">Index of the property.</param>
+    /// <param name="v">Value to quantize.</param>
+    /// <returns>Quantized value.</returns>
+    public int QuantizeProperty(int property, int v)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(property, this.NumberOfStaticProperties, nameof(property));
+
+        v = Math.Clamp(v, -PropertyRange, PropertyRange) + PropertyRange;
+
+        return this.propertyMapping[property][v];
+    }
+
+    /// <summary>
+    /// Returns the quantized static property value of <paramref name="v"/>.
+    /// </summary>
+    /// <param name="property">Index of the static property.</param>
+    /// <param name="v">Value to quantize.</param>
+    /// <returns>Quantized value.</returns>
+    public int QuantizeStaticProperty(int property, int v)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(property, this.NumberOfStaticProperties, nameof(property));
+
+        v = Math.Clamp(v, -PropertyRange, PropertyRange) + PropertyRange;
+
+        return this.staticPropertyMapping[property][v];
+    }
+
+    public void SetPredictor(JxlPredictor predictor, JxlTreeMode wpTreeMode)
+    {
+        if (wpTreeMode == JxlTreeMode.WpOnly)
+        {
+            this.predictors = [JxlPredictor.Weighted];
+
+            // equivalent of residuals.resize(1)
+            if (this.residuals.Count > 1)
+            {
+                this.residuals = [this.residuals[0]];
+            }
+            else if (this.residuals.Count < 1)
+            {
+                this.residuals = [[]];
+            }
+
+            return;
+        }
+
+        if (wpTreeMode == JxlTreeMode.NoWp && predictor == JxlPredictor.Weighted)
+        {
+            throw new InvalidOperationException("Invalid predictor settings");
+        }
+
+        if (predictor == JxlPredictor.Variable)
+        {
+            for (int i = 0; i < JxlPredictorFacts.ModularPredictors; i++)
+            {
+                this.predictors.Add((JxlPredictor)i);
+            }
+
+            Span<JxlPredictor> predictorsSpan = CollectionsMarshal.AsSpan(this.predictors);
+            RuntimeUtility.Swap(ref predictorsSpan[0], ref predictorsSpan[(int)JxlPredictor.Weighted]);
+            RuntimeUtility.Swap(ref predictorsSpan[1], ref predictorsSpan[(int)JxlPredictor.Gradient]);
+        }
+        else if (predictor == JxlPredictor.Best)
+        {
+            this.predictors = [JxlPredictor.Weighted, JxlPredictor.Gradient];
+        }
+        else
+        {
+            this.predictors = [predictor];
+        }
+
+        if (wpTreeMode == JxlTreeMode.NoWp)
+        {
+            // delete all weighted predictors
+            _ = this.predictors.RemoveAll(p => p == JxlPredictor.Weighted);
+        }
+
+        this.residuals.Grow([], this.predictors.Count);
+    }
+
+    public void SetProperties(List<int> properties, JxlTreeMode wpTreeMode)
+    {
+        this.propertiesToUse = properties;
+
+        if (wpTreeMode == JxlTreeMode.WpOnly)
+        {
+            this.propertiesToUse = [JxlMaConstants.WpProp];
+        }
+        else if (wpTreeMode == JxlTreeMode.GradientOnly)
+        {
+            this.propertiesToUse = [JxlMaConstants.GradientProp];
+        }
+        else if (wpTreeMode == JxlTreeMode.NoWp)
+        {
+            // delete all weighted properties, tree mode
+            // says "no weighted predictors"
+            _ = this.propertiesToUse.RemoveAll(x => x == JxlMaConstants.WpProp);
+        }
+
+        if (this.propertiesToUse.Count == 0)
+        {
+            // could happen in default tree mode or when properties parameter
+            // is empty
+            throw new InvalidOperationException("Invalid property set configuration");
+        }
+
+        this.NumberOfStaticProperties = 0;
+
+        for (int i = 0; i < this.propertiesToUse.Count; ++i)
+        {
+            int prop = this.propertiesToUse[i];
+
+            if (prop < JxlPredictorFacts.StaticProperties)
+            {
+                if (i != prop)
+                {
+                    throw new InvalidOperationException("Index is not equal to the property");
+                }
+
+                this.NumberOfStaticProperties++;
+            }
+        }
+
+        this.properties.Resize(this.propertiesToUse.Count - this.NumberOfStaticProperties);
+    }
+
+    public void InitializeTable(int logSize)
+    {
+        int size = 1 << logSize;
+
+        if (this.deduplicationTable.Count == size)
+        {
+            return;
+        }
+
+        this.deduplicationTable.Resize(size, DeduplicationEntryUnused);
+
+        for (int i = 0; i < this.NumberOfDistinctSamples; i++)
+        {
+            if (this.sampleCounts[i] != ushort.MaxValue)
+            {
+                this.AddToTable(i);
+            }
+        }
+    }
+
+    public void AddToTableAndMerge(int a)
+    {
+        int pos1 = Hash1(a);
+        int pos2 = Hash2(a);
+
+        if (this.deduplicationTable[pos1] != DeduplicationEntryUnused && this.IsSameSample(a, this.deduplicationTable[pos1]))
+        {
+            if (this.sampleCounts[a] != 1)
+            {
+                throw new InvalidOperationException("Sample count must be 1");
+            }
+
+            this.sampleCounts[this.deduplicationTable[pos1]]++;
+
+            if (this.sampleCounts[this.deduplicationTable[pos1]] == ushort.MaxValue)
+            {
+                this.deduplicationTable[pos1] = DeduplicationEntryUnused;
+            }
+
+            return;
+        }
+
+        if (this.deduplicationTable[pos2] != DeduplicationEntryUnused && this.IsSameSample(a, this.deduplicationTable[pos2]))
+        {
+            if (this.sampleCounts[a] != 1)
+            {
+                throw new InvalidOperationException("Sample count must be 1");
+            }
+
+            this.sampleCounts[this.deduplicationTable[pos2]]++;
+
+            if (this.sampleCounts[this.deduplicationTable[pos2]] == ushort.MaxValue)
+            {
+                this.deduplicationTable[pos2] = DeduplicationEntryUnused;
+            }
+
+            return;
+        }
+
+        this.AddToTable(a);
+    }
+
+    public void AddToTable(int a)
+    {
+        int pos1 = Hash1(a);
+        int pos2 = Hash2(a);
+
+        if (this.deduplicationTable[pos1] == DeduplicationEntryUnused)
+        {
+            this.deduplicationTable[pos1] = a;
+        }
+        else if (this.deduplicationTable[pos2] == DeduplicationEntryUnused)
+        {
+            this.deduplicationTable[pos2] = a;
+        }
+    }
+
+    public void PrepareForSamples(int extraNumSamples)
+    {
+        foreach (List<JxlResidualToken> residual in this.residuals)
+        {
+            residual.Grow(default, residual.Count + extraNumSamples);
+        }
+
+        for (int i = 0; i < this.NumberOfStaticProperties; i++)
+        {
+            this.staticProperties[i].Grow(0, this.staticProperties[i].Count + extraNumSamples);
+        }
+
+        foreach (List<byte> prop in this.properties)
+        {
+            prop.Grow((byte)0, prop.Count + extraNumSamples);
+        }
+
+        int totalNumSamples = extraNumSamples + this.sampleCounts.Count;
+        int nextSize = JxlMath.CeilLog2Nonzero(totalNumSamples * 3 / 2);
+
+        this.InitializeTable(nextSize);
+    }
+
+    public int Hash1(int a)
+    {
+        const ulong constant = 0x1e35a7bd;
+
+        ulong h = constant;
+
+        foreach (List<JxlResidualToken> r in this.residuals)
+        {
+            h = (h * constant) + (ulong)r[a].Token;
+            h = (h * constant) + (ulong)r[a].NumberOfBits;
+        }
+
+        for (int i = 0; i < this.NumberOfStaticProperties; i++)
+        {
+            h = (h * constant) + (ulong)this.staticProperties[i][a];
+        }
+
+        foreach (List<byte> property in this.properties)
+        {
+            h = (h * constant) + property[a];
+        }
+
+        return (int)((h >> 16) & (ulong)(this.deduplicationTable.Count - 1));
+    }
+
+    public int Hash2(int a)
+    {
+        const ulong constant = 0x1e35a7bd1e35a7bd;
+
+        ulong h = constant;
+
+        for (int i = 0; i < this.NumberOfStaticProperties; i++)
+        {
+            h = (h * constant) ^ (ulong)this.staticProperties[i][a];
+        }
+
+        foreach (List<byte> property in this.properties)
+        {
+            h = (h * constant) ^ property[a];
+        }
+
+        foreach (List<JxlResidualToken> r in this.residuals)
+        {
+            h = (h * constant) ^ (ulong)r[a].Token;
+            h = (h * constant) ^ (ulong)r[a].NumberOfBits;
+        }
+
+        return (int)((h >> 16) & (ulong)(this.deduplicationTable.Count - 1));
+    }
+
+    public bool IsSameSample(int a, int b)
+    {
+        foreach (List<JxlResidualToken> r in this.residuals)
+        {
+            if (r[a].Token != r[b].Token)
+            {
+                return false;
+            }
+
+            if (r[a].NumberOfBits != r[b].NumberOfBits)
+            {
+                return false;
+            }
+        }
+
+        for (int i = 0; i < this.NumberOfStaticProperties; ++i)
+        {
+            if (this.staticProperties[i][a] != this.staticProperties[i][b])
+            {
+                return false;
+            }
+        }
+
+        foreach (List<byte> p in this.properties)
+        {
+            if (p[a] != p[b])
+            {
+                return false;
+            }
+        }
+
+        return false;
+    }
+
+    public void AddSample(int pixel, Span<int> properties, Span<int> predictions)
+    {
+        for (int i = 0; i < this.predictors.Count; i++)
+        {
+            int v = pixel - predictions[(int)this.predictors[i]];
+            new JxlAnsHybridUIntConfiguration(4, 1, 2).Encode(JxlPackSigned.PackUnsigned(v), out uint tok, out uint nbits, out uint bits);
+
+            if (tok >= 256)
+            {
+                throw new InvalidOperationException("Token is too large");
+            }
+
+            if (nbits >= 256)
+            {
+                throw new InvalidOperationException("Number of bits is too large");
+            }
+
+            JxlResidualToken token = new((int)tok, (int)nbits);
+            this.residuals[i].Add(token);
+        }
+
+        for (int i = 0; i < this.NumberOfStaticProperties; ++i)
+        {
+            this.staticProperties[i].Add(this.QuantizeStaticProperty(i, properties[i]));
+        }
+
+        for (int i = this.NumberOfStaticProperties; i < this.propertiesToUse.Count; i++)
+        {
+            this.properties[i - this.NumberOfStaticProperties].Add(unchecked((byte)this.QuantizeProperty(i, properties[this.propertiesToUse[i]])));
+        }
+
+        this.sampleCounts.Add(1);
+        this.NumberOfSamples++;
+
+        this.AddToTableAndMerge(this.sampleCounts.Count - 1);
+
+        foreach (List<JxlResidualToken> residual in this.residuals)
+        {
+            // remove last item from List<T>
+            residual.RemoveAt(residual.Count - 1);
+        }
+
+        for (int i = 0; i < this.NumberOfStaticProperties; i++)
+        {
+            // ditto
+            this.staticProperties[i].RemoveAt(this.staticProperties[i].Count - 1);
+        }
+
+        foreach (List<byte> property in this.properties)
+        {
+            // ditto
+            property.RemoveAt(property.Count - 1);
+        }
+
+        // ditto
+        this.sampleCounts.RemoveAt(this.sampleCounts.Count - 1);
+    }
+
+    public void Swap(int a, int b)
+    {
+        if (a == b)
+        {
+            return;
+        }
+
+        foreach (List<JxlResidualToken> r in this.residuals)
+        {
+            // Get a Span for this List so we can get a ref to its items
+            // for use in RuntimeUtility.Swap (tuple-swap is slightly slower)
+            Span<JxlResidualToken> sp = CollectionsMarshal.AsSpan(r);
+
+            RuntimeUtility.Swap(ref sp[a], ref sp[b]);
+        }
+
+        for (int i = 0; i < this.NumberOfStaticProperties; i++)
+        {
+            // Ditto
+            Span<int> sp = CollectionsMarshal.AsSpan(this.staticProperties[i]);
+
+            RuntimeUtility.Swap(ref sp[a], ref sp[b]);
+        }
+
+        foreach (List<byte> p in this.properties)
+        {
+            // Ditto
+            Span<byte> sp = CollectionsMarshal.AsSpan(p);
+
+            RuntimeUtility.Swap(ref sp[a], ref sp[b]);
+        }
+
+        // Ditto
+        Span<int> sampleCounts = CollectionsMarshal.AsSpan(this.sampleCounts);
+
+        RuntimeUtility.Swap(ref sampleCounts[a], ref sampleCounts[b]);
+    }
+
+    public void PreQuantizeProperties(
+        Configuration configuration,
+        StaticPropertyRange range,
+        List<JxlModularMultiplierInfo> multiplierInfo,
+        List<int> groupPixelCount,
+        List<int> channelPixelCount,
+        List<int> pixelSamples,
+        List<int> diffSamples,
+        int maxPropertyValues)
+    {
+        List<int> groupMultiplierThresholds = [];
+        List<int> channelMultiplierThresholds = [];
+
+        foreach (JxlModularMultiplierInfo v in multiplierInfo)
+        {
+            if (v.Range[0][0] != range[0][0])
+            {
+                channelMultiplierThresholds.Add(v.Range[0][0] - 1);
+            }
+
+            if (v.Range[0][1] != range[0][1])
+            {
+                channelMultiplierThresholds.Add(v.Range[0][1] - 1);
+            }
+
+            if (v.Range[1][0] != range[1][0])
+            {
+                groupMultiplierThresholds.Add(v.Range[1][0] - 1);
+            }
+
+            if (v.Range[1][1] != range[1][1])
+            {
+                groupMultiplierThresholds.Add(v.Range[1][1] - 1);
+            }
+        }
+
+        channelMultiplierThresholds.Sort();
+        channelMultiplierThresholds.Resize(0, channelMultiplierThresholds.Distinct().Count());
+        groupMultiplierThresholds.Sort();
+        groupMultiplierThresholds.Resize(0, groupMultiplierThresholds.Distinct().Count());
+
+        this.compactProperties.Resize([], this.propertiesToUse.Count);
+
+        List<int> QuantizeChannel()
+        {
+            if (channelMultiplierThresholds.Count > 0)
+            {
+                return channelMultiplierThresholds;
+            }
+
+            return JxlMaEncoder.QuantizeHistogram(
+                CollectionsMarshal.AsSpan(groupPixelCount),
+                maxPropertyValues);
+        }
+
+        List<int> QuantizeGroupId()
+        {
+            if (groupMultiplierThresholds.Count > 0)
+            {
+                return groupMultiplierThresholds;
+            }
+
+            return JxlMaEncoder.QuantizeHistogram(
+                CollectionsMarshal.AsSpan(groupPixelCount),
+                maxPropertyValues);
+        }
+
+        List<int> QuantizeCoordinate()
+        {
+            List<int> quantized = new(maxPropertyValues - 1);
+
+            for (int i = 0; i + 1 < maxPropertyValues; i++)
+            {
+                quantized[i] = ((i + 1) * 256 / maxPropertyValues) - 1;
+            }
+
+            return quantized;
+        }
+
+        List<int> absPixelThresholds = [];
+        List<int> pixelThresholds = [];
+
+        List<int> QuantizePixelProperty()
+        {
+            if (pixelThresholds.Count == 0)
+            {
+                pixelThresholds = JxlMaEncoder.QuantizeSamples(
+                    CollectionsMarshal.AsSpan(pixelSamples),
+                    maxPropertyValues);
+            }
+
+            return pixelThresholds;
+        }
+
+        List<int> QuantizeAbsolutePixelProperty()
+        {
+            if (absPixelThresholds.Count == 0)
+            {
+                _ = QuantizePixelProperty(); // compute the non-abs thresholds
+
+                Span<int> pixelSamplesSpan = CollectionsMarshal.AsSpan(pixelSamples);
+                TensorPrimitives.Abs(pixelSamplesSpan, pixelSamplesSpan);
+
+                absPixelThresholds = JxlMaEncoder.QuantizeSamples(pixelSamplesSpan, maxPropertyValues);
+            }
+
+            return absPixelThresholds;
+        }
+
+        List<int> absoluteDiffThresholds = [];
+        List<int> diffThresholds = [];
+
+        List<int> QuantizeDiffProperty()
+        {
+            if (diffThresholds.Count == 0)
+            {
+                diffThresholds = JxlMaEncoder.QuantizeSamples(
+                    CollectionsMarshal.AsSpan(diffSamples),
+                    maxPropertyValues);
+            }
+
+            return diffThresholds;
+        }
+
+        List<int> QuantizeAbsoluteDiffProperty()
+        {
+            if (absoluteDiffThresholds.Count == 0)
+            {
+                _ = QuantizeDiffProperty();
+
+                Span<int> diffSamplesSpan = CollectionsMarshal.AsSpan(diffSamples);
+                TensorPrimitives.Abs(diffSamplesSpan, diffSamplesSpan);
+
+                absoluteDiffThresholds = JxlMaEncoder.QuantizeSamples(diffSamplesSpan, maxPropertyValues);
+            }
+
+            return absoluteDiffThresholds;
+        }
+
+        List<int> QuantizeWeightedPrediction()
+        {
+            // TODO: static ReadOnlySpan<int> ... => [...]?
+            if (maxPropertyValues < 32)
+            {
+                return [-127, -63, -31, -15, -7, -3, -1, 0, 1,
+                        3, 7, 15, 31, 63, 127];
+            }
+            else if (maxPropertyValues < 64)
+            {
+                return [-255, -191, -127, -95, -63, -47, -31, -23,
+                        -15,  -11,  -7,   -5,  -3,  -1,  0,   1,
+                        3,    5,    7,    11,  15,  23,  31,  47,
+                        63,   95,   127,  191, 255];
+            }
+            else
+            {
+                return [-255, -223, -191, -159, -127, -111, -95, -79, -63, -55, -47,
+                        -39,  -31,  -27,  -23,  -19,  -15,  -13, -11, -9,  -7,  -6,
+                        -5,   -4,   -3,   -2,   -1,   0,    1,   2,   3,   4,   5,
+                        6,    7,    9,    11,   13,   15,   19,  23,  27,  31,  39,
+                        47,   55,   63,   79,   95,   111,  127, 159, 191, 223, 255];
+            }
+        }
+
+        this.propertyMapping.Resize(0, this.propertiesToUse.Count - this.NumberOfStaticProperties);
+
+        for (int i = 0; i < this.propertiesToUse.Count; i++)
+        {
+            if (this.propertiesToUse[i] == 0)
+            {
+                this.compactProperties[i] = QuantizeChannel();
+            }
+            else if (this.propertiesToUse[i] == 1)
+            {
+                this.compactProperties[i] = QuantizeGroupId();
+            }
+            else if (this.propertiesToUse[i] is 2 or 3)
+            {
+                this.compactProperties[i] = QuantizeCoordinate();
+            }
+            else if (this.propertiesToUse[i] == 6 || this.propertiesToUse[i] == 7 ||
+                     this.propertiesToUse[i] == 8 ||
+                     (this.propertiesToUse[i] >= JxlMaConstants.NumNonrefProperties && (this.propertiesToUse[i] - JxlMaConstants.NumNonrefProperties) % 4 == 1))
+            {
+                this.compactProperties[i] = QuantizePixelProperty();
+            }
+            else if (this.propertiesToUse[i] == 4 || this.propertiesToUse[i] == 5 ||
+                     (this.propertiesToUse[i] >= JxlMaConstants.NumNonrefProperties && (this.propertiesToUse[i] - JxlMaConstants.NumNonrefProperties) % 4 == 0))
+            {
+                this.compactProperties[i] = QuantizeAbsolutePixelProperty();
+            }
+            else if (this.propertiesToUse[i] >= JxlMaConstants.NumNonrefProperties && (this.propertiesToUse[i] - JxlMaConstants.NumNonrefProperties) % 4 == 2)
+            {
+                this.compactProperties[i] = QuantizeAbsoluteDiffProperty();
+            }
+            else if (this.propertiesToUse[i] == JxlMaConstants.WpProp)
+            {
+                this.compactProperties[i] = QuantizeWeightedPrediction();
+            }
+            else
+            {
+                this.compactProperties[i] = QuantizeDiffProperty();
+            }
+
+            if (i < this.NumberOfStaticProperties)
+            {
+                JxlMaEncoder.QuantMap(
+                    CollectionsMarshal.AsSpan(this.compactProperties[i]),
+                    CollectionsMarshal.AsSpan(this.staticPropertyMapping[i]),
+                    (PropertyRange * 2) + 1,
+                    PropertyRange);
+            }
+            else
+            {
+                JxlMaEncoder.QuantMap(
+                    CollectionsMarshal.AsSpan(this.compactProperties[i]),
+                    CollectionsMarshal.AsSpan(this.propertyMapping[i - this.NumberOfStaticProperties]),
+                    (PropertyRange * 2) + 1,
+                    PropertyRange);
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ListUtils.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ListUtils.cs
new file mode 100644
index 0000000000..c203fc66a0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Encoding/ListUtils.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding;
+
+internal static class ListUtils
+{
+    public static void Grow<T>(this List<T> list, T item, int desiredSize)
+    {
+        while (list.Count < desiredSize)
+        {
+            list.Add(item);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularChannel.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularChannel.cs
new file mode 100644
index 0000000000..4d227853bb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularChannel.cs
@@ -0,0 +1,83 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular;
+
+/// <summary>
+/// A wrapper over <see cref="JxlImageI"/> for modular operations.
+/// </summary>
+internal sealed class JxlModularChannel : IDisposable
+{
+    public JxlModularChannel(Configuration configuration, int width, int height, int horizShift, int vertShift)
+    {
+        this.HorizontalShift = horizShift;
+        this.VerticalShift = vertShift;
+        this.Width = width;
+        this.Height = height;
+        this.Plane = new JxlImageI(configuration, width, height);
+    }
+
+    /// <summary>
+    /// Gets or sets the image width.
+    /// </summary>
+    public int Width { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image height.
+    /// </summary>
+    public int Height { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image horizontal shift.
+    /// </summary>
+    /// <remarks>
+    /// width ~= width &gt;&gt; HorizontalShift
+    /// </remarks>
+    public int HorizontalShift { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image vertical shift.
+    /// </summary>
+    /// <remarks>
+    /// height ~= height &gt;&gt; VerticalShift
+    /// </remarks>
+    public int VerticalShift { get; set; }
+
+    /// <summary>
+    /// Gets or sets the index of the component.
+    /// </summary>
+    public int Component { get; set; } = -1;
+
+    /// <summary>
+    /// Gets or sets the backing plane buffer.
+    /// </summary>
+    public JxlImageI Plane { get; set; }
+
+    public void Shrink(Configuration configuration)
+    {
+        if (this.Plane.XSize == this.Width && this.Plane.YSize == this.Height)
+        {
+            return;
+        }
+
+        this.Plane.Dispose();
+        this.Plane = new JxlImageI(configuration, this.Width, this.Height);
+    }
+
+    public void Shrink(Configuration configuration, int newWidth, int newHeight)
+    {
+        this.Width = newWidth;
+        this.Height = newHeight;
+        this.Shrink(configuration);
+    }
+
+    public Span<int> GetRow(int y) => this.Plane.GetRow(y);
+
+    public Span<int> GetRowMinus(int y, int minus) => this.Plane.GetRowMinus(y, minus);
+
+    public Span<int> GetRowPlus(int y, int plus) => this.Plane.GetRowPlus(y, plus);
+
+    public void Dispose() => this.Plane.Dispose();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularImage.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularImage.cs
new file mode 100644
index 0000000000..9b3ce7e02f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularImage.cs
@@ -0,0 +1,90 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular;
+
+internal sealed class JxlModularImage : IDisposable
+{
+    public JxlModularImage(int width, int height, int bitDepth)
+    {
+        this.Width = width;
+        this.Height = height;
+        this.BitDepth = bitDepth;
+        this.MetaChannels = 0;
+        this.IsInvalid = false;
+    }
+
+    public JxlModularImage()
+        : this(0, 0, 8)
+    {
+    }
+
+    public List<JxlModularChannel> Channels { get; set; } = [];
+
+    public List<JxlTransform> Transforms { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets the total number of metachannels in this image.
+    /// </summary>
+    public int MetaChannels { get; set; }
+
+    /// <summary>
+    /// Gets or sets the bit depth used in this image.
+    /// </summary>
+    public int BitDepth { get; set; }
+
+    /// <summary>
+    /// Gets or sets modular image width.
+    /// </summary>
+    public int Width { get; set; }
+
+    /// <summary>
+    /// Gets or sets modular image height.
+    /// </summary>
+    public int Height { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the modular image has an error.
+    /// </summary>
+    public bool IsInvalid { get; set; }
+
+    public bool IsEmpty => this.Channels.Any(x => x.Width > 0 && x.Height > 0);
+
+    public void UndoTransforms(Configuration configuration, JxlModularHeader wpHeader)
+    {
+        while (this.Transforms.Count > 0)
+        {
+            JxlTransform transform = this.Transforms.First();
+            transform.Inverse(configuration, this, wpHeader);
+            this.Transforms.RemoveAt(0);
+        }
+    }
+
+    public static JxlModularImage Create(Configuration configuration, int width, int height, int bitDepth, int channels)
+    {
+        JxlModularImage result = new(width, height, bitDepth);
+
+        for (int i = 0; i < channels; i++)
+        {
+            JxlModularChannel c = new(configuration, width, height, 0, 0);
+
+            result.Channels.Add(c);
+            result.Channels[^1].Component = i;
+        }
+
+        return result;
+    }
+
+    public void Dispose()
+    {
+        foreach (JxlModularChannel channel in this.Channels)
+        {
+            channel.Dispose();
+        }
+
+        this.Channels = [];
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularOptions.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularOptions.cs
new file mode 100644
index 0000000000..5346b6a3d0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/JxlModularOptions.cs
@@ -0,0 +1,64 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular;
+
+internal sealed class JxlModularOptions
+{
+    /// <summary>
+    /// Gets or sets value indicating when to stop decoding/encoding
+    /// when reaching a non-meta channel that has a dimension bigger
+    /// than this value.
+    /// </summary>
+    public int MaxChannelSize { get; set; } = 0xFFFFFF;
+
+    /// <summary>
+    /// Gets or sets value used during decoding for validation
+    /// of transforms (squeezing) scheme.
+    /// </summary>
+    public int GroupDimension { get; set; } = 0x1FFFFFFF;
+
+    /// <summary>
+    /// Gets or sets fraction of pixels to look at to learn a MA tree.
+    /// </summary>
+    public float NumberOfRepeats { get; set; } = 0.5f;
+
+    /// <summary>
+    /// Gets or sets maximum number of previous channel properties
+    /// to use in the MA trees.
+    /// </summary>
+    public int MaxProperties { get; set; }
+
+    /// <summary>
+    /// Gets or sets properties that default to channel, group, weighted,
+    /// gradient residual, W-NW, NW-N, N-NE, N-NN.
+    /// </summary>
+    public List<int> SplittingHeuristicsProperties { get; set; } = [0, 1, 15, 9, 10, 11, 12, 13];
+
+    public float SplittingHeuristicsNodeThreshold { get; set; } = 96f;
+
+    public int MaxPropertyValues { get; set; } = 32;
+
+    public JxlPredictor Predictor { get; set; } = JxlPredictor.Undefined;
+
+    public int WpMode { get; set; }
+
+    public float FastDecodeMultiplier { get; set; } = 1.01f;
+
+    public JxlTreeMode WpTreeMode { get; set; } = JxlTreeMode.Default;
+
+    public bool SkipEncoderFastPath { get; set; }
+
+    public JxlTreeKind TreeKind { get; set; } = JxlTreeKind.Learn;
+
+    public JxlHistogramParameters HistogramParameters { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to ignore the image and just
+    /// pretend all tokens are zeroes.
+    /// </summary>
+    public bool ZeroTokens { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/README.md b/src/ImageSharp/Formats/Jxl/Processing/Modular/README.md
new file mode 100644
index 0000000000..3339605a40
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/README.md
@@ -0,0 +1,15 @@
+# Implementation of Modular coding mode for JPEG XL
+JPEG XL files typically consist of two distinct coding modes: VarDCT
+and Modular. VarDCT is lossy and transform-based, while Modular uses
+the predictive coding approach and can achieve lossless or near-lossless
+compression.
+
+This folder has the implementation of the Modular encoder/decoder.
+
+### Folder structure
+In the Transforms folder, there are implementations for the Reversible
+Color Transform (RCT), Squeeze Transform and Palette, both inverse
+and forward.
+
+In the Encoding folder there are predictors using neighbors, averages,
+weighted prediction and tree-based prediction.
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlPalette.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlPalette.cs
new file mode 100644
index 0000000000..4e306c1f40
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlPalette.cs
@@ -0,0 +1,1379 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+/// <summary>
+/// Palette/indexed decoder and encoder.
+/// </summary>
+internal static class JxlPalette
+{
+    /// <summary>
+    /// Represents maximum number of colors in a palette.
+    /// </summary>
+    private const int MaxPaletteLookupTableSize = 1 << 16;
+
+    /// <summary>
+    /// Represents number of channels for RGB. This is 3 because RGB
+    /// has three channels: R (Red), G (Green), B (Blue).
+    /// </summary>
+    private const int RgbChannels = 3;
+
+    /// <summary>
+    /// 5x5x5 color cube for the larger cube.
+    /// </summary>
+    private const int LargeCube = 5;
+
+    /// <summary>
+    /// Smaller interleaved color cube to fill the holes of the larger cube.
+    /// </summary>
+    private const int SmallCube = 4;
+
+    /// <summary>
+    /// Number of bits required to represent a small cube.
+    /// </summary>
+    private const int SmallCubeBits = 2; // 2 bits gives us 0..3 inclusive, so it's perfect to represent a small cube
+
+    /// <summary>
+    /// Cube of SmallCube
+    /// </summary>
+    private const int LargeCubeOffset = SmallCube * SmallCube * SmallCube;
+
+    private const int ImplicitPaletteSize = LargeCubeOffset + (LargeCube * LargeCube * LargeCube);
+
+    private const bool EncodeToHighQualityImplicitPalette = true;
+
+    /// <summary>
+    /// Minimum index required to use the implicit palette.
+    /// </summary>
+    private const int MinimumImplicitPaletteIndex = -((2 * 72) - 1);
+
+    /// <summary>
+    /// Backing array used to construct data for the <see cref="DefaultOffsets"/> matrix.
+    /// </summary>
+    private static readonly int[,] DefaultOffsetsData =
+    {
+        { 1, 2 },
+        { 0, 3 },
+        { 0, 4 },
+        { 1, 1 },
+        { 1, 3 },
+        { 2, 2 },
+        { 1, 0 },
+        { 1, 4 },
+        { 2, 1 },
+        { 2, 3 },
+        { 2, 0 },
+        { 2, 4 }
+    };
+
+    /// <summary>
+    /// Used by the palette encoder.
+    /// </summary>
+    private static readonly DenseMatrix<int> DefaultOffsets = new(DefaultOffsetsData);
+
+    /// <summary>
+    /// Static delta palette used by <see cref="GetPaletteValue(Span{int}, int, int, int, int)" />.
+    /// </summary>
+    private static readonly int[][] DeltaPalette =
+    [
+        [0, 0, 0], [4, 4, 4], [11, 0, 0],
+        [0, 0, -13], [0, -12, 0], [-10, -10, -10],
+        [-18, -18, -18], [-27, -27, -27], [-18, -18, 0],
+        [0, 0, -32], [-32, 0, 0], [-37, -37, -37],
+        [0, -32, -32], [24, 24, 45], [50, 50, 50],
+        [-45, -24, -24], [-24, -45, -45], [0, -24, -24],
+        [-34, -34, 0], [-24, 0, -24], [-45, -45, -24],
+        [64, 64, 64], [-32, 0, -32], [0, -32, 0],
+        [-32, 0, 32], [-24, -45, -24], [45, 24, 45],
+        [24, -24, -45], [-45, -24, 24], [80, 80, 80],
+        [64, 0, 0], [0, 0, -64], [0, -64, -64],
+        [-24, -24, 45], [96, 96, 96], [64, 64, 0],
+        [45, -24, -24], [34, -34, 0], [112, 112, 112],
+        [24, -45, -45], [45, 45, -24], [0, -32, 32],
+        [24, -24, 45], [0, 96, 96], [45, -24, 24],
+        [24, -45, -24], [-24, -45, 24], [0, -64, 0],
+        [96, 0, 0], [128, 128, 128], [64, 0, 64],
+        [144, 144, 144], [96, 96, 0], [-36, -36, 36],
+        [45, -24, -45], [45, -45, -24], [0, 0, -96],
+        [0, 128, 128], [0, 96, 0], [45, 24, -45],
+        [-128, 0, 0], [24, -45, 24], [-45, 24, -45],
+        [64, 0, -64], [64, -64, -64], [96, 0, 96],
+        [45, -45, 24], [24, 45, -45], [64, 64, -64],
+        [128, 128, 0], [0, 0, -128], [-24, 45, -45]
+    ];
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Scale(int denominator, int value, int bitDepth)
+    {
+        DebugGuard.IsTrue(denominator == 4, "Denominator is defined as 4");
+
+        return (value * ((1 << bitDepth) - 1)) >> 2;
+    }
+
+    public static int GetPaletteValue(Span<int> palette, int index, int c, int oneRow, int bitDepth)
+    {
+        if (index < 0)
+        {
+            if (c >= RgbChannels)
+            {
+                return 0;
+            }
+
+            index = -(index + 1);
+            index %= 1 + (2 * (DeltaPalette.Length - 1));
+
+            // JPEG XL reference uses:
+            //    static constexpr int kMultiplier[] = {-1, 1};
+            //    kMultiplier[index & 1]
+            //
+            // we use:
+            //    ((index & 1) != 0 ? 1 : -1)
+            //
+            // The latter avoids multiplication and can make use
+            // of CPU registers instead of memory access (if the JIT allows it).
+            int result = DeltaPalette[(index + 1) >> 1][c] * ((index & 1) != 0 ? 1 : -1);
+
+            if (bitDepth > 8)
+            {
+                result *= 1 << (bitDepth - 8);
+            }
+
+            return result;
+        }
+        else if (palette.Length <= index && index < palette.Length + LargeCubeOffset)
+        {
+            if (c >= RgbChannels)
+            {
+                return 0;
+            }
+
+            index -= palette.Length;
+            index >>= c * SmallCubeBits;
+            return Scale(SmallCube, index % SmallCube, bitDepth) + (1 << Math.Max(0, bitDepth - 3));
+        }
+        else if (palette.Length + LargeCubeOffset <= index)
+        {
+            if (c >= RgbChannels)
+            {
+                return 0;
+            }
+
+            switch (c)
+            {
+                case 1:
+                    index /= LargeCube;
+                    break;
+
+                case 2:
+                    index /= LargeCube * LargeCube;
+                    break;
+
+                default:
+                    break;
+            }
+
+            return Scale(LargeCube - 1, index % LargeCube, bitDepth);
+        }
+
+        return palette[(c * oneRow) + index];
+    }
+
+    public static void MetaPalette(Configuration configuration, JxlModularImage input, int beginC, int endC, int numberOfColors, int numberOfDeltas)
+    {
+        JxlTransform.CheckEqualChannels(input, beginC, endC);
+        int nb = endC - beginC + 1;
+        if (beginC >= input.MetaChannels)
+        {
+            // Palette was done on normal channels
+            input.MetaChannels++;
+        }
+        else
+        {
+            // Palette was done on metachannels
+            if (endC >= input.MetaChannels)
+            {
+                throw new InvalidOperationException("End channel offset is out of bounds");
+            }
+
+            input.MetaChannels += 2 - nb;
+        }
+
+        input.Channels.RemoveRange(beginC + 1, endC - beginC);
+        JxlModularChannel ch = new(configuration, numberOfColors + numberOfDeltas, nb, -1, -1);
+        input.Channels.Insert(0, ch);
+    }
+
+    /// <summary>
+    /// Decodes palette/indexed images.
+    /// </summary>
+    /// <param name="configuration">Configuration for parallelism.</param>
+    /// <param name="input">Input &amp; out images.</param>
+    /// <param name="beginC">Offset of output channel.</param>
+    /// <param name="nbColors">Number of colors.</param>
+    /// <param name="nbDeltas">Number of deltas.</param>
+    /// <param name="predictor">Kind of predictor mode to use.</param>
+    /// <param name="weightedHeader">For weighted prediction.</param>
+    /// <exception cref="InvalidOperationException">Thrown when the input for prediction is invalid.</exception>
+    /// <exception cref="NotImplementedException">Thrown when there are too many channels.</exception>
+    public static void InversePalette(Configuration configuration, JxlModularImage input, int beginC, int nbColors, int nbDeltas, JxlPredictor predictor, JxlModularHeader weightedHeader)
+    {
+        if (input.MetaChannels < 1)
+        {
+            throw new InvalidOperationException("A palette transform was invoked without a palette");
+        }
+
+        int nb = input.Channels[0].Height;
+        int c0 = beginC + 1;
+
+        if (c0 >= input.Channels.Count)
+        {
+            throw new InvalidOperationException("Channel is out of range");
+        }
+
+        JxlModularChannel channel = input.Channels[c0];
+        int w = channel.Width;
+        int h = channel.Height;
+
+        if (nb < 1)
+        {
+            throw new InvalidOperationException("Transforms are corrupted");
+        }
+
+        for (int i = 1; i < nb; i++)
+        {
+            JxlModularChannel newChannel = new(configuration, w, h, channel.HorizontalShift, channel.VerticalShift);
+            input.Channels.Insert(c0 + 1, newChannel);
+        }
+
+        JxlModularChannel palette = input.Channels[0];
+
+        int oneRow = palette.Plane.PixelsPerRow;
+        int oneRowImage = channel.Plane.PixelsPerRow;
+        int bitDepth = Math.Min(input.BitDepth, 24);
+
+        if (w == 0)
+        {
+            // Channel is empty. Don't do anything.
+        }
+        else if (nbDeltas == 0 && predictor == JxlPredictor.Zero)
+        {
+            if (nb == 1)
+            {
+                _ = Parallel.For(0, h, configuration.GetParallelOptions(), y =>
+                {
+                    Span<int> p = channel.GetRow(y);
+                    Span<int> paletteData = palette.GetRow(0);
+
+                    for (int x = 0; x < w; x++)
+                    {
+                        int index = Math.Clamp(p[x], 0, palette.Width - 1);
+
+                        p[x] = GetPaletteValue(paletteData, index, 0, oneRow, bitDepth);
+                    }
+                });
+            }
+            else if (nb == 2)
+            {
+                _ = Parallel.For(0, h, configuration.GetParallelOptions(), y =>
+                {
+                    Span<int> paletteData = palette.GetRow(0);
+                    Span<int> p0 = channel.GetRow(y);
+                    Span<int> p1 = input.Channels[c0 + 1].GetRow(y);
+
+                    for (int x = 0; x < w; x++)
+                    {
+                        int index0 = Math.Clamp(p0[x], 0, palette.Width - 1);
+                        int index1 = Math.Clamp(p1[x], 0, palette.Width - 1);
+
+                        p0[x] = GetPaletteValue(paletteData, index0, 0, oneRow, bitDepth);
+                        p1[x] = GetPaletteValue(paletteData, index1, 0, oneRow, bitDepth);
+                    }
+                });
+            }
+            else if (nb == 3)
+            {
+                _ = Parallel.For(0, h, configuration.GetParallelOptions(), y =>
+                {
+                    Span<int> paletteData = palette.GetRow(0);
+                    Span<int> p0 = channel.GetRow(y);
+                    Span<int> p1 = input.Channels[c0 + 1].GetRow(y);
+                    Span<int> p2 = input.Channels[c0 + 2].GetRow(y);
+
+                    for (int x = 0; x < w; x++)
+                    {
+                        int index0 = Math.Clamp(p0[x], 0, palette.Width - 1);
+                        int index1 = Math.Clamp(p1[x], 0, palette.Width - 1);
+                        int index2 = Math.Clamp(p2[x], 0, palette.Width - 1);
+
+                        p0[x] = GetPaletteValue(paletteData, index0, 0, oneRow, bitDepth);
+                        p1[x] = GetPaletteValue(paletteData, index1, 0, oneRow, bitDepth);
+                        p2[x] = GetPaletteValue(paletteData, index2, 0, oneRow, bitDepth);
+                    }
+                });
+            }
+            else if (nb == 4)
+            {
+                _ = Parallel.For(0, h, configuration.GetParallelOptions(), y =>
+                {
+                    Span<int> paletteData = palette.GetRow(0);
+                    Span<int> p0 = channel.GetRow(y);
+                    Span<int> p1 = input.Channels[c0 + 1].GetRow(y);
+                    Span<int> p2 = input.Channels[c0 + 2].GetRow(y);
+                    Span<int> p3 = input.Channels[c0 + 3].GetRow(y);
+
+                    for (int x = 0; x < w; x++)
+                    {
+                        int index0 = Math.Clamp(p0[x], 0, palette.Width - 1);
+                        int index1 = Math.Clamp(p1[x], 0, palette.Width - 1);
+                        int index2 = Math.Clamp(p2[x], 0, palette.Width - 1);
+                        int index3 = Math.Clamp(p3[x], 0, palette.Width - 1);
+
+                        p0[x] = GetPaletteValue(paletteData, index0, 0, oneRow, bitDepth);
+                        p1[x] = GetPaletteValue(paletteData, index1, 0, oneRow, bitDepth);
+                        p2[x] = GetPaletteValue(paletteData, index2, 0, oneRow, bitDepth);
+                        p3[x] = GetPaletteValue(paletteData, index3, 0, oneRow, bitDepth);
+                    }
+                });
+            }
+            else if (nb == 5)
+            {
+                _ = Parallel.For(0, h, configuration.GetParallelOptions(), y =>
+                {
+                    Span<int> paletteData = palette.GetRow(0);
+                    Span<int> p0 = channel.GetRow(y);
+                    Span<int> p1 = input.Channels[c0 + 1].GetRow(y);
+                    Span<int> p2 = input.Channels[c0 + 2].GetRow(y);
+                    Span<int> p3 = input.Channels[c0 + 3].GetRow(y);
+                    Span<int> p4 = input.Channels[c0 + 4].GetRow(y);
+
+                    for (int x = 0; x < w; x++)
+                    {
+                        int index0 = Math.Clamp(p0[x], 0, palette.Width - 1);
+                        int index1 = Math.Clamp(p1[x], 0, palette.Width - 1);
+                        int index2 = Math.Clamp(p2[x], 0, palette.Width - 1);
+                        int index3 = Math.Clamp(p3[x], 0, palette.Width - 1);
+                        int index4 = Math.Clamp(p4[x], 0, palette.Width - 1);
+
+                        p0[x] = GetPaletteValue(paletteData, index0, 0, oneRow, bitDepth);
+                        p1[x] = GetPaletteValue(paletteData, index1, 0, oneRow, bitDepth);
+                        p2[x] = GetPaletteValue(paletteData, index2, 0, oneRow, bitDepth);
+                        p3[x] = GetPaletteValue(paletteData, index3, 0, oneRow, bitDepth);
+                        p4[x] = GetPaletteValue(paletteData, index4, 0, oneRow, bitDepth);
+                    }
+                });
+            }
+            else
+            {
+                throw new NotImplementedException($"Too many channels for palette compressed images: {nb}");
+            }
+        }
+        else
+        {
+            JxlImageI plane = input.Channels[c0].Plane;
+            JxlImageI indices = new(configuration, plane.XSize, plane.YSize);
+            input.Channels[c0].Plane = indices;
+
+            if (predictor == JxlPredictor.Weighted)
+            {
+                _ = Parallel.For(0, nb, configuration.GetParallelOptions(), c =>
+                {
+                    JxlModularChannel channel = input.Channels[c0 + c];
+                    JxlModularState wpState = new(weightedHeader, channel.Width);
+                    Span<int> paletteData = palette.GetRow(0);
+
+                    for (int y = 0; y < channel.Height; y++)
+                    {
+                        Span<int> p = channel.GetRow(y);
+                        Span<int> idx = indices.GetRow(y);
+
+                        for (int x = 0; x < channel.Width; x++)
+                        {
+                            int index = idx[x];
+                            int value = 0;
+                            int paletteEntry = GetPaletteValue(paletteData, index, c, oneRow, bitDepth);
+                            JxlPredictionResult pred = JxlContextPrediction.PredictTreeNoWeightedPrediction(channel.Width, p[x..], oneRowImage, x, y, predictor, wpState);
+
+                            if (index < nbDeltas)
+                            {
+                                value = pred.Guess + paletteEntry;
+                            }
+                            else
+                            {
+                                value = paletteEntry;
+                            }
+
+                            p[x] = value;
+                            wpState.UpdatePredictionErrors(p[x], x, y, channel.Width);
+                        }
+                    }
+                });
+            }
+            else
+            {
+                _ = Parallel.For(0, nb, configuration.GetParallelOptions(), c =>
+                {
+                    JxlModularChannel channel = input.Channels[c0 + c];
+                    Span<int> paletteData = palette.GetRow(0);
+
+                    for (int y = 0; y < channel.Height; y++)
+                    {
+                        Span<int> p = channel.GetRow(y);
+                        Span<int> idx = indices.GetRow(y);
+
+                        for (int x = 0; x < channel.Width; x++)
+                        {
+                            int index = idx[x];
+                            int value = 0;
+                            int paletteEntry = GetPaletteValue(paletteData, index, c, oneRow, bitDepth);
+
+                            if (index < nbDeltas)
+                            {
+                                JxlPredictionResult pred = JxlContextPrediction.PredictNoTreeNoWeightedPrediction(channel.Width, p[x..], oneRowImage, x, y, predictor);
+                                value = pred.Guess + paletteEntry;
+                            }
+                            else
+                            {
+                                value = paletteEntry;
+                            }
+
+                            p[x] = value;
+                        }
+                    }
+                });
+            }
+        }
+
+        if (c0 >= input.MetaChannels)
+        {
+            input.MetaChannels--;
+        }
+        else
+        {
+            if (input.MetaChannels >= 2 - nb)
+            {
+                throw new InvalidOperationException("Too many meta channels");
+            }
+
+            input.MetaChannels -= 2 - nb;
+
+            if (beginC + nb - 1 < input.MetaChannels)
+            {
+                throw new InvalidOperationException("Too many meta channels");
+            }
+
+            input.Channels.RemoveAt(0);
+        }
+    }
+
+    private static float ColorDistance(Span<float> a, Span<int> b)
+    {
+        InlineArray3<int> array = default;
+        array[0] = b[0];
+        array[1] = b[1];
+        array[2] = b[2];
+        return ColorDistance(a, array);
+    }
+
+    private static float ColorDistance(Span<float> a, InlineArray3<int> b)
+    {
+        if (a.Length != 3)
+        {
+            throw new InvalidOperationException("Length mismatch");
+        }
+
+        float distance = 0;
+        float ave3 = 0;
+
+        if (a.Length >= 3)
+        {
+            ave3 = ((a[0] + b[0]) + (a[1] + b[1]) + (a[2] + b[2])) * (1.21f / 3.0f);
+        }
+
+        float sumA = 0;
+        float sumB = 0;
+
+        for (int c = 0; c < a.Length; c++)
+        {
+            float diff = a[c] - b[c];
+            float weight = c == 0 ? 3f : c == 1 ? 5f : 2f;
+
+            if (c < 3 && (a[c] + b[c] >= ave3))
+            {
+                weight += c == 2 ? 1.12f : 1.15f;
+
+                if (c == 2 && ((a[2] + b[2]) < 1.22f * ave3))
+                {
+                    weight -= 0.5f;
+                }
+            }
+
+            distance += diff * diff * weight * weight;
+            int sumWeight = c == 0 ? 3 : c == 1 ? 5 : 1;
+
+            sumA += a[c] * sumWeight;
+            sumB += b[c] * sumWeight;
+        }
+
+        distance *= 4;
+        float sumDiff = sumA - sumB;
+        distance += sumDiff * sumDiff;
+        return distance;
+    }
+
+    private static int QuantizeColorToImplicitPaletteIndex(Span<int> color, int paletteSize, int bitDepth, bool highQuality)
+    {
+        int index = 1;
+        int quant = (1 << bitDepth) - 1;
+        int half = bitDepth > 1 ? (1 << (bitDepth - 1)) : 0;
+
+        if (highQuality)
+        {
+            int multiplier = 1;
+
+            for (int i = 0; i < color.Length; i++)
+            {
+                int value = color[i];
+                int quantized = (((LargeCube - 1) * value) + half) / quant;
+                index += quantized * multiplier;
+                multiplier *= LargeCube;
+            }
+
+            return index + (paletteSize * LargeCubeOffset);
+        }
+        else
+        {
+            int multiplier = 1;
+            int bdMinus3 = 1 << Math.Max(0, bitDepth - 3);
+
+            for (int i = 0; i < color.Length; i++)
+            {
+                int value = color[i];
+                value -= bdMinus3;
+                value = Math.Max(0, value);
+
+                int quantized = (((LargeCube - 1) * value) + half) / quant;
+                quantized = Math.Min(quantized, SmallCube - 1); // cannot be > SmallCube - 1
+
+                index += quantized * multiplier;
+                multiplier *= SmallCube;
+            }
+
+            return index + paletteSize;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int RoundInteger(int value, int div)
+    {
+        if (value < 0)
+        {
+            return (-value + (div / 2)) / div;
+        }
+        else
+        {
+            return (value + (div / 2)) / div;
+        }
+    }
+
+    /// <summary>
+    /// Encodes an image into palette/indexed coding mode.
+    /// </summary>
+    /// <param name="configuration">Configuration for memory allocation/management.</param>
+    /// <param name="input">Input image.</param>
+    /// <param name="beginC">Offset of starting channel.</param>
+    /// <param name="endC">Offset of final channel.</param>
+    /// <param name="numberOfColors">Number of colors.</param>
+    /// <param name="numberOfDeltas">Number of deltas.</param>
+    /// <param name="ordered">Should the output palette produced by this method be sorted?</param>
+    /// <param name="lossy">Should the palette be quantized in lossy mode? (May discard subtle pixel values)</param>
+    /// <param name="predictor">The kind of predictor that was used.</param>
+    /// <param name="wpHeader">Header for weighted prediction.</param>
+    public static void ForwardPalette(
+        Configuration configuration,
+        JxlModularImage input,
+        int beginC,
+        int endC,
+        ref int numberOfColors,
+        ref int numberOfDeltas,
+        bool ordered,
+        bool lossy,
+        ref JxlPredictor predictor,
+        JxlModularHeader wpHeader)
+    {
+        PaletteIterationData paletteIterationData = new();
+        int originalNumberOfColors = numberOfColors;
+        int originalNumberOfDeltas = numberOfDeltas;
+
+        if (lossy && input.BitDepth >= 8)
+        {
+            ForwardPaletteIteration(
+                configuration,
+                input,
+                beginC,
+                endC,
+                ref originalNumberOfColors,
+                ref originalNumberOfDeltas,
+                ordered,
+                lossy,
+                ref predictor,
+                wpHeader,
+                paletteIterationData);
+        }
+
+        paletteIterationData.IsFinalRun = false;
+        ForwardPaletteIteration(
+            configuration,
+            input,
+            beginC,
+            endC,
+            ref numberOfColors,
+            ref numberOfDeltas,
+            ordered,
+            lossy,
+            ref predictor,
+            wpHeader,
+            paletteIterationData);
+    }
+
+    private static void ForwardPaletteIteration(
+        Configuration configuration,
+        JxlModularImage input,
+        int beginC,
+        int endC,
+        ref int numberOfColors,
+        ref int numberOfDeltas,
+        bool ordered,
+        bool lossy,
+        ref JxlPredictor predictor,
+        JxlModularHeader wpHeader,
+        PaletteIterationData paletteIterationData)
+    {
+        JxlTransform.CheckEqualChannels(input, beginC, endC);
+        DebugGuard.MustBeGreaterThanOrEqualTo(beginC, input.MetaChannels, nameof(beginC));
+        int nb = endC - beginC + 1; // inclusive number of channels
+
+        // TODO: if this assert below triggers, increase nb to 6 and update
+        // the stack allocation for the 'tmp' variable below
+        // so the size is big enough.
+        DebugGuard.MustBeLessThanOrEqualTo(nb, 5, nameof(nb));
+
+        JxlModularChannel beginCChannel = input.Channels[beginC];
+        int w = beginCChannel.Width;
+        int h = beginCChannel.Height;
+
+        if (input.BitDepth >= 32)
+        {
+            throw new InvalidOperationException("Bit depth is too large");
+        }
+
+        if (!lossy && numberOfColors < 2)
+        {
+            throw new InvalidOperationException("Lossless palette transform needs at least 3 channels");
+        }
+
+        int idx = 0;
+
+        if (!lossy && nb == 1)
+        {
+            if (numberOfColors == 0)
+            {
+                throw new InvalidOperationException("No colors");
+            }
+
+            JxlTransform.ComputeMinMax(beginCChannel, out int minValue, out int maxValue);
+            int lookupTableSize = maxValue - minValue + 1;
+
+            if (lookupTableSize < MaxPaletteLookupTableSize)
+            {
+                HashSet<int> chPalette = [];
+
+                for (int y = 0; y < h; y++)
+                {
+                    Span<int> p = beginCChannel.GetRow(y);
+
+                    for (int x = 0; x < w; x++)
+                    {
+                        bool newColor = chPalette.Add(p[x]);
+
+                        if (newColor)
+                        {
+                            idx++;
+
+                            if (idx > numberOfColors)
+                            {
+                                throw new InvalidOperationException("Index out of bounds");
+                            }
+                        }
+                    }
+                }
+
+                // Don't dispose. The channel is stored into the input.
+                JxlModularChannel modularChannel = new(configuration, idx, 1, -1, -1);
+
+                numberOfColors = idx;
+                idx = 0;
+
+                Span<int> ppalette = modularChannel.GetRow(0);
+
+                foreach (int p in chPalette)
+                {
+                    ppalette[idx++] = p;
+                }
+
+                for (int y = 0; y < h; y++)
+                {
+                    Span<int> p = beginCChannel.GetRow(y);
+
+                    for (int x = 0; x < w; x++)
+                    {
+                        for (idx = 0; p[x] != ppalette[idx] && idx < numberOfColors; idx++)
+                        {
+                            // nop; this is to find the value of idx
+                        }
+
+                        p[x] = idx;
+                    }
+                }
+
+                predictor = JxlPredictor.Zero;
+                input.MetaChannels++;
+                input.Channels.Insert(0, modularChannel);
+
+                return;
+            }
+
+            Span<int> lookup = stackalloc int[lookupTableSize];
+            idx = 0;
+
+            for (int y = 0; y < h; y++)
+            {
+                Span<int> p = beginCChannel.GetRow(y);
+                for (int x = 0; x < w; x++)
+                {
+                    if (lookup[p[x] - minValue] == 0)
+                    {
+                        lookup[p[x] - minValue] = 1;
+                        idx++;
+
+                        if (idx > numberOfColors)
+                        {
+                            throw new InvalidOperationException("Index out of bounds");
+                        }
+                    }
+                }
+            }
+
+            // Don't dispose. The channel is stored into the input.
+            JxlModularChannel channel = new(configuration, idx, 1, -1, -1);
+            numberOfColors = idx;
+            idx = 0;
+            Span<int> pPalette = channel.GetRow(0);
+
+            for (int i = 0; i < lookupTableSize; i++)
+            {
+                if (lookup[i] != 0)
+                {
+                    pPalette[idx] = i + minValue;
+                    lookup[i] = idx;
+                    idx++;
+                }
+            }
+
+            for (int y = 0; y < h; y++)
+            {
+                Span<int> p = beginCChannel.GetRow(y);
+
+                for (int x = 0; x < w; x++)
+                {
+                    p[x] = lookup[p[x] - minValue];
+                }
+            }
+
+            predictor = JxlPredictor.Zero;
+            input.MetaChannels++;
+            input.Channels.Insert(0, channel);
+
+            return;
+        }
+
+        JxlModularImage quantizedInput = new(configuration, 1, 1, -1, -1);
+
+        if (lossy)
+        {
+            quantizedInput.Dispose();
+            quantizedInput = new(configuration, w, h, input.BitDepth, nb);
+
+            for (int c = 0; c < nb; c++)
+            {
+                if (!JxlImageOperations.CopyImage(input.Channels[beginC + c].Plane, quantizedInput.Channels[c].Plane))
+                {
+                    throw new InvalidOperationException("Copying failed");
+                }
+            }
+        }
+
+        numberOfDeltas = 0;
+        bool deltaUsed = false;
+        List<int[]> candidatePalette = [];
+        List<int[]> candidatePaletteImageOrder = [];
+        Dictionary<int[], int> inversePalette = [];
+
+        // Don't use stackalloc for color so we can store it as a
+        // dictionary member in colorFrequencyMap (see below)
+        int[] color = new int[nb];
+        Span<int> colorSpan = color.AsSpan();
+        Span<float> colorWithError = stackalloc float[nb];
+
+        if (lossy)
+        {
+            paletteIterationData.FindFrequentColorDeltas(w * h, input.BitDepth);
+            numberOfDeltas = paletteIterationData.FrequentDeltas[0].Count;
+            Dictionary<int[], int> colorFrequencyMap = [];
+
+            DenseMatrix<int> offsets = new(4, 2);
+
+            for (int y = 1; y + 1 < h; y++)
+            {
+                for (int x = 1; x + 1 < w; x++)
+                {
+                    for (int c = 0; c < nb; c++)
+                    {
+                        colorSpan[c] = input.Channels[beginC + c].GetRow(y)[x];
+                    }
+
+                    // Defaults
+                    offsets[0, 0] = 1;
+                    offsets[0, 0] = 0;
+                    offsets[1, 0] = -1;
+                    offsets[1, 1] = 0;
+                    offsets[2, 0] = 0;
+                    offsets[2, 1] = 1;
+                    offsets[3, 0] = 0;
+                    offsets[3, 1] = -1;
+
+                    bool makesCross = true;
+
+                    for (int i = 0; i < 4 && makesCross; ++i)
+                    {
+                        int dx = offsets[i, 0];
+                        int dy = offsets[i, 1];
+
+                        for (int c = 0; c < nb && makesCross; c++)
+                        {
+                            if (input.Channels[beginC + c].GetRow(y + dy)[x + dx] != colorSpan[c])
+                            {
+                                makesCross = false;
+                            }
+                        }
+                    }
+
+                    if (makesCross)
+                    {
+                        colorFrequencyMap[color]++;
+                    }
+                }
+            }
+
+            const float imageFraction = 0.01f;
+            int colorFrequencyLowerBound = 5 + (int)(input.Height * input.Width * imageFraction);
+
+            foreach (KeyValuePair<int[], int> colorFreq in colorFrequencyMap)
+            {
+                if (colorFreq.Value > colorFrequencyLowerBound)
+                {
+                    candidatePalette.Insert(0, colorFreq.Key);
+                    candidatePaletteImageOrder.Add(colorFreq.Key);
+                }
+            }
+        }
+
+        Dictionary<int[], bool> implicitColor = [];
+        int[][] implicitColors = new int[ImplicitPaletteSize][];
+
+        for (int k = 0; k < ImplicitPaletteSize; k++)
+        {
+            for (int i = 0; i < nb; i++)
+            {
+                color[i] = GetPaletteValue([], k, i, 0, input.BitDepth);
+            }
+
+            implicitColor[color] = true;
+            implicitColors[k] = color;
+        }
+
+        int implicitColorsUsed = 0;
+        Dictionary<int[], int> colorFreqMap = [];
+        for (int y = 0; y < h; y++)
+        {
+            for (int x = 0; x < w; x++)
+            {
+                if (lossy && candidatePalette.Count >= numberOfColors)
+                {
+                    break;
+                }
+
+                for (int c = 0; c < nb; c++)
+                {
+                    colorSpan[c] = input.Channels[beginC + c].GetRow(y)[x];
+                }
+
+                const bool new_color = candidatePalette.Add(color).second;
+                if (new_color)
+                {
+                    if (implicitColor[color])
+                    {
+                        implicitColorsUsed++;
+                    }
+                    else
+                    {
+                        candidatePaletteImageOrder.Add(color);
+                        if (candidatePaletteImageOrder.Count > numberOfColors)
+                        {
+                            throw new InvalidOperationException("Too many colors for palette/indexed");
+                        }
+                    }
+                }
+
+                colorFreqMap[color]++;
+            }
+        }
+
+        numberOfColors = numberOfDeltas + candidatePaletteImageOrder.Count;
+        if (!lossy && numberOfColors + implicitColorsUsed == 1)
+        {
+            // It's not useful to have a single-color palette.
+            throw new InvalidOperationException("Palette only has one color");
+        }
+
+        for (int k = 0; k < ImplicitPaletteSize; k++)
+        {
+            color = implicitColors[k];
+            if (colorFreqMap[color] > 10)
+            {
+                numberOfColors++;
+                candidatePaletteImageOrder.Add(color);
+            }
+        }
+
+        for (int k = 0; k < ImplicitPaletteSize; k++)
+        {
+            color = implicitColors[k];
+            inversePalette[color] = numberOfColors + k;
+        }
+
+        // Don't dispose this.
+        JxlModularChannel newChannel = new(configuration, numberOfColors, nb, -1, -1);
+        Span<int> palette = newChannel.GetRow(0);
+        int oneRow = newChannel.Plane.PixelsPerRow;
+        int oneRowImage = beginCChannel.Plane.PixelsPerRow;
+        int bitDepth = Math.Min(input.BitDepth, 24); // max. 24 bits, cannot be greater
+
+        if (lossy)
+        {
+            for (int i = 0; i < numberOfDeltas; i++)
+            {
+                for (int c = 0; c < 3; c++)
+                {
+                    palette[(c * oneRow) + i] = paletteIterationData.FrequentDeltas[c][i];
+                }
+            }
+        }
+
+        float frequencyThreshold = 4f;
+        int clr = 0;
+
+        if (ordered && nb >= 3)
+        {
+            candidatePaletteImageOrder.Sort((ap, bp) =>
+            {
+                float ay = (0.299f * ap[0]) + (0.587f * ap[1]) + (0.114f * ap[2]) + 0.1f;
+
+                if (ap.Length > 3)
+                {
+                    ay *= 1f + ap[3];
+                }
+
+                float by = (0.299f * bp[0]) + (0.587f * bp[1]) + (0.114f * bp[2]) + 0.1f;
+
+                if (bp.Length > 3)
+                {
+                    by *= 1f + bp[3];
+                }
+
+                ay = colorFreqMap[ap] > frequencyThreshold ? -ay : ay;
+                by = colorFreqMap[bp] > frequencyThreshold ? -by : by;
+
+                return ay.CompareTo(by);
+            });
+        }
+
+        foreach (int[] pcol in candidatePaletteImageOrder)
+        {
+            Span<int> pcolSpan = pcol.AsSpan();
+
+            for (int i = 0; i < nb; i++)
+            {
+                palette[numberOfDeltas + (i * oneRow) + clr] = pcolSpan[i];
+            }
+
+            inversePalette[pcol] = clr++;
+        }
+
+        List<JxlModularState> wpStates = [];
+
+        for (int c = 0; c < nb; c++)
+        {
+            wpStates.Add(new JxlModularState(wpHeader, w));
+        }
+
+        InlineArray3<DenseMatrix<float>> errorRow = default;
+
+        if (lossy)
+        {
+            errorRow[0] = new(nb, w + 4);
+            errorRow[1] = new(nb, w + 4);
+            errorRow[2] = new(nb, w + 4);
+        }
+
+        Span<int> tmp = stackalloc int[32]; // Power of 2
+        Span<int> bestValue = tmp.Slice(0 * nb, nb);
+        Span<int> idealResidual = tmp.Slice(1 * nb, nb);
+        Span<int> quantizedValue = tmp.Slice(2 * nb, nb);
+        Span<int> predictions = tmp.Slice(30 * nb, nb);
+
+        // This is a temporary buffer, values are copied here.
+        // It is so we can swap spans. Since spans are just a view
+        // of memory, using CopyTo as a swap means we need a
+        // separate buffer like this for the swapping value.
+        Span<float> tempBuffer = stackalloc float[w + 4];
+
+        for (int y = 0; y < h; y++)
+        {
+            for (int c = 0; c < nb; c++)
+            {
+                p_in[c] = input.channel[beginC + c].Row(y);
+                if (lossy)
+                    p_quant[c] = quantized_input.channel[c].Row(y);
+            }
+
+            Span<int> p = beginCChannel.GetRow(y);
+
+            for (int x = 0; x < w; x++)
+            {
+                int index;
+                if (!lossy)
+                {
+                    for (int c = 0; c < nb; c++)
+                    {
+                        color[c] = p_in[c][x];
+                    }
+
+                    index = inversePalette[color];
+                }
+                else
+                {
+                    int best_index = 0;
+                    bool best_is_delta = false;
+                    float best_distance = float.PositiveInfinity;
+
+                    tmp.Clear();
+
+                    foreach (double diffusion_multiplier in (Span<double>)[0.55, 0.75])
+                    {
+                        for (int c = 0; c < nb; c++)
+                        {
+                            colorWithError[c] =
+                                p_in[c][x] + ((paletteIterationData.IsFinalRun ? 1 : 0) *
+                                                 diffusion_multiplier * errorRow[0][c, x + 2]);
+                            color[c] = (int)Math.Clamp(MathF.Round(colorWithError[c]), 0, (1 << input.BitDepth) - 1);
+                        }
+
+                        for (int c = 0; c < nb; c++)
+                        {
+                            predictions[c] = PredictTreeNoWeightedPrediction(w, p_quant[c] + x, oneRowImage, x, y, predictor, wpStates[c]).Guess;
+                        }
+
+                        void TryIndex(int index, Span<int> predictions, Span<int> idealResidual, Span<float> colorWithError, ref Span<int> bestValue, ref Span<int> quantizedValue, Span<int> palette, ref int numberOfColors, ref int numberOfDeltas)
+                        {
+                            for (int c = 0; c < nb; c++)
+                            {
+                                quantizedValue[c] = GetPaletteValue(palette, index, c, oneRow, bitDepth);
+                                if (index < numberOfDeltas)
+                                {
+                                    quantizedValue[c] += predictions[c];
+                                }
+                            }
+
+                            float color_distance = 32.0f / (1 << Math.Max(0, 2 * (bitDepth - 8))) * ColorDistance(colorWithError, quantizedValue);
+
+                            float indexPenalty = 0;
+                            if (index == -1)
+                            {
+                                indexPenalty = -124;
+                            }
+                            else if (index < 0)
+                            {
+                                indexPenalty = -2 * index;
+                            }
+                            else if (index < numberOfDeltas)
+                            {
+                                indexPenalty = 250;
+                            }
+                            else if (index < numberOfColors)
+                            {
+                                indexPenalty = 150;
+                            }
+                            else if (index < numberOfColors + LargeCubeOffset)
+                            {
+                                indexPenalty = 70;
+                            }
+                            else
+                            {
+                                indexPenalty = 256;
+                            }
+
+                            float distance = color_distance + indexPenalty;
+                            if (distance < best_distance)
+                            {
+                                best_distance = distance;
+                                best_index = index;
+                                best_is_delta = index < numberOfDeltas;
+
+                                RuntimeUtility.Swap(ref bestValue, ref quantizedValue);
+
+                                for (int c = 0; c < nb; c++)
+                                {
+                                    idealResidual[c] = (int)(colorWithError[c] - predictions[c]);
+                                }
+                            }
+                        }
+
+                        for (index = MinimumImplicitPaletteIndex; index < numberOfColors; index++)
+                        {
+                            TryIndex(index);
+                        }
+
+                        TryIndex(QuantizeColorToImplicitPaletteIndex(color, numberOfColors, bitDepth, false));
+
+                        if (EncodeToHighQualityImplicitPalette)
+                        {
+                            TryIndex(QuantizeColorToImplicitPaletteIndex(color, numberOfColors, bitDepth, true));
+                        }
+                    }
+
+                    index = best_index;
+                    deltaUsed |= best_is_delta;
+
+                    if (!paletteIterationData.IsFinalRun)
+                    {
+                        for (int c = 0; c < 3; c++)
+                        {
+                            paletteIterationData.Deltas[c].Add(idealResidual[c]);
+                        }
+
+                        paletteIterationData.DeltaDistances.Add(best_distance);
+                    }
+
+                    for (int c = 0; c < nb; c++)
+                    {
+                        wpStates[c].UpdatePredictionErrors(bestValue[c], x, y, w);
+                        p_quant[c][x] = bestValue[c];
+                    }
+
+                    float len_error = 0;
+                    for (int c = 0; c < nb; c++)
+                    {
+                        float local_error = colorWithError[c] - bestValue[c];
+                        len_error += local_error * local_error;
+                    }
+
+                    len_error = MathF.Sqrt(len_error);
+                    float modulate = 1f;
+                    long len_limit = 38 << Math.Max(0, bitDepth - 8);
+                    if (len_error > len_limit)
+                    {
+                        modulate *= len_limit / len_error;
+                    }
+
+                    DenseMatrix<int> offsets = new(12, 2);
+
+                    for (int c = 0; c < nb; c++)
+                    {
+                        float total_error = colorWithError[c] - bestValue[c];
+
+                        DefaultOffsets.Data.AsSpan().CopyTo(offsets.Data);
+
+                        float total_available = 0;
+                        for (int i = 0; i < 11; i++)
+                        {
+                            int row = offsets[i, 0];
+                            int col = offsets[i, 1];
+
+                            if (Math.Sign(errorRow[row][c, x + col]) != Math.Sign(total_error))
+                            {
+                                total_available += errorRow[row][c, x + col];
+                            }
+                        }
+
+                        float weight = MathF.Abs(total_error) / (MathF.Abs(total_available) + 1e-3f);
+                        weight = MathF.Min(weight, 1.0f);
+
+                        for (int i = 0; i < 11; ++i)
+                        {
+                            int row = offsets[i, 0];
+                            int col = offsets[i, 1];
+
+                            if (Math.Sign(errorRow[row][c, x + col]) != Math.Sign(total_error))
+                            {
+                                total_error += weight * errorRow[row][c, x + col];
+                                errorRow[row][c, x + col] *= 1 - weight;
+                            }
+                        }
+
+                        total_error *= modulate;
+                        float remaining_error = (1.0f / 14f) * total_error;
+                        errorRow[0][c, x + 3] += 2 * remaining_error;
+                        errorRow[0][c, x + 4] += remaining_error;
+                        errorRow[1][c, x + 0] += remaining_error;
+
+                        for (int i = 0; i < 5; ++i)
+                        {
+                            errorRow[1][c, x + i] += remaining_error;
+                            errorRow[2][c, x + i] += remaining_error;
+                        }
+                    }
+                }
+
+                if (paletteIterationData.IsFinalRun)
+                {
+                    p[x] = index;
+                }
+            }
+
+            if (lossy)
+            {
+                for (int c = 0; c < nb; c++)
+                {
+                    // Variables for swapping
+                    Span<float> pos0 = errorRow[0].Data.AsSpan(c, w + 4);
+                    Span<float> pos1 = errorRow[1].Data.AsSpan(c, w + 4);
+                    Span<float> pos2 = errorRow[2].Data.AsSpan(c, w + 4);
+
+                    // we need to swap:
+                    //     error_row[0][c].swap(error_row[1][c]);
+                    pos0.CopyTo(tempBuffer);
+                    pos1.CopyTo(pos0);
+                    tempBuffer.CopyTo(pos1);
+
+                    // swap old1, old2
+                    pos1.CopyTo(tempBuffer);
+                    pos2.CopyTo(pos1);
+
+                    pos2.Clear();
+                }
+            }
+        }
+
+        if (!deltaUsed)
+        {
+            predictor = JxlPredictor.Zero;
+        }
+
+        if (paletteIterationData.IsFinalRun)
+        {
+            input.MetaChannels++;
+            input.Channels.RemoveRange(beginC + 1, endC - beginC);
+            input.Channels.Insert(0, newChannel);
+        }
+
+        numberOfColors -= numberOfDeltas;
+    }
+
+    /// <summary>
+    /// For palette encoding.
+    /// </summary>
+    internal sealed class PaletteIterationData
+    {
+        /// <summary>
+        /// Maximum number of deltas.
+        /// </summary>
+        private const int MaxDeltas = 128;
+
+        private InlineArray3<List<int>> deltas;
+
+        public bool IsFinalRun { get; set; }
+
+        public InlineArray3<List<int>> Deltas
+        {
+            get => this.deltas;
+            set => this.deltas = value;
+        }
+
+        public List<double> DeltaDistances { get; set; } = [];
+
+        public List<int>[] FrequentDeltas { get; set; } = new List<int>[3];
+
+        public void FindFrequentColorDeltas(int numPixels, int bitDepth)
+        {
+            Dictionary<InlineArray3<int>, double> deltaFrequencyMap = [];
+            int bucketSize = 3 << Math.Max(0, bitDepth - 3);
+            for (int i = 0; i < this.Deltas[0].Count; i++)
+            {
+                InlineArray3<int> delta = default;
+                delta[0] = RoundInteger(this.Deltas[0][i], bucketSize);
+                delta[1] = RoundInteger(this.Deltas[1][i], bucketSize);
+                delta[2] = RoundInteger(this.Deltas[2][i], bucketSize);
+
+                // Condition equivalent to delta[0] == 0 && delta[1] == 0 && delta[2] == 0
+                if ((delta[0] | delta[1] | delta[2]) == 0)
+                {
+                    continue;
+                }
+
+                deltaFrequencyMap[delta] += Math.Sqrt(Math.Sqrt(this.DeltaDistances[i]));
+            }
+
+            float deltaDistanceMultiplier = 1f / numPixels;
+            Span<float> allZero = [0, 0, 0];
+
+            foreach (KeyValuePair<InlineArray3<int>, double> deltaFrequency in deltaFrequencyMap)
+            {
+                float deltaDistance = MathF.Sqrt(ColorDistance(allZero, deltaFrequency.Key)) + 1f;
+                double second = deltaFrequency.Value * deltaDistance * deltaDistanceMultiplier;
+                deltaFrequencyMap[deltaFrequency.Key] = second;
+            }
+
+            Dictionary<InlineArray3<int>, double> sorted = deltaFrequencyMap.ToDictionary(
+                entry => entry.Key,
+                entry => entry.Value);
+
+            IOrderedEnumerable<KeyValuePair<InlineArray3<int>, double>> sortedEnumerator = sorted.OrderBy(
+                x => x.Value);
+
+            foreach (KeyValuePair<InlineArray3<int>, double> deltaFrequency in sortedEnumerator)
+            {
+                if (this.FrequentDeltas[0].Count >= MaxDeltas)
+                {
+                    break;
+                }
+
+                if (deltaFrequency.Value < 17)
+                {
+                    break;
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    this.FrequentDeltas[c].Add(deltaFrequency.Key[c] * bucketSize);
+                }
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlRct.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlRct.cs
new file mode 100644
index 0000000000..315fcf2b4e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlRct.cs
@@ -0,0 +1,403 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+/// <summary>
+/// Reversible Color Transform (RCT)
+/// </summary>
+internal static class JxlRct
+{
+    /// <summary>
+    /// Performs Inverse Reversible Color Transform (RCT) on one row.
+    /// </summary>
+    /// <param name="transformType">
+    /// The kind of RCT.
+    /// </param>
+    /// <param name="in0">Input Y</param>
+    /// <param name="in1">Input Co</param>
+    /// <param name="in2">Input Cg</param>
+    /// <param name="out0">Output R</param>
+    /// <param name="out1">Output G</param>
+    /// <param name="out2">Output B</param>
+    private static void InverseRctRow(int transformType, Span<int> in0, Span<int> in1, Span<int> in2, Span<int> out0, Span<int> out1, Span<int> out2)
+    {
+        DebugGuard.MustBeBetweenOrEqualTo(transformType, 0, 6, nameof(transformType));
+
+        int width = in0.Length; // All input & output channels have equal widths
+
+        int second = transformType >> 1;
+        int third = transformType & 1;
+
+        int n = Vector<int>.Count;
+
+        if (transformType == 6)
+        {
+            // SIMD-aligned loop
+            int x;
+            for (x = 0; x + n - 1 < width; x += n)
+            {
+                Vector<int> y = new(in0[x..]);
+                Vector<int> co = new(in1[x..]);
+                Vector<int> cg = new(in2[x..]);
+                y -= cg >> 1;
+                Vector<int> g = cg + y;
+                y -= co >> 1;
+                Vector<int> r = y + co;
+                r.CopyTo(out0[x..]);
+                g.CopyTo(out1[x..]);
+                y.CopyTo(out2[x..]);
+            }
+
+            // Remainder (SIMD-unaligned)
+            for (; x < width; x++)
+            {
+                int y = in0[x];
+                int co = in1[x];
+                int cg = in2[x];
+                int tmp = y + -(cg >> 1);
+                int g = cg + tmp;
+                int b = tmp + -(co >> 1);
+                int r = b + co;
+                out0[x] = r;
+                out1[x] = g;
+                out2[x] = b;
+            }
+        }
+        else
+        {
+            // SIMD-aligned loop
+            int x;
+            for (x = 0; x + n - 1 < width; x += n)
+            {
+                // Add a Vec suffix because the variables
+                // 'second' and 'third' are already defined.
+                // Though 'first' isn't, it's still suffixed
+                // for consistency.
+                Vector<int> firstVec = new(in0[x..]);
+                Vector<int> secondVec = new(in1[x..]);
+                Vector<int> thirdVec = new(in2[x..]);
+
+                if (third > 0)
+                {
+                    thirdVec += firstVec;
+                }
+
+                if (second == 1)
+                {
+                    secondVec += firstVec;
+                }
+                else if (second == 2)
+                {
+                    secondVec += (firstVec + thirdVec) >> 1;
+                }
+
+                firstVec.CopyTo(out0[x..]);
+                secondVec.CopyTo(out1[x..]);
+                thirdVec.CopyTo(out2[x..]);
+            }
+
+            // Remainder (SIMD-unaligned)
+            for (; x < width; x++)
+            {
+                int firstCoeff = in0[x];
+                int secondCoeff = in1[x];
+                int thirdCoeff = in2[x];
+
+                if (third > 0)
+                {
+                    thirdCoeff += firstCoeff;
+                }
+
+                if (second == 1)
+                {
+                    secondCoeff += firstCoeff;
+                }
+                else if (second == 2)
+                {
+                    secondCoeff += (firstCoeff + thirdCoeff) >> 1;
+                }
+
+                out0[x] = firstCoeff;
+                out1[x] = secondCoeff;
+                out2[x] = thirdCoeff;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Performs Inverse Reversible Color Transform (RCT) on an entire
+    /// image.
+    /// </summary>
+    /// <param name="configuration">
+    /// The configuration is used to access maximum degree of parallelism.
+    /// </param>
+    /// <param name="img">
+    /// Image to compute inverse RCT.
+    /// </param>
+    /// <param name="beginC">
+    /// Offset of the color channel for Y, Co, Cg.
+    /// </param>
+    /// <param name="rctType">
+    /// Type of Reversible Color Transform
+    /// </param>
+    /// <exception cref="InvalidOperationException">
+    /// Invoked when RCT/permutation is invalid.
+    /// </exception>
+    public static void InverseRct(Configuration configuration, JxlModularImage img, int beginC, int rctType)
+    {
+        JxlTransform.CheckEqualChannels(img, beginC, beginC + 2);
+
+        int m = beginC;
+        JxlModularChannel c0 = img.Channels[m + 0];
+        int w = c0.Width;
+        int h = c0.Height;
+
+        if (rctType == 0)
+        {
+            // No-op
+            return;
+        }
+
+        int permutation = rctType / 7;
+
+        if (permutation >= 7)
+        {
+            throw new InvalidOperationException("Permutation must be <= 6");
+        }
+
+        int custom = rctType % 7;
+
+        if (custom == 0)
+        {
+            // Permute-only.
+            JxlModularChannel ch0 = img.Channels[m];
+            JxlModularChannel ch1 = img.Channels[m + 1];
+            JxlModularChannel ch2 = img.Channels[m + 2];
+            img.Channels[m + (permutation % 3)] = ch0;
+            img.Channels[m + ((permutation + 1 + (permutation / 3)) % 3)] = ch1;
+            img.Channels[m + ((permutation + 2 - (permutation / 3)) % 3)] = ch2;
+            return;
+        }
+
+        _ = Parallel.For(0, h, configuration.GetParallelOptions(), y =>
+        {
+            Span<int> in0 = img.Channels[m].GetRow(y);
+            Span<int> in1 = img.Channels[m + 1].GetRow(y);
+            Span<int> in2 = img.Channels[m + 2].GetRow(y);
+
+            Span<int> out0 = img.Channels[m + (permutation % 3)].GetRow(y);
+            Span<int> out1 = img.Channels[m + ((permutation + 1 + (permutation / 3)) % 3)].GetRow(y);
+            Span<int> out2 = img.Channels[m + ((permutation + 2 - (permutation / 3)) % 3)].GetRow(y);
+
+            InverseRctRow(custom, in0, in1, in2, out0, out1, out2);
+        });
+    }
+
+    /// <summary>
+    /// Performs Reversible Color Transform (RCT) on one row.
+    /// </summary>
+    /// <param name="transform">
+    /// The type of RCT transform method.
+    /// </param>
+    /// <param name="in0">R</param>
+    /// <param name="in1">G</param>
+    /// <param name="in2">B</param>
+    /// <param name="out0">Y</param>
+    /// <param name="out1">Co</param>
+    /// <param name="out2">Cg</param>
+    private static void ForwardRctRow(int transform, Span<int> in0, Span<int> in1, Span<int> in2, Span<int> out0, Span<int> out1, Span<int> out2)
+    {
+        DebugGuard.MustBeLessThanOrEqualTo(transform, 6, nameof(transform));
+
+        int second = transform >> 1;
+        int third = transform & 1;
+
+        int width = in0.Length; // All input & output channels have equal widths
+
+        if (!Vector.IsHardwareAccelerated || Vector<int>.Count == 1)
+        {
+            // No SIMD support. Use scalar.
+            if (transform == 6)
+            {
+                for (int x = 0; x < width; x++)
+                {
+                    int r = in0[x];
+                    int g = in1[x];
+                    int b = in2[x];
+                    int o1 = r - b;
+                    int tmp = b + (o1 >> 1);
+                    int o2 = g - tmp;
+                    out0[x] = tmp + (o2 >> 1);
+                    out1[x] = o1;
+                    out2[x] = o2;
+                }
+            }
+            else
+            {
+                for (int x = 0; x < width; x++)
+                {
+                    int firstCoeff = in0[x];
+                    int secondCoeff = in1[x];
+                    int thirdCoeff = in2[x];
+
+                    if (second == 1)
+                    {
+                        secondCoeff -= firstCoeff;
+                    }
+                    else if (second == 2)
+                    {
+                        secondCoeff -= (firstCoeff + thirdCoeff) >> 1;
+                    }
+
+                    if (third != 0)
+                    {
+                        thirdCoeff -= firstCoeff;
+                    }
+
+                    out0[x] = firstCoeff;
+                    out1[x] = secondCoeff;
+                    out2[x] = thirdCoeff;
+                }
+            }
+        }
+        else
+        {
+            // Have SIMD support
+            int lanes = Vector<int>.Count;
+
+            if (transform == 6)
+            {
+                for (int x = 0; x < width; x += lanes)
+                {
+                    Vector<int> r = new(in0[x..]);
+                    Vector<int> g = new(in1[x..]);
+                    Vector<int> b = new(in2[x..]);
+                    Vector<int> o1 = r - b;
+                    Vector<int> tmp = b + (o1 >> 1);
+                    Vector<int> o2 = g - tmp;
+                    Vector<int> o0 = tmp + (o2 >> 1);
+                    o0.CopyTo(out0[x..]);
+                    o1.CopyTo(out1[x..]);
+                    o2.CopyTo(out2[x..]);
+                }
+            }
+            else
+            {
+                for (int x = 0; x < width; x += lanes)
+                {
+                    Vector<int> i0 = new(in0[x..]);
+                    Vector<int> i1 = new(in1[x..]);
+                    Vector<int> i2 = new(in2[x..]);
+                    Vector<int> o1 = i1;
+
+                    // TODO: duplicate loops for second == 1, second == 2
+                    // and otherwise? We should reduce the number of branches in
+                    // loops.
+                    if (second == 1)
+                    {
+                        o1 -= i0;
+                    }
+                    else if (second == 2)
+                    {
+                        o1 -= (i0 + i2) >> 1;
+                    }
+
+                    Vector<int> o2 = i2;
+
+                    if (third != 0)
+                    {
+                        o2 -= i0;
+                    }
+
+                    i0.CopyTo(out0[x..]);
+                    o1.CopyTo(out1[x..]);
+                    o2.CopyTo(out2[x..]);
+                }
+            }
+        }
+    }
+
+    private static void RctPermute(InlineArray3<JxlModularChannel> input, int permutation, ref InlineArray3<JxlModularChannel> output)
+    {
+        output[0] = input[permutation % 3];
+        output[1] = input[(permutation + 1 + (permutation / 3)) % 3];
+        output[2] = input[(permutation + 2 - (permutation / 3)) % 3];
+    }
+
+    /// <summary>
+    /// Performs Forward Reversible Color Transform. (Internal method)
+    /// </summary>
+    /// <param name="configuration">
+    /// Configuration for parallelism.
+    /// </param>
+    /// <param name="input">
+    /// Input channels.
+    /// </param>
+    /// <param name="output">
+    /// Output channels.
+    /// </param>
+    /// <param name="rctType">
+    /// Kind of RCT.
+    /// </param>
+    private static void ForwardRctCore(Configuration configuration, InlineArray3<JxlModularChannel> input, InlineArray3<JxlModularChannel> output, int rctType)
+    {
+        int permutation = rctType / 7;
+        int transform = rctType % 7;
+
+        InlineArray3<JxlModularChannel> inp = default;
+        RctPermute(input, permutation, ref inp);
+
+        int width = output[0].Width;
+        int height = output[0].Height;
+
+        _ = Parallel.For(0, height, configuration.GetParallelOptions(), y =>
+        {
+            Span<int> i0 = inp[0].GetRow(y);
+            Span<int> i1 = inp[1].GetRow(y);
+            Span<int> i2 = inp[2].GetRow(y);
+
+            Span<int> o0 = output[0].GetRow(y);
+            Span<int> o1 = output[1].GetRow(y);
+            Span<int> o2 = output[2].GetRow(y);
+
+            ForwardRctRow(transform, i0, i1, i2, o0, o1, o2);
+        });
+    }
+
+    /// <summary>
+    /// Performs forward Reversible Color Transform (RCT).
+    /// </summary>
+    /// <param name="configuration">
+    /// Configuration for parallelism.
+    /// </param>
+    /// <param name="image">
+    /// Image to perform Reversible Color Transform.
+    /// </param>
+    /// <param name="beginC">
+    /// Offset of the color channel.
+    /// </param>
+    /// <param name="rctType">
+    /// Kind of RCT.
+    /// </param>
+    public static void ForwardRct(Configuration configuration, JxlModularImage image, int beginC, int rctType)
+    {
+        JxlTransform.CheckEqualChannels(image, beginC, beginC + 2);
+
+        if (rctType == 0)
+        {
+            // No-op
+            return;
+        }
+
+        InlineArray3<JxlModularChannel> channels = default;
+        channels[0] = image.Channels[beginC];
+        channels[1] = image.Channels[beginC + 1];
+        channels[2] = image.Channels[beginC + 2];
+
+        return ForwardRct(configuration, new JxlModularImage(channels[0], channels[1], channels[2]), beginC, rctType);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlSqueeze.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlSqueeze.cs
new file mode 100644
index 0000000000..11752a92c9
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlSqueeze.cs
@@ -0,0 +1,804 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+#pragma warning disable IDE0057 // Use range operator
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+/// <summary>
+/// Implements the <em>squeeze transform</em>.
+/// </summary>
+/// <remarks>
+/// The squeeze transform in JXL is a reversible
+/// wavelet-like decomposition used in the modular mode
+/// to reduce redundancy and improve compression,
+/// especially for structured or synthetic images.
+/// It works by hierarchically splitting channesl
+/// into lower-resolution representations plus
+/// residuals, giving us multi-resolution coding while
+/// remaining lossless.
+/// </remarks>
+internal static class JxlSqueeze
+{
+    private const int MaxFirstPreviewSize = 8;
+
+    /// <summary>
+    /// Computes the average of two integers.
+    /// </summary>
+    /// <remarks>
+    /// This method is specific to the Squeeze transform.
+    /// It is not a generic average method.
+    /// </remarks>
+    /// <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;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int SmoothTendency(int b, int a, int n)
+    {
+        int diff = 0;
+        if (b >= a && a >= n)
+        {
+            diff = ((4 * b) - (3 * n) - a + 6) / 12;
+
+            if (diff - (diff & 1) > 2 * (b - a))
+            {
+                diff = (2 * (b - a)) + 1;
+            }
+
+            if (diff + (diff & 1) > 2 * (a - n))
+            {
+                diff = 2 * (a - n);
+            }
+        }
+        else if (b <= a && a <= n)
+        {
+            diff = ((4 * b) - (3 * n) - a - 6) / 12;
+
+            if (diff + (diff & 1) < 2 * (b - a))
+            {
+                diff = (2 * (b - a)) - 1;
+            }
+
+            if (diff - (diff & 1) < 2 * (a - n))
+            {
+                diff = 2 * (a - n);
+            }
+        }
+
+        return diff;
+    }
+
+    // The function operates on 256-bit fixed size vectors,
+    // 8 elements at a time. It should still work even on CPUs
+    // without 256-bit vector support (the JIT will translate
+    // these into 128-bit halves, or scalar without SIMD support).
+    //
+    // The FastUnsqueeze method CAN operate on vectors below
+    // 256-bit, but not above. It's better to simply use Vector256
+    // rather than duplicate everything. Vector<T> may be a problem
+    // as its number of elements can be greater than 8 which is too
+    // much for this method.
+    [MethodImpl(InliningOptions.HotPath)] // Called on an entire image
+    private static void FastUnsqueeze(Span<int> pResidual, Span<int> pAvg, Span<int> pNAvg, Span<int> pPout, Span<int> pOut, Span<int> pNOut)
+    {
+        Vector256<int> oneThird = Vector256.Create(0x55555556);
+
+        ref int pAvgRef = ref MemoryMarshal.GetReference(pAvg);
+        ref int pNAvgRef = ref MemoryMarshal.GetReference(pNAvg);
+        ref int pPoutReference = ref MemoryMarshal.GetReference(pPout);
+        ref int pResidualRef = ref MemoryMarshal.GetReference(pResidual);
+        ref int pOutRef = ref MemoryMarshal.GetReference(pOut);
+        ref int pNOutRef = ref MemoryMarshal.GetReference(pNOut);
+
+        Vector256<int> avg = Vector256.LoadUnsafe(ref pAvgRef);
+        Vector256<int> nextAvg = Vector256.LoadUnsafe(ref pNAvgRef);
+        Vector256<int> top = Vector256.LoadUnsafe(ref pPoutReference);
+
+        Vector256<int> ba = top - avg;
+        Vector256<int> an = avg - nextAvg;
+        Vector256<int> nonmono = ba ^ an;
+        Vector256<int> absba = Vector256.Abs(ba);
+        Vector256<int> absan = Vector256.Abs(an);
+        Vector256<int> absbn = Vector256.Abs(top - nextAvg);
+
+        Vector256<long> a3eh = Vector256_.MultiplyEven(absba, oneThird);
+        Vector256<long> a3oh = Vector256_.MultiplyOdd(absba, oneThird);
+
+        Vector256<int> a3 = BitConverter.IsLittleEndian
+            ? Vector256_.InterleaveOdd(a3eh.AsInt32(), a3oh.AsInt32())
+            : Vector256_.InterleaveEven(a3eh.AsInt32(), a3oh.AsInt32());
+
+        a3 += absbn + Vector256.Create(2);
+
+        Vector256<int> absdiff = a3 >> 2;
+
+        Vector256<int> skipdiff = Vector256_.NotEqual(ba, Vector256<int>.Zero);
+        skipdiff &= Vector256_.NotEqual(an, Vector256<int>.Zero);
+        skipdiff &= Vector256.LessThan(nonmono, Vector256<int>.Zero);
+
+        Vector256<int> absBa2 = (absba << 1) + (absdiff & Vector256<int>.One);
+
+        absdiff = Vector256.ConditionalSelect(
+            Vector256.GreaterThan(absdiff, absBa2),
+            (absba << 1) + Vector256<int>.One,
+            absdiff);
+
+        Vector256<int> absan2 = absan << 1;
+        absdiff = Vector256.ConditionalSelect(
+            Vector256.GreaterThan(absdiff + (absdiff & Vector256<int>.One), absan2),
+            absan2,
+            absdiff);
+
+        Vector256<int> diff1 = Vector256.ConditionalSelect(
+            Vector256.LessThan(top, nextAvg),
+            -absdiff,
+            absdiff);
+
+        Vector256<int> tendency = diff1 & ~skipdiff;
+        Vector256<int> diffMinusTendency = Vector256.LoadUnsafe(ref pResidualRef);
+        Vector256<int> diff = diffMinusTendency + tendency;
+        Vector256<int> output = avg + (diff + (diff << 31));
+
+        output.StoreUnsafe(ref pOutRef);
+        (output - diff).StoreUnsafe(ref pNOutRef);
+    }
+
+    public static void InverseHorizontalSqueeze(Configuration configuration, JxlModularImage input, int c, int rc)
+    {
+        // Channel offsets should not overflow.
+        DebugGuard.MustBeLessThan(c, input.Channels.Count, nameof(c));
+        DebugGuard.MustBeLessThan(rc, input.Channels.Count, nameof(c));
+
+        JxlModularChannel inputChannel = input.Channels[c];
+        JxlModularChannel inputResidualChannel = input.Channels[rc];
+
+        if (inputChannel.Width != JxlMath.DivCeil(inputChannel.Width + inputResidualChannel.Width, 2))
+        {
+            throw new InvalidOperationException("Invalid width");
+        }
+
+        if (inputChannel.Height != inputResidualChannel.Height)
+        {
+            throw new InvalidOperationException("Height of the input channel must be equal to the height of the residual channel");
+        }
+
+        if (inputResidualChannel.Width == 0)
+        {
+            input.Channels[c].HorizontalShift--;
+            return;
+        }
+
+        // Do not dispose.
+        JxlModularChannel outputChannel = new(
+            configuration,
+            inputChannel.Width + inputResidualChannel.Width,
+            inputChannel.Height,
+            inputChannel.HorizontalShift - 1,
+            inputChannel.VerticalShift);
+
+        if (inputResidualChannel.Height == 0)
+        {
+            input.Channels[c] = outputChannel;
+            return;
+        }
+
+        // The number of rows a single parallel iteration computes
+        // is stored here.
+        const int rowsPerThread = 8;
+
+        // rowsPerThread * 9, aligned to the power of 2.
+        const int rowsPerThreadMul9Alignment = 128;
+
+        // rowsPerThread * 8, aligned to the power of 2.
+        const int rowsPerThreadMul8Alignment = 64;
+
+        _ = Parallel.For(0, JxlMath.DivCeil(inputChannel.Height, rowsPerThread), configuration.GetParallelOptions(), idx =>
+        {
+            int y0 = idx * rowsPerThread;
+            int rows = Math.Min(rowsPerThread, inputChannel.Height - y0);
+            int x = 0;
+
+            int onerow_in = inputChannel.Plane.PixelsPerRow;
+            int onerow_inr = inputResidualChannel.Plane.PixelsPerRow;
+            int onerow_out = outputChannel.Plane.PixelsPerRow;
+            Span<int> pResidual = inputResidualChannel.GetRow(y0);
+            Span<int> pAverage = inputChannel.GetRow(y0);
+            Span<int> pOut = outputChannel.GetRow(y0);
+            ref int pOutRef = ref MemoryMarshal.GetReference(pOut);
+
+            Span<int> bpAvg = stackalloc int[rowsPerThreadMul9Alignment].Slice(0, rowsPerThread * 9);
+            Span<int> bpResidual = stackalloc int[rowsPerThreadMul8Alignment].Slice(0, rowsPerThread * 8);
+            Span<int> bpOutEven = stackalloc int[rowsPerThreadMul8Alignment].Slice(0, rowsPerThread * 8);
+            Span<int> bpOutOdd = stackalloc int[rowsPerThreadMul8Alignment].Slice(0, rowsPerThread * 8);
+            Span<int> bpOutEvenT = stackalloc int[rowsPerThreadMul8Alignment].Slice(0, rowsPerThread * 8);
+            Span<int> bpOutOddT = stackalloc int[rowsPerThreadMul8Alignment].Slice(0, rowsPerThread * 8);
+
+            ref int bpOutEvenTRef = ref MemoryMarshal.GetReference(bpOutEvenT);
+            ref int bpOutOddTRef = ref MemoryMarshal.GetReference(bpOutOddT);
+
+            int n = Vector256<int>.Count;
+
+            if (inputResidualChannel.Width > 16 && rows == rowsPerThread)
+            {
+                for (; x < inputResidualChannel.Width - 9; x += 8)
+                {
+                    JxlSimdUtils.Transpose8x8Block(pResidual[x..], bpResidual, onerow_inr);
+                    JxlSimdUtils.Transpose8x8Block(pAverage[x..], bpAvg, onerow_in);
+
+                    for (int y = 0; y < rowsPerThread; y++)
+                    {
+                        bpAvg[64 + y] = pAverage[x + 8 + (onerow_in * y)];
+                    }
+
+                    for (int i = 0; i < 8; i++)
+                    {
+                        // i * 8
+                        int i8 = i << 3;
+
+                        FastUnsqueeze(
+                            bpResidual[i8..],
+                            bpAvg[i8..],
+                            bpAvg[(8 * (i + 1))..],
+                            (x + i > 0) ? bpOutOdd[(8 * ((x + i - 1) & 7))..] : bpAvg[i8..],
+                            bpOutEven[i8..],
+                            bpOutOdd[i8..]);
+                    }
+
+                    JxlSimdUtils.Transpose8x8Block(bpOutEven, bpOutEvenT, 8);
+                    JxlSimdUtils.Transpose8x8Block(bpOutOdd, bpOutOddT, 8);
+
+                    for (int y = 0; y < rowsPerThread; y++)
+                    {
+                        // y * 8
+                        int y8 = y << 3;
+
+                        for (int i = 0; i < rowsPerThread; i += n)
+                        {
+                            int offset = y8 + i;
+
+                            Vector256<int> even = Vector256.LoadUnsafe(ref Unsafe.Add(ref bpOutEvenTRef, offset));
+                            Vector256<int> odd = Vector256.LoadUnsafe(ref Unsafe.Add(ref bpOutOddTRef, offset));
+
+                            JxlSimdUtils.StoreInterleaved(
+                                even,
+                                odd,
+                                ref Unsafe.Add(ref pOutRef, ((x + i) << 1) + (onerow_out * y)));
+                        }
+                    }
+                }
+            }
+
+            for (int y = 0; y < rows; y++)
+            {
+                UnsqueezeRow(y0 + y, x);
+            }
+        });
+
+        input.Channels[c] = outputChannel;
+
+        void UnsqueezeRow(int y, int x0)
+        {
+            Span<int> residual = inputResidualChannel.GetRow(y);
+            Span<int> average = inputChannel.GetRow(y);
+            Span<int> output = outputChannel.GetRow(y);
+            int inputChannelWidth = inputChannel.Width;
+            int outputChannelWidth = outputChannel.Width;
+
+            for (int x = x0; x < inputResidualChannel.Width; x++)
+            {
+                int xLsh1 = x << 1; // Prevents left shifting three times. Saves on CPU cycles.
+
+                int diffMinusTendency = residual[x];
+                int avg = average[x];
+                int nextAverage = x + 1 < inputChannelWidth ? average[x + 1] : avg;
+
+                int left = x > 0 ? output[xLsh1 - 1] : avg;
+                int tendency = SmoothTendency(left, avg, nextAverage);
+                int diff = diffMinusTendency + tendency;
+
+                int a = avg + (diff / 2);
+                output[xLsh1] = a;
+
+                int b = a - diff;
+                output[xLsh1 + 1] = b;
+            }
+
+            if ((outputChannelWidth & 1) > 0)
+            {
+                output[outputChannelWidth - 1] = average[inputChannelWidth - 1];
+            }
+        }
+    }
+
+    public static void InverseVerticalSqueeze(Configuration configuration, JxlModularImage input, int c, int rc)
+    {
+        // Channel offsets should not overflow.
+        DebugGuard.MustBeLessThan(c, input.Channels.Count, nameof(c));
+        DebugGuard.MustBeLessThan(rc, input.Channels.Count, nameof(c));
+
+        JxlModularChannel inputChannel = input.Channels[c];
+        JxlModularChannel inputResidualChannel = input.Channels[rc];
+
+        if (inputChannel.Height != JxlMath.DivCeil(inputChannel.Height + inputResidualChannel.Height, 2))
+        {
+            throw new InvalidOperationException("Invalid height");
+        }
+
+        if (inputChannel.Width != inputResidualChannel.Width)
+        {
+            throw new InvalidOperationException("Width of the input channel must be equal to the width of the residual channel");
+        }
+
+        if (inputResidualChannel.Height == 0)
+        {
+            input.Channels[c].VerticalShift--;
+            return;
+        }
+
+        // Do not dispose.
+        JxlModularChannel outputChannel = new(
+            configuration,
+            inputChannel.Width,
+            inputChannel.Height + inputResidualChannel.Height,
+            inputChannel.HorizontalShift,
+            inputChannel.VerticalShift - 1);
+
+        if (inputResidualChannel.Width == 0)
+        {
+            input.Channels[c] = outputChannel;
+            return;
+        }
+
+        // The number of columns a single parallel iteration computes
+        // is stored here.
+        const int colsPerThread = 8;
+
+        _ = Parallel.For(0, JxlMath.DivCeil(inputChannel.Width, colsPerThread), configuration.GetParallelOptions(), idx =>
+        {
+            int x0 = idx * colsPerThread;
+            int x1 = Math.Min((idx + 1) * colsPerThread, inputChannel.Width);
+            int w = x1 - x0;
+
+            for (int y = 0; y < inputResidualChannel.Height; y++)
+            {
+                int yLsh1 = y << 1;
+
+                Span<int> pResidual = inputResidualChannel.GetRow(y)[x0..];
+                Span<int> pAverage = inputChannel.GetRow(y)[x0..];
+                Span<int> pNAvg = inputChannel.GetRow(y + 1 < inputChannel.Height ? y + 1 : y)[x0..];
+                Span<int> pOut = outputChannel.GetRow(yLsh1)[x0..];
+                Span<int> pNOut = outputChannel.GetRow(yLsh1 + 1)[x0..];
+                Span<int> pPOut = y > 0 ? outputChannel.GetRow(yLsh1 - 1)[x0..] : pNAvg;
+                int x = 0;
+
+                for (; x + 7 < w; x += 8)
+                {
+                    FastUnsqueeze(
+                        pResidual[x..],
+                        pAverage[x..],
+                        pNAvg[x..],
+                        pPOut[x..],
+                        pOut[x..],
+                        pNOut[x..]);
+                }
+
+                // Remainder
+                for (; x < w; x++)
+                {
+                    int avg = pNAvg[x];
+                    int nextAvg = pNAvg[x];
+                    int top = pPOut[x];
+                    int tendency = SmoothTendency(top, avg, nextAvg);
+                    int diffMinusTendency = pResidual[x];
+                    int diff = diffMinusTendency + tendency;
+                    int output = avg + (diff >> 1);
+                    pOut[x] = output;
+                    pNOut[x] = output - diff;
+                }
+            }
+        });
+
+        if ((outputChannel.Height & 1) > 0)
+        {
+            int y = inputChannel.Height - 1;
+
+            Span<int> pAverage = inputChannel.GetRow(y);
+            Span<int> pOutput = outputChannel.GetRow(y << 1);
+
+            for (int x = 0; x < inputChannel.Width; x++)
+            {
+                pOutput[x] = pAverage[x];
+            }
+        }
+
+        input.Channels[c] = outputChannel;
+    }
+
+    public static void InverseSqueeze(Configuration configuration, JxlModularImage input, Span<JxlSqueezeParameters> parameters)
+    {
+        int totalNumberOfChannels = input.Channels.Count;
+
+        for (int i = parameters.Length - 1; i >= 0; i--)
+        {
+            ref JxlSqueezeParameters parameter = ref parameters[i];
+
+            CheckMetaSqueezeParameters(parameter, totalNumberOfChannels);
+
+            bool horizontal = parameter.Horizontal;
+            bool inPlace = parameter.InPlace;
+            int beginC = parameter.BeginC;
+            int endC = parameter.BeginC + parameter.NumC - 1;
+
+            int offset = inPlace
+                ? endC + 1
+                : totalNumberOfChannels + beginC + endC - 1;
+
+            if (beginC < input.MetaChannels)
+            {
+                if (input.MetaChannels <= parameter.NumC)
+                {
+                    throw new InvalidOperationException("Not enough meta channels");
+                }
+
+                input.MetaChannels -= parameter.NumC;
+            }
+
+            for (int c = beginC; c <= endC; c++)
+            {
+                int rc = offset + c - beginC;
+
+                if (rc >= totalNumberOfChannels)
+                {
+                    throw new InvalidOperationException("Residual channel offset out of bounds");
+                }
+
+                JxlModularChannel channelC = input.Channels[c]; // Input channel
+                JxlModularChannel channelRC = input.Channels[rc]; // Residual channel
+
+                if (channelC.Width < channelRC.Width || channelC.Height < channelRC.Height)
+                {
+                    throw new InvalidOperationException("Input channel width or height does not match residual channel width/height");
+                }
+
+                if (horizontal)
+                {
+                    InverseHorizontalSqueeze(configuration, input, c, rc);
+                }
+                else
+                {
+                    InverseVerticalSqueeze(configuration, input, c, rc);
+                }
+            }
+        }
+    }
+
+    public static void DefaultSqueezeParameters(List<JxlSqueezeParameters> squeezeParameters, JxlModularImage image)
+    {
+        int numberOfChannels = image.Channels.Count - image.MetaChannels;
+        squeezeParameters.Clear();
+
+        JxlModularChannel numMetaChannelsChannel = image.Channels[image.MetaChannels];
+        int w = numMetaChannelsChannel.Width;
+        int h = numMetaChannelsChannel.Height;
+        bool wide = w > h;
+
+        JxlModularChannel nextNumMetaChannelsChannel = image.Channels[image.MetaChannels + 1];
+
+        if (numberOfChannels > 2 && nextNumMetaChannelsChannel.Width == w && nextNumMetaChannelsChannel.Height == h)
+        {
+            JxlSqueezeParameters parameters = new()
+            {
+                Horizontal = true,
+                InPlace = false,
+                BeginC = image.MetaChannels + 1,
+                NumC = 2
+            };
+
+            squeezeParameters.Add(parameters);
+            parameters.Horizontal = false;
+            squeezeParameters.Add(parameters);
+        }
+
+        JxlSqueezeParameters newParameters = new()
+        {
+            BeginC = image.MetaChannels,
+            NumC = numberOfChannels,
+            InPlace = true
+        };
+
+        if (!wide)
+        {
+            if (h > MaxFirstPreviewSize)
+            {
+                newParameters.Horizontal = false;
+                squeezeParameters.Add(newParameters);
+                h = (h + 1) >> 1;
+            }
+        }
+
+        while (w > MaxFirstPreviewSize || h > MaxFirstPreviewSize)
+        {
+            if (w > MaxFirstPreviewSize)
+            {
+                newParameters.Horizontal = true;
+                squeezeParameters.Add(newParameters);
+                w = (w + 1) >> 1;
+            }
+
+            if (w > MaxFirstPreviewSize)
+            {
+                newParameters.Horizontal = false;
+                squeezeParameters.Add(newParameters);
+                h = (h + 1) >> 1;
+            }
+        }
+    }
+
+    private static void CheckMetaSqueezeParameters(in JxlSqueezeParameters parameter, int numChannels)
+    {
+        int c1 = parameter.BeginC;
+        int c2 = parameter.BeginC + parameter.NumC - 1;
+
+        if ((uint)c1 >= numChannels ||
+            (uint)c2 >= numChannels ||
+            c2 < c1)
+        {
+            throw new InvalidOperationException("Invalid channel range");
+        }
+    }
+
+    public static void MetaSqueeze(Configuration configuration, JxlModularImage image, List<JxlSqueezeParameters> parameters)
+    {
+        if (parameters.Count == 0)
+        {
+            DefaultSqueezeParameters(parameters, image);
+        }
+
+        foreach (JxlSqueezeParameters parameter in parameters)
+        {
+            CheckMetaSqueezeParameters(parameter, image.Channels.Count);
+
+            bool horizontal = parameter.Horizontal;
+            bool inPlace = parameter.InPlace;
+            int beginC = parameter.BeginC;
+            int endC = parameter.BeginC + parameter.NumC - 1;
+
+            if (beginC < image.MetaChannels)
+            {
+                if (endC >= image.MetaChannels)
+                {
+                    throw new InvalidOperationException("Invalid squeeze: mix of meta and nonmeta channels");
+                }
+
+                if (!inPlace)
+                {
+                    throw new InvalidOperationException("Invalid squeeze: meta channels require in-place residuals");
+                }
+
+                image.MetaChannels += parameter.NumC;
+            }
+
+            int offset = inPlace
+                ? endC + 1
+                : image.Channels.Count;
+
+            for (int c = beginC; c <= endC; c++)
+            {
+                JxlModularChannel channel = image.Channels[c];
+
+                if (channel.Height > 30 || channel.VerticalShift > 30)
+                {
+                    throw new InvalidOperationException("Too many squeezes: shift > 30");
+                }
+
+                int w = channel.Width;
+                int h = channel.Height;
+
+                if ((w & h) == 0) // either w, or h, is 0
+                {
+                    throw new InvalidOperationException("Squeezing empty channel");
+                }
+
+                if (horizontal)
+                {
+                    channel.Width = (w + 1) >> 1;
+
+                    if (channel.HorizontalShift >= 0)
+                    {
+                        channel.HorizontalShift++;
+                    }
+
+                    w -= (w + 1) >> 1;
+                }
+                else
+                {
+                    channel.HorizontalShift = (h + 1) >> 1;
+
+                    if (channel.VerticalShift >= 0)
+                    {
+                        channel.VerticalShift++;
+                    }
+
+                    h -= (h + 1) >> 1;
+                }
+
+                channel.Shrink(configuration);
+
+                JxlModularChannel placeholder = new(configuration, w, h, channel.HorizontalShift, channel.VerticalShift)
+                {
+                    Component = channel.Component
+                };
+
+                image.Channels.Insert(offset + (c - beginC), placeholder);
+            }
+        }
+    }
+
+    public static void ForwardHorizontalSqueeze(Configuration configuration, JxlModularImage input, int c, int rc)
+    {
+        JxlModularChannel inputChannel = input.Channels[c];
+
+        // Do not dispose these.
+        JxlModularChannel outputChannel = new(configuration, (inputChannel.Width + 1) >> 1, inputChannel.Height, inputChannel.HorizontalShift + 1, inputChannel.VerticalShift);
+        JxlModularChannel outputChannelResidual = new(configuration, inputChannel.Width - outputChannel.Width, outputChannel.Height, inputChannel.HorizontalShift + 1, inputChannel.VerticalShift);
+
+        outputChannel.Component = inputChannel.Component;
+        outputChannelResidual.Component = inputChannel.Component;
+
+        for (int y = 0; y < outputChannel.Height; y++)
+        {
+            Span<int> pIn = inputChannel.GetRow(y);
+            Span<int> pOut = outputChannel.GetRow(y);
+            Span<int> pRes = outputChannelResidual.GetRow(y);
+
+            for (int x = 0; x < outputChannelResidual.Width; x++)
+            {
+                int x2 = x << 1; // x * 2
+
+                int a = pIn[x2];
+                int b = pIn[x2 + 1];
+                int avg = Average(a, b);
+                pOut[x] = avg;
+                int diff = a - b;
+                int nextAvg = avg;
+
+                if (x + 1 < outputChannelResidual.Width)
+                {
+                    int c2 = pIn[x2 + 2]; // actually C, but 1. variable 'c' already defined 2. names should be camelCase
+                    int d = pIn[x2 + 3];
+
+                    nextAvg = Average(c2, d);
+                }
+                else if ((inputChannel.Width & 1) != 0)
+                {
+                    nextAvg = pIn[x2 + 2];
+                }
+
+                int left = x > 0 ? pIn[x2 - 1] : avg;
+                int tendency = SmoothTendency(left, avg, nextAvg);
+
+                pRes[x] = diff - tendency;
+            }
+
+            if ((inputChannel.Width & 1) != 0)
+            {
+                int x = outputChannel.Width - 1;
+                pOut[x] = pIn[x * 2];
+            }
+        }
+
+        input.Channels[c] = outputChannel;
+        input.Channels.Insert(rc, outputChannelResidual);
+    }
+
+    public static void ForwardVerticalSqueeze(Configuration configuration, JxlModularImage input, int c, int rc)
+    {
+        JxlModularChannel inputChannel = input.Channels[c];
+
+        // Do not dispose these.
+        JxlModularChannel outputChannel = new(configuration, inputChannel.Width, (inputChannel.Height + 1) >> 1, inputChannel.HorizontalShift, inputChannel.VerticalShift + 1);
+        JxlModularChannel outputResidualChannel = new(configuration, inputChannel.Width, inputChannel.Height - outputChannel.Height, inputChannel.HorizontalShift, inputChannel.VerticalShift + 1);
+
+        outputChannel.Component = inputChannel.Component;
+        outputResidualChannel.Component = inputChannel.Component;
+
+        int oneRowInput = inputChannel.Plane.PixelsPerRow;
+
+        for (int y = 0; y < outputChannel.Height; y++)
+        {
+            Span<int> pIn = inputChannel.GetRow(y * 2);
+            Span<int> pOut = outputChannel.GetRow(y);
+            Span<int> pResidual = outputResidualChannel.GetRow(y);
+
+            for (int x = 0; x < outputChannel.Width; x++)
+            {
+                int a = pIn[x];
+                int b = pIn[x + oneRowInput];
+                int avg = Average(a, b);
+                pOut[x] = avg;
+                int diff = a - b;
+                int nextAvg = avg;
+
+                if (y + 1 < outputResidualChannel.Height)
+                {
+                    int c2 = pIn[x + (2 * oneRowInput)]; // actually C, but 1. variable 'c' already defined 2. names should be camelCase
+                    int d = pIn[x + (3 * oneRowInput)];
+                    nextAvg = Average(c2, d);
+                }
+                else if ((inputChannel.Height & 1) != 0)
+                {
+                    nextAvg = pIn[x + (2 * oneRowInput)];
+                }
+
+                int top = y > 0 ? pIn[x - oneRowInput] : avg;
+                int tendency = SmoothTendency(top, avg, nextAvg);
+
+                pResidual[x] = diff - tendency;
+            }
+        }
+
+        if ((inputChannel.Height & 1) != 0)
+        {
+            int y = outputChannel.Height - 1;
+
+            Span<int> pIn = inputChannel.GetRow(y * 2);
+            Span<int> pOut = outputChannel.GetRow(y);
+
+            for (int x = 0; x < outputChannel.Width; x++)
+            {
+                pOut[x] = pIn[x];
+            }
+        }
+
+        input.Channels[c] = outputChannel;
+        input.Channels.Insert(rc, outputResidualChannel);
+    }
+
+    public static void ForwardSqueeze(Configuration configuration, JxlModularImage input, List<JxlSqueezeParameters> parameters)
+    {
+        if (parameters.Count == 0)
+        {
+            DefaultSqueezeParameters(parameters, input);
+
+            if (parameters.Count == 0)
+            {
+                // If there's nothing to do, don't squeeze.
+                return;
+            }
+        }
+
+        foreach (JxlSqueezeParameters parameter in parameters)
+        {
+            CheckMetaSqueezeParameters(parameter, input.Channels.Count);
+
+            bool horizontal = parameter.Horizontal;
+            bool inPlace = parameter.InPlace;
+            int beginC = parameter.BeginC;
+            int endC = parameter.BeginC + parameter.NumC - 1;
+
+            int offset = inPlace
+                ? endC + 1
+                : input.Channels.Count;
+
+            for (int c = beginC; c <= endC; c++)
+            {
+                if (horizontal)
+                {
+                    ForwardHorizontalSqueeze(configuration, input, c, offset + c - beginC);
+                }
+                else
+                {
+                    ForwardVerticalSqueeze(configuration, input, c, offset + c - beginC);
+                }
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlSqueezeParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlSqueezeParameters.cs
new file mode 100644
index 0000000000..1d4c332770
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlSqueezeParameters.cs
@@ -0,0 +1,74 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+/// <summary>
+/// Parameters for the squeeze transform.
+/// </summary>
+internal struct JxlSqueezeParameters : IJxlFields
+{
+    private bool horizontal;
+    private bool inPlace;
+    private int beginC;
+    private int numC;
+
+    public JxlSqueezeParameters() => JxlBundle.Init(this);
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the transform is horizontal.
+    /// </summary>
+    public bool Horizontal
+    {
+        readonly get => this.horizontal;
+        set => this.horizontal = value;
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the transform is in-place.
+    /// </summary>
+    public bool InPlace
+    {
+        readonly get => this.inPlace;
+        set => this.inPlace = value;
+    }
+
+    public int BeginC
+    {
+        readonly get => this.beginC;
+        set => this.beginC = value;
+    }
+
+    public int NumC
+    {
+        readonly get => this.numC;
+        set => this.numC = value;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (!visitor.Boolean(false, ref this.horizontal) ||
+            !visitor.Boolean(false, ref this.inPlace) ||
+            !visitor.U32(
+                JxlFieldExpressions.Bits(3),
+                JxlFieldExpressions.BitsOffset(6, 8),
+                JxlFieldExpressions.BitsOffset(10, 72),
+                JxlFieldExpressions.BitsOffset(13, 1096),
+                0,
+                ref this.beginC) ||
+            !visitor.U32(
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Value(2),
+                JxlFieldExpressions.Value(3),
+                JxlFieldExpressions.BitsOffset(4, 4),
+                2,
+                ref this.numC))
+        {
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlTransform.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlTransform.cs
new file mode 100644
index 0000000000..6d8c73f8f2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlTransform.cs
@@ -0,0 +1,136 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics.Tensors;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+internal sealed class JxlTransform : IJxlFields
+{
+    public JxlTransform()
+        : this(JxlTransformType.Invalid)
+    {
+    }
+
+    public JxlTransform(JxlTransformType id)
+    {
+        JxlBundle.Init(this);
+        this.TransformType = id;
+    }
+
+    public JxlTransformType TransformType { get; set; }
+
+    public int BeginC { get; set; }
+
+    public int RctType { get; set; }
+
+    public int NumC { get; set; }
+
+    public int Colors { get; set; }
+
+    public int Deltas { get; set; }
+
+    public List<JxlSqueezeParameters> Squeezes { get; set; } = [];
+
+    public int MaxDeltaError { get; set; }
+
+    public JxlPredictor Predictor { get; set; }
+
+    public bool OrderedPalette { get; set; } = true;
+
+    public bool LossyPalette { get; set; }
+
+    public bool Visit(JxlVisitor visitor) => throw new NotImplementedException();
+
+    public static void CheckEqualChannels(JxlModularImage image, int c1, int c2)
+    {
+        int channelsCount = image.Channels.Count;
+
+        if (c1 > channelsCount || c2 >= channelsCount || c2 < c1)
+        {
+            throw new InvalidOperationException($"Invalid channel range: {c1}..{c2} (there are only {channelsCount} channels)");
+        }
+
+        if (c1 < image.MetaChannels && c2 >= image.MetaChannels)
+        {
+            throw new InvalidOperationException("Invalid: transforming mix of meta and nonmeta");
+        }
+
+        JxlModularChannel ch1 = image.Channels[c1];
+        for (int c = c1 + 1; c <= c2; c++)
+        {
+            JxlModularChannel ch2 = image.Channels[c];
+            if (ch1.Width != ch2.Width ||
+                ch1.Height != ch2.Height ||
+                ch1.HorizontalShift != ch2.HorizontalShift ||
+                ch1.VerticalShift != ch2.VerticalShift)
+            {
+                throw new InvalidOperationException($"Channel {c} is not equal");
+            }
+        }
+    }
+
+    public static void ComputeMinMax(JxlModularChannel channel, out int min, out int max)
+    {
+        // Start with opposite bounds so the first iteration
+        // guarantees to set these values
+        min = int.MaxValue;
+        max = int.MinValue;
+
+        for (int y = 0; y < channel.Height; y++)
+        {
+            ReadOnlySpan<int> p = channel.GetRow(y);
+
+            int minRow = TensorPrimitives.Min(p);
+            int maxRow = TensorPrimitives.Max(p);
+
+            min = Math.Min(minRow, min);
+            max = Math.Max(maxRow, max);
+        }
+    }
+
+    public void Inverse(Configuration configuration, JxlModularImage input, JxlModularHeader wpHeader)
+    {
+        switch (this.TransformType)
+        {
+            case JxlTransformType.Rct:
+                JxlRct.InverseRct(configuration, input, this.BeginC, this.RctType);
+                break;
+
+            case JxlTransformType.Squeeze:
+                JxlSqueeze.InverseSqueeze(configuration, input, CollectionsMarshal.AsSpan(this.Squeezes));
+                break;
+
+            case JxlTransformType.Palette:
+                JxlPalette.InversePalette(configuration, input, this.BeginC, this.Colors, this.Deltas, this.Predictor, wpHeader);
+                break;
+
+            default:
+                throw new InvalidOperationException($"Unknown transform: {this.TransformType}");
+        }
+    }
+
+    public void MetaApply(Configuration configuration, JxlModularImage image)
+    {
+        switch (this.TransformType)
+        {
+            case JxlTransformType.Rct:
+                CheckEqualChannels(image, this.BeginC, this.BeginC + 2);
+                break;
+
+            case JxlTransformType.Squeeze:
+                JxlSqueeze.MetaSqueeze(configuration, image, this.Squeezes);
+                break;
+
+            case JxlTransformType.Palette:
+                JxlPalette.MetaPalette(configuration, image, this.BeginC, this.BeginC + this.NumC - 1, this.Colors, this.Deltas);
+                break;
+
+            default:
+                throw new InvalidOperationException($"Unknown transform: {this.TransformType}");
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlTransformType.cs b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlTransformType.cs
new file mode 100644
index 0000000000..0919425db1
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Modular/Transforms/JxlTransformType.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Transforms;
+
+/// <summary>
+/// Represents the type of a transform.
+/// </summary>
+internal enum JxlTransformType : byte
+{
+    /// <summary>
+    /// Reversible Color Transform
+    /// </summary>
+    Rct,
+
+    /// <summary>
+    /// Palette/indexed coding
+    /// </summary>
+    Palette,
+
+    /// <summary>
+    /// Haar-style squeezing
+    /// </summary>
+    Squeeze,
+
+    /// <summary>
+    /// Invalid/unknown
+    /// </summary>
+    Invalid
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseConstants.cs b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseConstants.cs
new file mode 100644
index 0000000000..87027aad94
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseConstants.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+/// <summary>
+/// Constants used by noise processing.
+/// </summary>
+internal static class JxlNoiseConstants
+{
+    public const float Precision = 1024f;
+    public const float NoiseLutMax = 1023.4999f / Precision;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseHelper.cs b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseHelper.cs
new file mode 100644
index 0000000000..1b6dfa2480
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseHelper.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+internal static class JxlNoiseHelper
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static JxlNoiseIndexAndFraction IndexAndFraction(float x)
+    {
+        const int scaleNumerator = JxlNoiseParameters.NoisePoints - 2;
+        const float scale = scaleNumerator / 1.0f;
+
+        float scaledX = MathF.Max(0f, x * scale);
+        float floorX = MathF.Floor(scaledX);
+        float fractionalX = scaledX - floorX;
+
+        if (scaledX >= scaleNumerator + 1)
+        {
+            floorX = scaleNumerator;
+            fractionalX = 1f;
+        }
+
+        return new((int)floorX, fractionalX);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseIndexAndFraction.cs b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseIndexAndFraction.cs
new file mode 100644
index 0000000000..fe18886a04
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseIndexAndFraction.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct JxlNoiseIndexAndFraction(int index, float fraction)
+{
+    public int Index = index;
+
+    public float Fraction = fraction;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseLevel.cs b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseLevel.cs
new file mode 100644
index 0000000000..836a0e3026
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseLevel.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct JxlNoiseLevel(float noiseLevel, float intensity)
+{
+    public float NoiseLevel = noiseLevel;
+
+    public float Intensity = intensity;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseParameters.cs
new file mode 100644
index 0000000000..9fef114a25
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Noise/JxlNoiseParameters.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Noise;
+
+internal sealed class JxlNoiseParameters
+{
+    public const int NoisePoints = 8;
+
+    public float[] Lookup { get; set; } = new float[NoisePoints];
+
+    public bool ContainsAny => this.Lookup.Any(x => MathF.Abs(x) > 1e-3f);
+
+    public void Clear() => this.Lookup.AsSpan().Clear();
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlAspectRatioHelpers.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlAspectRatioHelpers.cs
new file mode 100644
index 0000000000..6c69a8fff7
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlAspectRatioHelpers.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal static class JxlAspectRatioHelpers
+{
+    private static readonly SignedRational[] Ratios =
+    [
+        new(1, 1),
+        new(12, 10),
+        new(4, 3),
+        new(3, 2),
+        new(16, 9),
+        new(5, 4),
+        new(2, 1)
+    ];
+
+    public static SignedRational FixedAspectRatios(int ratio) => Ratios[ratio - 1];
+
+    public static int FindAspectRatio(int x, int y)
+    {
+        for (int i = 0; i < 7; i++)
+        {
+            if (x == MultiplyTruncate(Ratios[i], y))
+            {
+                return i;
+            }
+        }
+
+        return 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int MultiplyTruncate(SignedRational rational, int multiplicand) => (multiplicand * rational.Numerator) / rational.Denominator;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlBitDepth.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlBitDepth.cs
new file mode 100644
index 0000000000..a0f6765224
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlBitDepth.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Describes the interpretation of the input and output
+/// buffers.
+/// </summary>
+internal struct JxlBitDepth
+{
+    /// <summary>
+    /// Gets or sets the kind of bit depth.
+    /// </summary>
+    public JxlBitDepthType Type { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of bits per sample when the
+    /// bit depth type is custom.
+    /// </summary>
+    public uint BitsPerSample { get; set; }
+
+    /// <summary>
+    /// Gets or sets the custom exponent bits per sample.
+    /// </summary>
+    public uint ExponentBitsPerSample { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlBitDepthType.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlBitDepthType.cs
new file mode 100644
index 0000000000..754ac41010
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlBitDepthType.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Specifies the kind of bit depth.
+/// </summary>
+internal enum JxlBitDepthType : byte
+{
+    /// <summary>
+    /// Default setting, where the encoder expects the
+    /// input pixels to use the full range of the pixel format
+    /// data type (e.g. for ushort, the input range is 0..65535
+    /// and the value 65535 is mapped to 1.0 when converting
+    /// to float), and the decoder uses the full range to output
+    /// pixels.
+    /// </summary>
+    FromPixelFormat,
+
+    /// <summary>
+    /// When selected, the encoder expects the input pixels
+    /// to be in the range defined by the bits per sample value of the
+    /// basic info (e.g., for 12-bit images using ushort data types
+    /// the range is 0..4095 and the 4095 value is mapped to 1.0 when
+    /// converting to float), and the decoder outputs pixels in
+    /// this range.
+    /// </summary>
+    FromCodeStream,
+
+    /// <summary>
+    /// Specifies custom ranges for pixel outputs.
+    /// </summary>
+    Custom = 2,
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlFrameDimensions.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlFrameDimensions.cs
new file mode 100644
index 0000000000..7bd67326a3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlFrameDimensions.cs
@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal sealed class JxlFrameDimensions
+{
+    public const int BlockDimensions = 8;
+    public const int DctBlockSize = BlockDimensions * BlockDimensions;
+    public const int GroupDimensions = 256;
+    public const int GroupDimensionsInBlocks = GroupDimensions / BlockDimensions;
+
+    public JxlFrameDimensions(int xSizePixel, int ySizePixel, int groupSizeShift, int maxHorizontalShift, int maxVerticalShift, bool modularMode, int upsampling)
+    {
+        this.GroupDimension = (GroupDimensions >> 1) << groupSizeShift;
+        this.DcGroupDimension = this.GroupDimension * BlockDimensions;
+        this.XSizeUpsampled = xSizePixel;
+        this.YSizeUpsampled = ySizePixel;
+        this.XSize = JxlMath.DivCeil(xSizePixel, upsampling);
+        this.YSize = JxlMath.DivCeil(ySizePixel, upsampling);
+        this.XSizeBlocks = JxlMath.DivCeil(this.XSize, BlockDimensions << maxHorizontalShift) << maxHorizontalShift;
+        this.YSizeBlocks = JxlMath.DivCeil(this.YSize, BlockDimensions << maxVerticalShift) << maxVerticalShift;
+        this.XSizePadded = this.XSizeBlocks * BlockDimensions;
+        this.YSizePadded = this.YSizeBlocks * BlockDimensions;
+
+        if (modularMode)
+        {
+            this.XSizePadded = this.XSize;
+            this.YSizePadded = this.YSize;
+        }
+
+        this.XSizeUpsampledPadded = this.XSizePadded * upsampling;
+        this.YSizeUpsampledPadded = this.YSizePadded * upsampling;
+        this.XSizeGroups = JxlMath.DivCeil(this.XSize, GroupDimensions);
+        this.YSizeGroups = JxlMath.DivCeil(this.YSize, GroupDimensions);
+        this.XSizeDcGroups = JxlMath.DivCeil(this.XSizeBlocks, GroupDimensions);
+        this.YSizeDcGroups = JxlMath.DivCeil(this.YSizeBlocks, GroupDimensions);
+        this.NumGroups = this.XSizeGroups * this.YSizeGroups;
+        this.NumDcGroups = this.XSizeDcGroups * this.YSizeDcGroups;
+    }
+
+    public int XSize { get; set; }
+
+    public int YSize { get; set; }
+
+    public int XSizeUpsampled { get; set; }
+
+    public int YSizeUpsampled { get; set; }
+
+    public int XSizeUpsampledPadded { get; set; }
+
+    public int YSizeUpsampledPadded { get; set; }
+
+    public int XSizePadded { get; set; }
+
+    public int YSizePadded { get; set; }
+
+    public int XSizeBlocks { get; set; }
+
+    public int YSizeBlocks { get; set; }
+
+    public int XSizeGroups { get; set; }
+
+    public int YSizeGroups { get; set; }
+
+    public int XSizeDcGroups { get; set; }
+
+    public int YSizeDcGroups { get; set; }
+
+    public int NumGroups { get; set; }
+
+    public int NumDcGroups { get; set; }
+
+    public int GroupDimension { get; set; }
+
+    public int DcGroupDimension { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlHalfUtils.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlHalfUtils.cs
new file mode 100644
index 0000000000..49faab821a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlHalfUtils.cs
@@ -0,0 +1,178 @@
+// 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.Jxl.Processing.Primitives;
+
+internal static class JxlHalfUtils
+{
+    /*
+     * SIMD version of the following bit-twiddling implementation
+     * of float to Half conversion, because Vector<T> doesn't
+     * have a method like this (only reinterpretation, we want
+     * conversion).
+        public static ushort ConvertSingleToHalf(float f)
+        {
+            uint x = BitConverter.SingleToUInt32Bits(f);
+
+            uint sign = (x >> 16) & 0x8000; // sign bit
+            int exp = (int)((x >> 23) & 0xFF) - 127 + 15; // exponent rebias
+            uint mantissa = x & 0x007FFFFF; // mantissa bits
+
+            if (exp <= 0)
+            {
+                // Subnormal or zero
+                if (exp < -10)
+                {
+                    return (ushort)sign;
+                }
+
+                mantissa = (mantissa | 0x00800000) >> (1 - exp);
+                return (ushort)(sign | (mantissa >> 13));
+            }
+            else if (exp >= 31)
+            {
+                // Inf or NaN
+                return (ushort)(sign | 0x7C00 | (mantissa >> 13));
+            }
+            else
+            {
+                // Normalized
+                return (ushort)(sign | ((uint)exp << 10) | (mantissa >> 13));
+            }
+        }
+     */
+    public static Vector<ushort> ConvertSingleToHalf(Vector<float> f)
+    {
+        Vector<uint> x = f.As<float, uint>();
+
+        Vector<uint> sign = (x >> 16) & Vector.Create(0x8000u);
+        Vector<int> exponent = ((x >> 23) & Vector.Create(0xFFu)).As<uint, int>() - Vector.Create(127) + Vector.Create(15);
+        Vector<uint> mantissa = x & Vector.Create(0x007FFFFFu);
+
+        Vector<uint> results = Vector<uint>.Zero;
+
+        Vector<uint> lessThanMinus10 = Vector.LessThan(exponent, Vector.Create(-10)).As<int, uint>();
+        Vector<uint> gte31 = Vector.GreaterThanOrEqual(exponent, Vector.Create(31)).As<int, uint>();
+        Vector<uint> notLtMinus10OrGte31 = ~(lessThanMinus10 | gte31);
+
+        // Subnormal or zero (exp < -10) = sign
+        results = Vector.ConditionalSelect(lessThanMinus10, sign, results);
+
+        // exp <= 0 = (ushort)(sign | (((mantissa | 0x00800000) >> (1 - exp)) >> 13));
+        results = Vector.ConditionalSelect(
+            Vector.LessThanOrEqual(exponent, Vector<int>.Zero).As<int, uint>(),
+            sign | (ShiftRightAll(mantissa.As<uint, int>() | Vector.Create(0x00800000), Vector<int>.One - exponent) >> 13).As<int, uint>(),
+            results);
+
+        // exp >= 31 = (ushort)(sign | 0x7C00 | (mantissa >> 13))
+        results = Vector.ConditionalSelect(
+            gte31,
+            sign | Vector.Create(0x7C00u) | (mantissa >> 13),
+            results);
+
+        // anything else - normalized
+        results = Vector.ConditionalSelect(
+            notLtMinus10OrGte31,
+            sign | (exponent.As<int, uint>() << 10) | (mantissa >> 13),
+            results);
+
+        return VectorUInt32ToUInt16(results);
+    }
+
+    private static Vector<ushort> VectorUInt32ToUInt16(Vector<uint> uint32)
+    {
+        Vector<uint> clipped = uint32 & Vector.Create(0xFFFFu);
+        return clipped.As<uint, ushort>();
+    }
+
+    /// <summary>
+    /// Vectors don't support shifting right using shift value as vector.
+    /// This is a hack to do this.
+    /// </summary>
+    /// <typeparam name="T">Kind of vector</typeparam>
+    /// <param name="vec">Input vector</param>
+    /// <param name="shiftVec">Vectors with shift value for each corresponding item.</param>
+    /// <returns>Shifted vectors</returns>
+    private static Vector<T> ShiftRightAll<T>(Vector<T> vec, Vector<T> shiftVec)
+        where T : unmanaged, IShiftOperators<T, T, T>
+    {
+        Span<T> firstVec = stackalloc T[Vector<T>.Count];
+        Span<T> secondVec = stackalloc T[Vector<T>.Count];
+
+        vec.CopyTo(firstVec);
+        shiftVec.CopyTo(secondVec);
+
+        ref T firstRef = ref MemoryMarshal.GetReference(firstVec);
+        ref T secondRef = ref MemoryMarshal.GetReference(secondVec);
+
+        int count = Vector<T>.Count;
+
+        if (count == 1)
+        {
+            return Vector.Create(firstRef >>> secondRef);
+        }
+        else if (count == 2)
+        {
+            firstRef >>>= secondRef;
+            Unsafe.Add(ref firstRef, 1) >>>= Unsafe.Add(ref secondRef, 1);
+            return Vector.Create<T>(firstVec);
+        }
+        else if (count == 4)
+        {
+            firstRef >>>= secondRef;
+            Unsafe.Add(ref firstRef, 1) >>>= Unsafe.Add(ref secondRef, 1);
+            Unsafe.Add(ref firstRef, 2) >>>= Unsafe.Add(ref secondRef, 2);
+            Unsafe.Add(ref firstRef, 3) >>>= Unsafe.Add(ref secondRef, 3);
+            return Vector.Create<T>(firstVec);
+        }
+        else if (count == 8)
+        {
+            firstRef >>>= secondRef;
+            Unsafe.Add(ref firstRef, 1) >>>= Unsafe.Add(ref secondRef, 1);
+            Unsafe.Add(ref firstRef, 2) >>>= Unsafe.Add(ref secondRef, 2);
+            Unsafe.Add(ref firstRef, 3) >>>= Unsafe.Add(ref secondRef, 3);
+            Unsafe.Add(ref firstRef, 4) >>>= Unsafe.Add(ref secondRef, 4);
+            Unsafe.Add(ref firstRef, 5) >>>= Unsafe.Add(ref secondRef, 5);
+            Unsafe.Add(ref firstRef, 6) >>>= Unsafe.Add(ref secondRef, 6);
+            Unsafe.Add(ref firstRef, 7) >>>= Unsafe.Add(ref secondRef, 7);
+            return Vector.Create<T>(firstVec);
+        }
+        else if (count == 16)
+        {
+            firstRef >>>= secondRef;
+            Unsafe.Add(ref firstRef, 1) >>>= Unsafe.Add(ref secondRef, 1);
+            Unsafe.Add(ref firstRef, 2) >>>= Unsafe.Add(ref secondRef, 2);
+            Unsafe.Add(ref firstRef, 3) >>>= Unsafe.Add(ref secondRef, 3);
+            Unsafe.Add(ref firstRef, 4) >>>= Unsafe.Add(ref secondRef, 4);
+            Unsafe.Add(ref firstRef, 5) >>>= Unsafe.Add(ref secondRef, 5);
+            Unsafe.Add(ref firstRef, 6) >>>= Unsafe.Add(ref secondRef, 6);
+            Unsafe.Add(ref firstRef, 7) >>>= Unsafe.Add(ref secondRef, 7);
+            Unsafe.Add(ref firstRef, 8) >>>= Unsafe.Add(ref secondRef, 8);
+            Unsafe.Add(ref firstRef, 9) >>>= Unsafe.Add(ref secondRef, 9);
+            Unsafe.Add(ref firstRef, 10) >>>= Unsafe.Add(ref secondRef, 10);
+            Unsafe.Add(ref firstRef, 11) >>>= Unsafe.Add(ref secondRef, 11);
+            Unsafe.Add(ref firstRef, 12) >>>= Unsafe.Add(ref secondRef, 12);
+            Unsafe.Add(ref firstRef, 13) >>>= Unsafe.Add(ref secondRef, 13);
+            Unsafe.Add(ref firstRef, 14) >>>= Unsafe.Add(ref secondRef, 14);
+            Unsafe.Add(ref firstRef, 15) >>>= Unsafe.Add(ref secondRef, 15);
+            return Vector.Create<T>(firstVec);
+        }
+        else
+        {
+            // Vector too large, use a (slightly) slower loop
+            // instead of duplicating too much.
+            firstRef >>>= secondRef;
+
+            for (int i = 1; i < count; i++)
+            {
+                Unsafe.Add(ref firstRef, i) >>>= Unsafe.Add(ref secondRef, i);
+            }
+
+            return Vector.Create<T>(firstVec);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlInverseMtf.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlInverseMtf.cs
new file mode 100644
index 0000000000..18f9a55bdb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlInverseMtf.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Inverse Move to Front implementation
+/// </summary>
+internal static class JxlInverseMtf
+{
+    public static void MoveToFront(Span<byte> values, byte index)
+    {
+        byte value = values[index];
+
+        // CopyTo supports overlapping source and destination regions.
+        values[..index].CopyTo(values[1..]);
+        values[0] = value;
+    }
+
+    public static void InverseMoveToFrontTransform(Span<byte> values)
+    {
+        Span<byte> table = stackalloc byte[256];
+
+        for (int i = 0; i < table.Length; i++)
+        {
+            table[i] = (byte)i;
+        }
+
+        for (int i = 0; i < values.Length; i++)
+        {
+            byte index = values[i];
+            byte value = table[index];
+            values[i] = value;
+
+            if (index != 0)
+            {
+                // CopyTo handles the overlap and shifts the preceding entries.
+                table[..index].CopyTo(table[1..]);
+                table[0] = value;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlLehmerCode.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlLehmerCode.cs
new file mode 100644
index 0000000000..83e591fa9e
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlLehmerCode.cs
@@ -0,0 +1,106 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal static class JxlLehmerCode
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int ValueOfLowest1Bit(int n) => n & -n;
+
+    public static bool ComputeLehmerCode(ReadOnlySpan<uint> permutation, Span<uint> temp, int n, Span<uint> code)
+    {
+        temp[(n + 1)..].Clear();
+
+        for (int idx = 0; idx < n; idx++)
+        {
+            uint s = permutation[idx];
+
+            uint penalty = 0u;
+            uint i = s + 1u;
+
+            while (i != 0u)
+            {
+                penalty += temp[(int)i];
+                i &= i - 1u;    // Clear lowest bit
+            }
+
+            if (s < penalty)
+            {
+                return false;
+            }
+
+            code[idx] = s - penalty;
+            i = s + 1u;
+
+            while (i < n + 1u)
+            {
+                temp[(int)i]++;
+                i += (uint)ValueOfLowest1Bit((int)i);
+            }
+        }
+
+        return true;
+    }
+
+    public static bool DecodeLehmerCode(ReadOnlySpan<uint> code, Span<uint> temp, int n, Span<uint> permutation)
+    {
+        if (n == 0)
+        {
+            return false;
+        }
+
+        int log2n = JxlMath.CeilLog2Nonzero(n);
+        int paddedN = 1 << log2n;
+
+        for (int i = 0; i < paddedN; i++)
+        {
+            int i1 = i + 1;
+            temp[i] = (uint)ValueOfLowest1Bit(i1);
+        }
+
+        for (int i = 0; i < n; i++)
+        {
+            if (code[i] + i >= n)
+            {
+                return false;
+            }
+
+            uint rank = code[i] + 1;
+
+            int bit = paddedN;
+            int next = 0;
+
+            for (int b = 0; b <= log2n; b++)
+            {
+                int cand = next + bit;
+
+                if (cand < 1)
+                {
+                    return false;
+                }
+
+                bit >>= 1;
+
+                if (temp[cand - 1] < rank)
+                {
+                    next = cand;
+                    rank -= temp[cand - 1];
+                }
+            }
+
+            permutation[i] = unchecked((uint)next);
+
+            next++;
+            while (next <= paddedN)
+            {
+                temp[next - 1]--;
+                next += ValueOfLowest1Bit(next);
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlMatrix3x3.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlMatrix3x3.cs
new file mode 100644
index 0000000000..88454e1f69
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlMatrix3x3.cs
@@ -0,0 +1,142 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+
+#pragma warning disable IDE0044 // Add readonly modifier
+#pragma warning disable IDE0051 // Remove unused private members
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal struct JxlMatrix3x3
+{
+    /// <summary>
+    /// Represents the matrix element at 0,0.
+    /// </summary>
+    private double e00;
+
+    /// <summary>
+    /// Represents the matrix element at 0,1.
+    /// </summary>
+    private double e01;
+
+    /// <summary>
+    /// Represents the matrix element at 0,2.
+    /// </summary>
+    private double e02;
+
+    /// <summary>
+    /// Represents the matrix element at 1,0.
+    /// </summary>
+    private double e10;
+
+    /// <summary>
+    /// Represents the matrix element at 1,1.
+    /// </summary>
+    private double e11;
+
+    /// <summary>
+    /// Represents the matrix element at 1,2.
+    /// </summary>
+    private double e12;
+
+    /// <summary>
+    /// Represents the matrix element at 2,0.
+    /// </summary>
+    private double e20;
+
+    /// <summary>
+    /// Represents the matrix element at 2,1.
+    /// </summary>
+    private double e21;
+
+    /// <summary>
+    /// Represents the matrix element at 2,2.
+    /// </summary>
+    private double e22;
+
+    /// <summary>
+    /// Wraps all these values into a Span.
+    /// </summary>
+    /// <returns>A Span with all matrix elements.</returns>
+    public Span<double> AsSpan() => MemoryMarshal.CreateSpan(ref this.e00, 9);
+
+    /// <summary>
+    /// Wraps all these values into a ReadOnlySpan.
+    /// </summary>
+    /// <returns>A ReadOnlySpan with all matrix elements.</returns>
+    public ReadOnlySpan<double> AsReadOnlySpan() => MemoryMarshal.CreateReadOnlySpan(ref this.e00, 9);
+
+    public static void Multiply(in JxlMatrix3x3 a, in JxlMatrix3x3 b, ref JxlMatrix3x3 c)
+    {
+        ReadOnlySpan<double> spanA = a.AsReadOnlySpan();
+        ReadOnlySpan<double> spanB = b.AsReadOnlySpan();
+        Span<double> spanC = c.AsSpan();
+
+        for (int row = 0; row < 3; row++)
+        {
+            int row3 = row * 3;
+            for (int col = 0; col < 3; col++)
+            {
+                double sum = 0d;
+                for (int k = 0; k < 3; k++)
+                {
+                    sum += spanA[row3 + k] * spanB[(k * 3) + col];
+                }
+
+                spanC[row3 + col] = sum;
+            }
+        }
+    }
+
+    public static void Multiply(in JxlMatrix3x3 a, ReadOnlySpan<double> b, Span<double> c)
+    {
+        ReadOnlySpan<double> spanA = a.AsReadOnlySpan();
+
+        for (int row = 0; row < 3; row++)
+        {
+            double sum = 0f;
+            int row3 = row * 3;
+            for (int col = 0; col < 3; col++)
+            {
+                sum += spanA[row3 + col] * b[col];
+            }
+
+            c[row] = sum;
+        }
+    }
+
+    public static bool Invert(ref JxlMatrix3x3 matrix)
+    {
+        ReadOnlySpan<double> m = matrix.AsReadOnlySpan();
+        Span<double> temp =
+        [
+            ((double)m[4] * m[8]) - ((double)m[5] * m[7]),
+            ((double)m[2] * m[7]) - ((double)m[1] * m[8]),
+            ((double)m[1] * m[5]) - ((double)m[2] * m[4]),
+            ((double)m[5] * m[6]) - ((double)m[3] * m[8]),
+            ((double)m[0] * m[8]) - ((double)m[2] * m[6]),
+            ((double)m[2] * m[3]) - ((double)m[0] * m[5]),
+            ((double)m[3] * m[7]) - ((double)m[4] * m[6]),
+            ((double)m[1] * m[6]) - ((double)m[0] * m[7]),
+            ((double)m[0] * m[4]) - ((double)m[1] * m[3]),
+        ];
+
+        double det = (m[0] * temp[0]) + (m[1] * temp[3]) + (m[2] * temp[6]);
+
+        if (Math.Abs(det) < 1e-10)
+        {
+            return false;
+        }
+
+        double idet = 1.0 / det;
+        Span<double> spanM = matrix.AsSpan();
+
+        for (int i = 0; i < 9; i++)
+        {
+            spanM[i] = (double)(temp[i] * idet);
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlMatrix3x3F.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlMatrix3x3F.cs
new file mode 100644
index 0000000000..2d66df2729
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlMatrix3x3F.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+
+#pragma warning disable IDE0044 // Add readonly modifier
+#pragma warning disable IDE0052 // Remove unread private members
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal struct JxlMatrix3x3F
+{
+    /// <summary>
+    /// Represents the matrix element at 0,0.
+    /// </summary>
+    private float e00;
+
+    /// <summary>
+    /// Represents the matrix element at 0,1.
+    /// </summary>
+    private float e01;
+
+    /// <summary>
+    /// Represents the matrix element at 0,2.
+    /// </summary>
+    private float e02;
+
+    /// <summary>
+    /// Represents the matrix element at 1,0.
+    /// </summary>
+    private float e10;
+
+    /// <summary>
+    /// Represents the matrix element at 1,1.
+    /// </summary>
+    private float e11;
+
+    /// <summary>
+    /// Represents the matrix element at 1,2.
+    /// </summary>
+    private float e12;
+
+    /// <summary>
+    /// Represents the matrix element at 2,0.
+    /// </summary>
+    private float e20;
+
+    /// <summary>
+    /// Represents the matrix element at 2,1.
+    /// </summary>
+    private float e21;
+
+    /// <summary>
+    /// Represents the matrix element at 2,2.
+    /// </summary>
+    private float e22;
+
+    internal JxlMatrix3x3F(float[][] array)
+    {
+        this.e00 = array[0][0];
+        this.e01 = array[0][1];
+        this.e02 = array[0][2];
+        this.e10 = array[1][0];
+        this.e11 = array[1][1];
+        this.e12 = array[1][2];
+        this.e20 = array[2][0];
+        this.e21 = array[2][1];
+        this.e22 = array[2][2];
+    }
+
+    /// <summary>
+    /// Wraps all these values into a Span.
+    /// </summary>
+    /// <returns>A Span with all matrix elements.</returns>
+    public Span<float> AsSpan() => MemoryMarshal.CreateSpan(ref this.e00, 9);
+
+    /// <summary>
+    /// Wraps all these values into a ReadOnlySpan.
+    /// </summary>
+    /// <returns>A ReadOnlySpan with all matrix elements.</returns>
+    public ReadOnlySpan<float> AsReadOnlySpan() => MemoryMarshal.CreateReadOnlySpan(ref this.e00, 9);
+
+    public static void Multiply(in JxlMatrix3x3F a, in JxlMatrix3x3F b, ref JxlMatrix3x3F c)
+    {
+        ReadOnlySpan<float> spanA = a.AsReadOnlySpan();
+        ReadOnlySpan<float> spanB = b.AsReadOnlySpan();
+        Span<float> spanC = c.AsSpan();
+
+        for (int row = 0; row < 3; row++)
+        {
+            int row3 = row * 3;
+            for (int col = 0; col < 3; col++)
+            {
+                float sum = 0f;
+                for (int k = 0; k < 3; k++)
+                {
+                    sum += spanA[row3 + k] * spanB[(k * 3) + col];
+                }
+
+                spanC[row3 + col] = sum;
+            }
+        }
+    }
+
+    public static void Multiply(in JxlMatrix3x3F a, ReadOnlySpan<float> b, Span<float> c)
+    {
+        ReadOnlySpan<float> spanA = a.AsReadOnlySpan();
+
+        for (int row = 0; row < 3; row++)
+        {
+            float sum = 0f;
+            int row3 = row * 3;
+            for (int col = 0; col < 3; col++)
+            {
+                sum += spanA[row3 + col] * b[col];
+            }
+
+            c[row] = sum;
+        }
+    }
+
+    public static bool Invert(ref JxlMatrix3x3F matrix)
+    {
+        ReadOnlySpan<float> m = matrix.AsReadOnlySpan();
+        Span<double> temp =
+        [
+            ((double)m[4] * m[8]) - ((double)m[5] * m[7]),
+            ((double)m[2] * m[7]) - ((double)m[1] * m[8]),
+            ((double)m[1] * m[5]) - ((double)m[2] * m[4]),
+            ((double)m[5] * m[6]) - ((double)m[3] * m[8]),
+            ((double)m[0] * m[8]) - ((double)m[2] * m[6]),
+            ((double)m[2] * m[3]) - ((double)m[0] * m[5]),
+            ((double)m[3] * m[7]) - ((double)m[4] * m[6]),
+            ((double)m[1] * m[6]) - ((double)m[0] * m[7]),
+            ((double)m[0] * m[4]) - ((double)m[1] * m[3]),
+        ];
+
+        double det = (m[0] * temp[0]) + (m[1] * temp[3]) + (m[2] * temp[6]);
+
+        if (Math.Abs(det) < 1e-10)
+        {
+            return false;
+        }
+
+        double idet = 1.0 / det;
+        Span<float> spanM = matrix.AsSpan();
+
+        for (int i = 0; i < 9; i++)
+        {
+            spanM[i] = (float)(temp[i] * idet);
+        }
+
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOpsinInverseParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOpsinInverseParameters.cs
new file mode 100644
index 0000000000..4e51220296
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOpsinInverseParameters.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal static class JxlOpsinInverseParameters
+{
+    private const float M02 = 0.078f;
+    private const float M00 = 0.30f;
+    private const float M01 = 1.0f - M02 - M00;
+
+    private const float M12 = 0.078f;
+    private const float M10 = 0.23f;
+    private const float M11 = 1.0f - M12 - M10;
+
+    private const float M20 = 0.24342268924547819f;
+    private const float M21 = 0.20476744424496821f;
+    private const float M22 = 1.0f - M20 - M21;
+
+    private static readonly float[][] Matrix =
+    [
+        [M00, M01, M02],
+        [M10, M11, M12],
+        [M20, M21, M22]
+    ];
+
+    public static JxlMatrix3x3F GetOpsinAbsorbanceInverseMatrix()
+    {
+        JxlMatrix3x3F matrix = new(Matrix);
+        _ = JxlMatrix3x3F.Invert(ref matrix);
+        return matrix;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOverride.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOverride.cs
new file mode 100644
index 0000000000..c25f354046
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOverride.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Represents a boolean which can be overriden to be a default
+/// value.
+/// </summary>
+internal enum JxlOverride : sbyte
+{
+    /// <summary>
+    /// Specifies a true value.
+    /// </summary>
+    On = 1,
+
+    /// <summary>
+    /// Specifies a false value.
+    /// </summary>
+    Off = 0,
+
+    /// <summary>
+    /// Specifies a default value.
+    /// </summary>
+    Default = -1
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOverrideHelpers.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOverrideHelpers.cs
new file mode 100644
index 0000000000..a4e06edc17
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlOverrideHelpers.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Override utilities.
+/// </summary>
+internal static class JxlOverrideHelpers
+{
+    /// <summary>
+    /// Converts a boolean to an override.
+    /// </summary>
+    /// <param name="flag">Input boolean.</param>
+    /// <returns>
+    /// <see cref="JxlOverride.On"/> if true. Otherwise <see cref="JxlOverride.Off"/>.
+    /// </returns>
+    public static JxlOverride FromBoolean(bool flag) => flag ? JxlOverride.On : JxlOverride.Off;
+
+    /// <summary>
+    /// Converts an override to a boolean.
+    /// </summary>
+    /// <param name="override">The override.</param>
+    /// <param name="defaultValue">Default value.</param>
+    /// <returns>
+    /// If override is <see cref="JxlOverride.Default"/> returns <paramref name="defaultValue"/>.
+    /// Otherwise returns true if <see cref="JxlOverride.On"/>, false if <see cref="JxlOverride.Off"/>.
+    /// </returns>
+    public static bool ToBoolean(JxlOverride @override, bool defaultValue)
+    {
+        if (@override == JxlOverride.On)
+        {
+            return true;
+        }
+
+        if (@override == JxlOverride.Off)
+        {
+            return false;
+        }
+
+        return defaultValue;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlPackSigned.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlPackSigned.cs
new file mode 100644
index 0000000000..a4c2fec411
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlPackSigned.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Provides PackSigned and UnpackSigned methods.
+/// </summary>
+internal static class JxlPackSigned
+{
+    /// <summary>
+    /// Encodes non-negative (X) into (2 * X), negative (-X) into (2 * X - 1)
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint PackUnsigned(int x)
+    {
+        unchecked
+        {
+            uint value = (uint)x;
+            return (value << 1) ^ ((~value >> 31) - 1);
+        }
+    }
+
+    /// <summary>
+    /// Reverse to PackSigned, i.e. UnpackSigned(PackSigned(X)) == X.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int UnpackSigned(uint x)
+    {
+        unchecked
+        {
+            return (int)((x >> 1) ^ (((~x) & 1) - 1));
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlPixelFormat.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlPixelFormat.cs
new file mode 100644
index 0000000000..5e0d3ef22b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlPixelFormat.cs
@@ -0,0 +1,36 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Data type for the sample values per channel per pixel
+/// for the output buffer for pixels.
+/// </summary>
+internal struct JxlPixelFormat
+{
+    /// <summary>
+    /// Gets or sets the amount of channels available in a pixel buffer.
+    /// </summary>
+    public int Channels { get; set; }
+
+    /// <summary>
+    /// Gets or sets the data type of each channel.
+    /// </summary>
+    public JxlDataType DataType { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value that denotes whether multi-byte data types are represented in
+    /// big-endian or little-endian format. Applies to ushort
+    /// and float data types.
+    /// </summary>
+    public ByteOrder Endianness { get; set; }
+
+    /// <summary>
+    /// Gets or sets the alignment of scanlines to a multiple of
+    /// align bytes.
+    /// </summary>
+    public int Align { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlSpeedTier.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlSpeedTier.cs
new file mode 100644
index 0000000000..8cbc589a1b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlSpeedTier.cs
@@ -0,0 +1,76 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Defines how quickly or slowly to encode an image. Slower
+/// modes may take longer to encode the image but provide
+/// better compression, while faster modes skip many algorithms,
+/// therefore making compression faster, but at the same time,
+/// less efficient.
+/// </summary>
+internal enum JxlSpeedTier : sbyte
+{
+    /// <summary>
+    /// 🌍 Try multiple combinations of Glacier
+    /// flags for modular mode. Otherwise like Glacier.
+    /// </summary>
+    TectonicPlate = -1,
+
+    /// <summary>
+    /// 🧊 Learn a global tree in Modular mode.
+    /// </summary>
+    Glacier,
+
+    /// <summary>
+    /// 🐢 Turns on FindBestQuantizationHQ loop.
+    /// </summary>
+    Tortoise,
+
+    /// <summary>
+    /// 🐈 Turns on FindBestQuantization butteraugli loop.
+    /// </summary>
+    Kitten,
+
+    /// <summary>
+    /// 🐿️ Turns on dots, patches, and spline detection, as well as
+    /// context clustering. This is the default mode.
+    /// </summary>
+    Squirrel,
+
+    /// <summary>
+    /// 🐻 Turns on error diffusion and full AC strategy heuristics. This is the
+    /// equivalent of fast mode.
+    /// </summary>
+    Wombat,
+
+    /// <summary>
+    /// 🐰 Turns on simple heuristics for AC strategy, quant field,
+    /// gaborish by default, non-default color map, initial quant field,
+    /// and non-default Chroma from Luma.
+    /// </summary>
+    Hare,
+
+    /// <summary>
+    /// 🐆 Turns on clustering and enables coefficient reordering.
+    /// </summary>
+    Cheetah,
+
+    /// <summary>
+    /// 🦅 Turns off most encoder encoder features. Does context clustering.
+    /// For modular, uses fixed tree with Weighted predictor.
+    /// </summary>
+    Falcon,
+
+    /// <summary>
+    /// ⚡ Fastest possible setting for VarDCT. For Modular, uses fixed tree with
+    /// Gradient predictor.
+    /// </summary>
+    Thunder,
+
+    /// <summary>
+    /// ⚡ For VarDCT, same as Thunder. For Modular, no tree, Gradient predictor, fast histograms.
+    /// </summary>
+    Lightning
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSeparable5.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSeparable5.cs
new file mode 100644
index 0000000000..03c16de089
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSeparable5.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal struct JxlWeightsSeparable5
+{
+    // Don't make these a property so we can ref into them.
+    public InlineArray12<float> Horizontal;
+
+    public InlineArray12<float> Vertical;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSymmetric3.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSymmetric3.cs
new file mode 100644
index 0000000000..69cdc0395a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSymmetric3.cs
@@ -0,0 +1,52 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal sealed class JxlWeightsSymmetric3
+{
+    private InlineArray4<float> c;
+
+    private InlineArray4<float> r;
+
+    private InlineArray4<float> d;
+
+    public Vector128<float> GetCVector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.c[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public Vector128<float> GetRVector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.r[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public Vector128<float> GetDVector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.d[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public void SetC(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.c[0]);
+        vec.StoreUnsafe(ref first);
+    }
+
+    public void SetD(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.d[0]);
+        vec.StoreUnsafe(ref first);
+    }
+
+    public void SetR(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.r[0]);
+        vec.StoreUnsafe(ref first);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSymmetric5.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSymmetric5.cs
new file mode 100644
index 0000000000..7fb8977a50
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlWeightsSymmetric5.cs
@@ -0,0 +1,103 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal struct JxlWeightsSymmetric5
+{
+    public InlineArray4<float> C;
+
+    public InlineArray4<float> R;
+
+    public InlineArray4<float> R2;
+
+    public InlineArray4<float> D;
+
+    public InlineArray4<float> D2;
+
+    public InlineArray4<float> L;
+
+    public static InlineArray4<float> CreateVector4(float x)
+    {
+        InlineArray4<float> array = default;
+
+        array[0] = array[1] = array[2] = array[3] = x;
+
+        return array;
+    }
+
+    public readonly Vector128<float> GetCVector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.C[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public readonly Vector128<float> GetRVector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.R[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public readonly Vector128<float> GetR2Vector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.R2[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public readonly Vector128<float> GetDVector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.D[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public readonly Vector128<float> GetD2Vector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.D2[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public readonly Vector128<float> GetLVector()
+    {
+        ref float first = ref Unsafe.AsRef(in this.L[0]);
+        return Vector128.LoadUnsafe(ref first);
+    }
+
+    public readonly void SetC(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.C[0]);
+        vec.StoreUnsafe(ref first);
+    }
+
+    public readonly void SetD(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.D[0]);
+        vec.StoreUnsafe(ref first);
+    }
+
+    public readonly void SetD2(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.D2[0]);
+        vec.StoreUnsafe(ref first);
+    }
+
+    public readonly void SetR(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.R[0]);
+        vec.StoreUnsafe(ref first);
+    }
+
+    public readonly void SetR2(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.R2[0]);
+        vec.StoreUnsafe(ref first);
+    }
+
+    public readonly void SetL(Vector128<float> vec)
+    {
+        ref float first = ref Unsafe.AsRef(in this.L[0]);
+        vec.StoreUnsafe(ref first);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlXorShift.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlXorShift.cs
new file mode 100644
index 0000000000..e5b45f7344
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/JxlXorShift.cs
@@ -0,0 +1,60 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal sealed class JxlXorShift
+{
+    public const int Generators = 8;
+
+    private readonly ulong[] s0 = new ulong[8];
+    private readonly ulong[] s1 = new ulong[8];
+
+    public JxlXorShift(ulong seed)
+    {
+        this.s0[0] = SplitMix64(seed + 0x9E3779B97F4A7C15L);
+        this.s1[0] = SplitMix64(this.s0[0]);
+        for (int i = 1; i < 8; ++i)
+        {
+            this.s0[i] = SplitMix64(this.s1[i - 1]);
+            this.s1[i] = SplitMix64(this.s0[i]);
+        }
+    }
+
+    public JxlXorShift(uint seed1, uint seed2, uint seed3, uint seed4)
+    {
+        this.s0[0] = SplitMix64((((ulong)seed1 << 32) + seed2) + 0x9E3779B97F4A7C15uL);
+        this.s1[0] = SplitMix64((((ulong)seed3 << 32) + seed4) + 0x9E3779B97F4A7C15uL);
+        for (int i = 1; i < 8; ++i)
+        {
+            this.s0[i] = SplitMix64(this.s0[i - 1]);
+            this.s1[i] = SplitMix64(this.s1[i - 1]);
+        }
+    }
+
+    // TODO: SIMD
+    public void Fill(Span<ulong> randomBits)
+    {
+        for (int i = 0; i < 8; ++i)
+        {
+            ulong s1 = this.s0[i];
+            ulong s0 = this.s1[i];
+            ulong bits = s1 + s0;
+            this.s0[i] = s0;
+            s1 ^= s1 << 23;
+            randomBits[i] = bits;
+            s1 ^= s0 ^ (s1 >> 18) ^ (s0 >> 5);
+            this.s1[i] = s1;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong SplitMix64(ulong z)
+    {
+        z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9uL;
+        z = (z ^ (z >> 27)) * 0x94D049BB133111EBuL;
+        return z ^ (z >> 31);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/RectangleUtils.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/RectangleUtils.cs
new file mode 100644
index 0000000000..5226e7561a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/RectangleUtils.cs
@@ -0,0 +1,39 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+internal static class RectangleUtils
+{
+    public static int X0(this in Rectangle rect) => rect.X;
+
+    public static int Y0(this in Rectangle rect) => rect.Y;
+
+    public static int X1(this in Rectangle rect) => rect.X + rect.Width;
+
+    public static int Y1(this in Rectangle rect) => rect.Y + rect.Height;
+
+    public static Rectangle Extend(Rectangle curr, int border, Rectangle parent)
+    {
+        int newX0 = X0(in curr) > X0(in parent) + border ? X0(in curr) - border : X0(in parent);
+        int newY0 = Y0(in curr) > Y0(in parent) + border ? Y0(in curr) - border : Y0(in parent);
+        int newX1 = X1(in curr) + border > X1(in parent) ? X1(in parent) : X1(in curr) + border;
+        int newY1 = Y1(in curr) + border > Y1(in parent) ? Y1(in parent) : Y1(in curr) + border;
+
+        return new(newX0, newY0, newX1 - newX0, newY1 - newY0);
+    }
+
+    public static bool IsInside(this Rectangle a, Rectangle b) =>
+        a.X0() >= b.X0() &&
+        a.X1() <= b.X1() &&
+        a.Y0() >= b.Y0() &&
+        a.Y1() <= b.Y1();
+
+    public static Rectangle CreateRectangle(int xbegin, int ybegin, int xSizeMax, int ySizeMax, int xEnd, int yEnd)
+        => new(xbegin, ybegin, ClampedSize(xbegin, xSizeMax, xEnd), ClampedSize(ybegin, ySizeMax, yEnd));
+
+    private static int ClampedSize(int begin, int sizeMax, int end)
+        => begin + sizeMax <= end
+            ? sizeMax
+            : (end > begin ? end - begin : 0);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Primitives/Rng.cs b/src/ImageSharp/Formats/Jxl/Processing/Primitives/Rng.cs
new file mode 100644
index 0000000000..e11f243f8b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Primitives/Rng.cs
@@ -0,0 +1,87 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+/// <summary>
+/// Deterministic random number generator used for compatibility
+/// with JPEG XL.
+/// </summary>
+internal struct Rng
+{
+    private ulong s0;
+    private ulong s1;
+
+    public Rng(ulong seed)
+    {
+        this.s0 = 0x94D049BB133111EBUL;
+        this.s1 = 0xBF58476D1CE4E5B9UL + seed;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ulong Next()
+    {
+        ulong s1 = this.s0;
+        ulong s0 = this.s1;
+        ulong bits = s1 + s0;
+        this.s0 = s0;
+
+        s1 ^= s1 << 23;
+        s1 ^= s0 ^ (s1 >> 18) ^ (s0 >> 5);
+
+        this.s1 = s1;
+
+        return bits;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public long UniformI(long begin, long end) => (long)(this.Next() % (ulong)(end - begin)) + begin;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ulong UniformU(ulong begin, ulong end) => (this.Next() % (end - begin)) + begin;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float UniformF(float begin, float end)
+    {
+        uint u = (uint)(this.Next() >> (64 - 23)) | 0x3F800000u;
+        float f = BitConverter.UInt32BitsToSingle(u);
+
+        return ((end - begin) * (f - 1.0f)) + begin;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Bernoulli(float p) => this.UniformF(0, 1) < p;
+
+    internal readonly struct GeometricDistribution
+    {
+        public readonly float Value { get; }
+
+        public GeometricDistribution(float value) => this.Value = value;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static GeometricDistribution Make(float p) => new(1.0f / MathF.Log(1.0f - p));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public uint Geometric(in GeometricDistribution dist)
+    {
+        float f = this.UniformF(0, 1);
+        float invLog1mp = dist.Value;
+
+        float log = MathF.Log(1.0f - f) * invLog1mp;
+
+        return (uint)log;
+    }
+
+    public void Shuffle<T>(Span<T> span)
+    {
+        for (nuint i = 0; i + 1 < (nuint)span.Length; i++)
+        {
+            nuint a = (nuint)this.UniformU(i, (nuint)span.Length);
+            RuntimeUtility.Swap(ref span[(int)a], ref span[(int)i]);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlDequantMatrices.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlDequantMatrices.cs
new file mode 100644
index 0000000000..8841f0ceac
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlDequantMatrices.cs
@@ -0,0 +1,267 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// Contains matrices used to inverse quantize coefficients.
+/// </summary>
+internal sealed class JxlDequantMatrices
+{
+    /// <summary>
+    /// Sum(DotProduct(RequiredSizeX, RequiredSizeY)).
+    /// </summary>
+    private const int SumRequiredXY = 2056;
+
+    private const int TotalTableSize = SumRequiredXY * JxlFrameDimensions.DctBlockSize * 3;
+
+    /// <summary>
+    /// Contains weights &amp; multipliers for transforms used by the codec (e.g. DCT, identity, AFV).
+    /// </summary>
+    public static readonly JxlQuantizerEncoding[] Library = GetLibrary();
+
+    private uint computedMask;
+
+    /// <summary>
+    /// Storage for quantization.
+    /// </summary>
+    private readonly Memory<byte> tableStorage;
+
+    /// <summary>
+    /// Contains matrices for forward quantization.
+    /// </summary>
+    private readonly Memory<float> table;
+
+    /// <summary>
+    /// Contains matrices for inverse quantization.
+    /// </summary>
+    private readonly Memory<float> inverseTable;
+
+    /// <summary>
+    /// Quantization table for DC
+    /// </summary>
+    private InlineArray3<float> dcQuant;
+
+    /// <summary>
+    /// Inverse quantization table for DC
+    /// </summary>
+    private InlineArray3<float> inverseDcQuant;
+
+    /// <summary>
+    /// Table offsets.
+    /// </summary>
+    private readonly int[] tableOffsets = new int[JxlAcStrategy.NumberOfValidStrategies * 3];
+
+    /// <summary>
+    /// Quantizer encodings. Multiple may be used depending on the kind of transform.
+    /// </summary>
+    private JxlQuantizerEncoding[] encodings = [];
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlDequantMatrices"/> class.
+    /// </summary>
+    public JxlDequantMatrices()
+    {
+        // float dc_quant_[3] = {kDCQuant[0], kDCQuant[1], kDCQuant[2]};
+        // float inv_dc_quant_[3] = {kInvDCQuant[0], kInvDCQuant[1], kInvDCQuant[2]};
+        this.dcQuant[0] = JxlQuantizerConstants.DcQuant[0];
+        this.dcQuant[1] = JxlQuantizerConstants.DcQuant[1];
+        this.dcQuant[2] = JxlQuantizerConstants.DcQuant[2];
+
+        this.inverseDcQuant[0] = JxlQuantizerConstants.InverseDcQuant[0];
+        this.inverseDcQuant[1] = JxlQuantizerConstants.InverseDcQuant[1];
+        this.inverseDcQuant[2] = JxlQuantizerConstants.InverseDcQuant[2];
+
+        this.encodings = new JxlQuantizerEncoding[JxlQuantizerConstants.NumberOfQuantizerTables];
+        for (int i = 0; i < this.encodings.Length; i++)
+        {
+            this.encodings[i] = JxlQuantizerEncoding.Library(0);
+        }
+
+        int pos = 0;
+        Span<int> offsets = stackalloc int[JxlQuantizerConstants.NumberOfQuantizerTables * 3];
+
+        for (int i = 0; i < JxlQuantizerConstants.NumberOfQuantizerTables; i++)
+        {
+            int numBlocks = RequiredSizeX[i] * RequiredSizeY[i];
+            int num = numBlocks * JxlFrameDimensions.DctBlockSize;
+            int i3 = 3 * i;
+
+            for (int c = 0; c < 3; c++)
+            {
+                offsets[i3 + c] = pos + (c * num);
+            }
+
+            pos += 3 * num;
+        }
+
+        for (int i = 0; i < JxlAcStrategy.NumberOfValidStrategies; i++)
+        {
+            for (int c = 0; c < 3; c++)
+            {
+                this.tableOffsets[(i * 3) + c] = offsets[((int)JxlQuantizerConstants.AcStrategyToQuantTableMap[i] * 3) + c];
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets a lookup which represents required widths for each quantizer.
+    /// </summary>
+    public static ReadOnlySpan<int> RequiredSizeX => [1, 1, 1, 1, 2, 4, 1, 1, 2, 1, 1, 8, 4, 16, 8, 32, 16];
+
+    /// <summary>
+    /// Gets a lookup which represents required heights for each quantizer.
+    /// </summary>
+    public static ReadOnlySpan<int> RequiredSizeY => [1, 1, 1, 1, 2, 4, 2, 4, 4, 1, 1, 8, 8, 16, 16, 32, 32];
+
+    /// <summary>
+    /// Returns the default library with quantizer encodings for all transforms
+    /// used by the JPEG XL codec.
+    /// </summary>
+    /// <returns>Encodings for all kinds of transforms.</returns>
+    /// <exception cref="InvalidOperationException">Used when quantization constants were partially updated.</exception>
+    public static JxlQuantizerEncoding[] GetLibrary()
+    {
+        if (JxlQuantizerConstants.NumberOfQuantizerTables != 17)
+        {
+            throw new InvalidOperationException("This function should be updated when adding new quantization types");
+        }
+
+        if (JxlQuantWeights.NumPredefinedTables != 1)
+        {
+            throw new InvalidOperationException("This function should be updated when adding new quantization matrices to the library");
+        }
+
+        Verify(0, JxlQuantTable.DCT);
+        Verify(1, JxlQuantTable.IDENTITY);
+        Verify(2, JxlQuantTable.DCT2X2);
+        Verify(3, JxlQuantTable.DCT4X4);
+        Verify(4, JxlQuantTable.DCT16X16);
+        Verify(5, JxlQuantTable.DCT32X32);
+        Verify(6, JxlQuantTable.DCT8X16);
+        Verify(7, JxlQuantTable.DCT8X32);
+        Verify(8, JxlQuantTable.DCT16X32);
+        Verify(9, JxlQuantTable.DCT4X8);
+        Verify(10, JxlQuantTable.AFV0);
+        Verify(11, JxlQuantTable.DCT64X64);
+        Verify(12, JxlQuantTable.DCT32X64);
+        Verify(13, JxlQuantTable.DCT128X128);
+        Verify(14, JxlQuantTable.DCT64X128);
+        Verify(15, JxlQuantTable.DCT256X256);
+        Verify(16, JxlQuantTable.DCT128X256);
+
+        return
+        [
+            JxlQuantWeights.Dct,
+            JxlQuantWeights.Identity,
+            JxlQuantWeights.Dct2x2,
+            JxlQuantWeights.Dct4x4,
+            JxlQuantWeights.Dct16x16,
+            JxlQuantWeights.Dct32x32,
+            JxlQuantWeights.Dct8x16,
+            JxlQuantWeights.Dct8x32,
+            JxlQuantWeights.Dct16x32,
+            JxlQuantWeights.Dct4x8,
+            JxlQuantWeights.Afv,
+            JxlQuantWeights.Dct64x64,
+            JxlQuantWeights.Dct32x32,
+            JxlQuantWeights.Dct128x128,
+            JxlQuantWeights.Dct64x128,
+            JxlQuantWeights.Dct256x256,
+            JxlQuantWeights.Dct128x256
+        ];
+
+        [Conditional("DEBUG")]
+        static void Verify(int expected, JxlQuantTable actual)
+        {
+            if (expected != (byte)actual)
+            {
+                throw new InvalidOperationException("Quantizer modes were partially updated; this method needs to be updated too");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Returns a matrix for the specified kind of quantizer and index.
+    /// </summary>
+    /// <param name="quantKind">Quantizer kind</param>
+    /// <param name="c">Index</param>
+    /// <returns>Matrix</returns>
+    public Span<float> GetMatrix(JxlAcStrategyType quantKind, int c)
+    {
+        DebugGuard.MustBeGreaterThan((1 << (int)quantKind) & this.computedMask, 0, nameof(quantKind));
+        return this.table.Span[this.tableOffsets[((int)quantKind * 3) + c]..];
+    }
+
+    /// <summary>
+    /// Returns an inverse matrix for the specified kind of quantizer and index.
+    /// </summary>
+    /// <param name="quantKind">Quantizer kind</param>
+    /// <param name="c">Index</param>
+    /// <returns>Inverse matrix</returns>
+    public Span<float> GetInverseMatrix(JxlAcStrategyType quantKind, int c)
+    {
+        DebugGuard.MustBeGreaterThan((1 << (int)quantKind) & this.computedMask, 0, nameof(quantKind));
+        return this.inverseTable.Span[this.tableOffsets[((int)quantKind * 3) + c]..];
+    }
+
+    /// <summary>
+    /// Returns a DC quant for index c.
+    /// </summary>
+    /// <param name="c">The DC quantizer index.</param>
+    /// <returns>DC quant for index <paramref name="c"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float GetDcQuant(int c) => this.dcQuant[c];
+
+    /// <summary>
+    /// Returns all DC quantizers. See also <seealso cref="GetDcQuant(int)"/>.
+    /// </summary>
+    /// <returns>Span that covers all DC quantizers.</returns>
+    public Span<float> GetDcQuants() => this.dcQuant;
+
+    /// <summary>
+    /// Returns an inverse DC quant for index c.
+    /// </summary>
+    /// <param name="c">The inverse DC quantizer index.</param>
+    /// <returns>Inverse DC quant for index <paramref name="c"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float GetInverseDcQuant(int c) => this.inverseDcQuant[c];
+
+    /// <summary>
+    /// Applies the specified DC quantizer.
+    /// </summary>
+    /// <param name="dc">DC quantizer to apply to the dequantization matrices.</param>
+    public void SetDcQuant(InlineArray3<float> dc)
+    {
+        for (int c = 0; c < 3; c++)
+        {
+            this.dcQuant[c] = 1f / dc[c];
+            this.inverseDcQuant[c] = dc[c];
+        }
+    }
+
+    /// <summary>
+    /// Sets custom quantizer encodings for transform functions.
+    /// </summary>
+    /// <param name="encodings">The encodings to identify required transform functions.</param>
+    public void SetEncodings(JxlQuantizerEncoding[] encodings)
+    {
+        this.encodings = encodings;
+        this.computedMask = 0;
+    }
+
+    /// <summary>
+    /// Returns quantizer encodings for this dequant matrices instance.
+    /// </summary>
+    /// <returns>
+    /// Encodings set by the <see cref="SetEncodings(JxlQuantizerEncoding[])"/> method.
+    /// By default (when the aforementioned method wasn't invoked), the result
+    /// is simply an empty span.
+    /// </returns>
+    public Span<JxlQuantizerEncoding> GetEncodings() => this.encodings;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantMode.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantMode.cs
new file mode 100644
index 0000000000..412dd245d3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantMode.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// Specifies which algorithm should be used to quantize coefficients.
+/// </summary>
+internal enum JxlQuantMode : byte
+{
+    /// <summary>
+    /// The quantizer relies on predefined tables for quantization.
+    /// The idea is similar to Huffman coding.
+    /// </summary>
+    Library,
+
+    /// <summary>
+    /// The quantizer uses an Identity transform.
+    /// </summary>
+    Id,
+
+    /// <summary>
+    /// The quantizer uses a 2x2 Discrete Cosine Transform.
+    /// </summary>
+    Dct2,
+
+    /// <summary>
+    /// The quantizer uses a 4x4 Discrete Cosine Transform.
+    /// </summary>
+    Dct4,
+
+    /// <summary>
+    /// The quantizer uses a 4x8 Discrete Cosine Transform.
+    /// </summary>
+    Dct4x8,
+
+    /// <summary>
+    /// The quantizer uses the AFV transform.
+    /// </summary>
+    Afv,
+
+    /// <summary>
+    /// The quantizer uses a Discrete Cosine Transform with custom block size.
+    /// </summary>
+    Dct,
+
+    /// <summary>
+    /// No quantization is performed. Input data becomes the output as-is.
+    /// </summary>
+    Raw
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantTable.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantTable.cs
new file mode 100644
index 0000000000..dca689b88f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantTable.cs
@@ -0,0 +1,47 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// Specifies which quantization table to use depending on
+/// transform &amp; block type.
+/// </summary>
+internal enum JxlQuantTable : byte
+{
+    DCT = 0,
+    IDENTITY,
+    DCT2X2,
+    DCT4X4,
+    DCT16X16,
+    DCT32X32,
+
+    // DCT16X8
+    DCT8X16,
+
+    // DCT32X8
+    DCT8X32,
+
+    // DCT32X16
+    DCT16X32,
+    DCT4X8,
+
+    // DCT8X4
+    AFV0,
+
+    // AFV1
+    // AFV2
+    // AFV3
+    DCT64X64,
+
+    // DCT64X32,
+    DCT32X64,
+    DCT128X128,
+
+    // DCT128X64,
+    DCT64X128,
+    DCT256X256,
+
+    // DCT256X128,
+    DCT128X256
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantWeights.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantWeights.cs
new file mode 100644
index 0000000000..94aab143af
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantWeights.cs
@@ -0,0 +1,1229 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Numerics;
+using System.Numerics.Tensors;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+internal static class JxlQuantWeights
+{
+    public const int MaxQuantTableSize = JxlAcStrategy.MaximumCoefficientArea;
+
+    public const int NumPredefinedTables = 1;
+
+    public const int CeilLog2NumPredefinedTables = 0;
+
+    public const int Log2NumQuantModes = 3;
+
+    private const float AlmostZero = 1e-8f;
+
+    /// <summary>
+    /// DCT quantizer encoding. (6 distance bands)
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [3150f, 0f, -0.4f, -0.4f, -0.4f, -2f],
+                [560f, 0f, -0.3f, -0.3f, -0.3f, -0.3f],
+                [512f, -2f, -1f, 0f, -1f, -2f]
+            ],
+            6));
+
+    /// <summary>
+    /// Identity quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Identity = JxlQuantizerEncoding.Identity(
+        [
+            [280f, 3160f, 3160f],
+            [60f, 864f, 864f],
+            [18f, 200f, 200f],
+        ]);
+
+    /// <summary>
+    /// DCT2X2 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct2x2 = JxlQuantizerEncoding.Dct2(
+        [
+            [3840f, 2560f, 1280f, 640f, 480f, 300f],
+            [960f, 640f, 320f, 180f, 140f, 120f],
+            [640f, 320f, 128f, 64f, 32f, 16f],
+        ]);
+
+    /// <summary>
+    /// DCT4X4 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct4x4 = JxlQuantizerEncoding.Dct4(
+        new JxlDctQuantWeightParameters(
+            [
+                [2200, 0, 0, 0],
+                [392, 0, 0, 0],
+                [112, -0.25f, -0.25f, -0.5f]
+            ],
+            4),
+        [
+            [1, 1],
+            [1, 1],
+            [1, 1]
+        ]);
+
+    /// <summary>
+    /// DCT16x16 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct16x16 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    8996.8725711814115328f,
+                    -1.3000777393353804f,
+                    -0.49424529824571225f,
+                    -0.439093774457103443f,
+                    -0.6350101832695744f,
+                    -0.90177264050827612f,
+                    -1.6162099239887414f,
+                ],
+                [
+                    3191.48366296844234752f,
+                    -0.67424582104194355f,
+                    -0.80745813428471001f,
+                    -0.44925837484843441f,
+                    -0.35865440981033403f,
+                    -0.31322389111877305f,
+                    -0.37615025315725483f,
+                ],
+                [
+                    1157.50408145487200256f,
+                    -2.0531423165804414f,
+                    -1.4f,
+                    -0.50687130033378396f,
+                    -0.42708730624733904f,
+                    -1.4856834539296244f,
+                    -4.9209142884401604f,
+                ]
+            ],
+            7));
+
+    /// <summary>
+    /// DCT32x32 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct32x32 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    15718.40830982518931456f,
+                    -1.025f,
+                    -0.98f,
+                    -0.9012f,
+                    -0.4f,
+                    -0.48819395464f,
+                    -0.421064f,
+                    -0.27f,
+                ],
+                [
+                    7305.7636810695983104f,
+                    -0.8041958212306401f,
+                    -0.7633036457487539f,
+                    -0.55660379990111464f,
+                    -0.49785304658857626f,
+                    -0.43699592683512467f,
+                    -0.40180866526242109f,
+                    -0.27321683125358037f,
+                ],
+                [
+                    3803.53173721215041536f,
+                    -3.060733579805728f,
+                    -2.0413270132490346f,
+                    -2.0235650159727417f,
+                    -0.5495389509954993f,
+                    -0.4f,
+                    -0.4f,
+                    -0.3f,
+                ]
+            ],
+            7));
+
+    /// <summary>
+    /// DCT8x16 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct8x16 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    7240.7734393502f,
+                    -0.7f,
+                    -0.7f,
+                    -0.2f,
+                    -0.2f,
+                    -0.2f,
+                    -0.5f,
+                ],
+                [
+                    1448.15468787004f,
+                    -0.5f,
+                    -0.5f,
+                    -0.5f,
+                    -0.2f,
+                    -0.2f,
+                    -0.2f,
+                ],
+                [
+                    506.854140754517f,
+                    -1.4f,
+                    -0.2f,
+                    -0.5f,
+                    -0.5f,
+                    -1.5f,
+                    -3.6f,
+                ]
+            ],
+            7));
+
+    /// <summary>
+    /// DCT8x32 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct8x32 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    16283.2494710648897f,
+                    -1.7812845336559429f,
+                    -1.6309059012653515f,
+                    -1.0382179034313539f,
+                    -0.85f,
+                    -0.7f,
+                    -0.9f,
+                    -1.2360638576849587f,
+                ],
+                [
+                    5089.15750884921511936f,
+                    -0.320049391452786891f,
+                    -0.35362849922161446f,
+                    -0.30340000000000003f,
+                    -0.61f,
+                    -0.5f,
+                    -0.5f,
+                    -0.6f,
+                ],
+                [
+                    3397.77603275308720128f,
+                    -0.321327362693153371f,
+                    -0.34507619223117997f,
+                    -0.70340000000000003f,
+                    -0.9f,
+                    -1.0f,
+                    -1.0f,
+                    -1.1754605576265209f,
+                ]
+            ],
+            8));
+
+    /// <summary>
+    /// DCT16x32 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct16x32 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    13844.97076442300573f,
+                    -0.97113799999999995f,
+                    -0.658f,
+                    -0.42026f,
+                    -0.22712f,
+                    -0.2206f,
+                    -0.226f,
+                    -0.6f,
+                ],
+                [
+                    4798.964084220744293f,
+                    -0.61125308982767057f,
+                    -0.83770786552491361f,
+                    -0.79014862079498627f,
+                    -0.2692727459704829f,
+                    -0.38272769465388551f,
+                    -0.22924222653091453f,
+                    -0.20719098826199578f,
+                ],
+                [
+                    1807.236946760964614f,
+                    -1.2f,
+                    -1.2f,
+                    -0.7f,
+                    -0.7f,
+                    -0.7f,
+                    -0.4f,
+                    -0.5f,
+                ]
+            ],
+            8));
+
+    /// <summary>
+    /// DCT4x8 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct4x8 = JxlQuantizerEncoding.Dct4x8(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    2198.050556016380522f,
+                    -0.96269623020744692f,
+                    -0.76194253026666783f,
+                    -0.6551140670773547f
+                ],
+                [
+                    764.3655248643528689f,
+                    -0.92630200888366945f,
+                    -0.9675229603596517f,
+                    -0.27845290869168118f
+                ],
+                [
+                    527.107573587542228f,
+                    -1.4594385811273854f,
+                    -1.450082094097871593f,
+                    -1.5843722511996204f
+                ]
+            ],
+            4),
+        [1, 1, 1]);
+
+    /// <summary>
+    /// AFV quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Afv = JxlQuantizerEncoding.Afv(
+        Dct4x8.DctParameters!,
+        Dct4x4.DctParameters!,
+        [
+            [3072, 3072, 256, 256, 256, 414, 0, 0, 0],
+            [1024, 1024, 50, 50, 50, 58, 0, 0, 0],
+            [384, 384, 12, 12, 12, 22, -0.25f, -0.25f, -0.25f]
+        ]);
+
+    /// <summary>
+    /// DCT64x64 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct64x64 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    0.9f * 26629.073922049845f,
+                    -1.025f,
+                    -0.78f,
+                    -0.65012f,
+                    -0.19041574084286472f,
+                    -0.20819395464f,
+                    -0.421064f,
+                    -0.32733845535848671f,
+                ],
+                [
+                    0.9f * 9311.3238710010046f,
+                    -0.3041958212306401f,
+                    -0.3633036457487539f,
+                    -0.35660379990111464f,
+                    -0.3443074455424403f,
+                    -0.33699592683512467f,
+                    -0.30180866526242109f,
+                    -0.27321683125358037f,
+                ],
+                [
+                    0.9f * 4992.2486445538634f,
+                    -1.2f,
+                    -1.2f,
+                    -0.8f,
+                    -0.7f,
+                    -0.7f,
+                    -0.4f,
+                    -0.5f,
+                ]
+            ],
+            8));
+
+    /// <summary>
+    /// DCT32x64 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct32x64 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    0.65f * 23629.073922049845f,
+                    -1.025f,
+                    -0.78f,
+                    -0.65012f,
+                    -0.19041574084286472f,
+                    -0.20819395464f,
+                    -0.421064f,
+                    -0.32733845535848671f,
+                ],
+                [
+                    0.65f * 8611.3238710010046f,
+                    -0.3041958212306401f,
+                    -0.3633036457487539f,
+                    -0.35660379990111464f,
+                    -0.3443074455424403f,
+                    -0.33699592683512467f,
+                    -0.30180866526242109f,
+                    -0.27321683125358037f,
+                ],
+                [
+                    0.65f * 4492.2486445538634f,
+                    -1.2f,
+                    -1.2f,
+                    -0.8f,
+                    -0.7f,
+                    -0.7f,
+                    -0.4f,
+                    -0.5f,
+                ]
+            ],
+            8));
+
+    /// <summary>
+    /// DCT128x128 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct128x128 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    1.8f * 26629.073922049845f,
+                    -1.025f,
+                    -0.78f,
+                    -0.65012f,
+                    -0.19041574084286472f,
+                    -0.20819395464f,
+                    -0.421064f,
+                    -0.32733845535848671f,
+                ],
+                [
+                    1.8f * 9311.3238710010046f,
+                    -0.3041958212306401f,
+                    -0.3633036457487539f,
+                    -0.35660379990111464f,
+                    -0.3443074455424403f,
+                    -0.33699592683512467f,
+                    -0.30180866526242109f,
+                    -0.27321683125358037f,
+                ],
+                [
+                    1.8f * 4992.2486445538634f,
+                    -1.2f,
+                    -1.2f,
+                    -0.8f,
+                    -0.7f,
+                    -0.7f,
+                    -0.4f,
+                    -0.5f,
+                ]
+            ],
+            8));
+
+    /// <summary>
+    /// DCT64x128 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct64x128 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    1.3f * 23629.073922049845f,
+                    -1.025f,
+                    -0.78f,
+                    -0.65012f,
+                    -0.19041574084286472f,
+                    -0.20819395464f,
+                    -0.421064f,
+                    -0.32733845535848671f,
+                ],
+                [
+                    1.3f * 8611.3238710010046f,
+                    -0.3041958212306401f,
+                    -0.3633036457487539f,
+                    -0.35660379990111464f,
+                    -0.3443074455424403f,
+                    -0.33699592683512467f,
+                    -0.30180866526242109f,
+                    -0.27321683125358037f,
+                ],
+                [
+                    1.3f * 4492.2486445538634f,
+                    -1.2f,
+                    -1.2f,
+                    -0.8f,
+                    -0.7f,
+                    -0.7f,
+                    -0.4f,
+                    -0.5f,
+                ]
+            ],
+            8));
+
+    /// <summary>
+    /// DCT256x256 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct256x256 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    3.6f * 26629.073922049845f,
+                    -1.025f,
+                    -0.78f,
+                    -0.65012f,
+                    -0.19041574084286472f,
+                    -0.20819395464f,
+                    -0.421064f,
+                    -0.32733845535848671f,
+                ],
+                [
+                    3.6f * 9311.3238710010046f,
+                    -0.3041958212306401f,
+                    -0.3633036457487539f,
+                    -0.35660379990111464f,
+                    -0.3443074455424403f,
+                    -0.33699592683512467f,
+                    -0.30180866526242109f,
+                    -0.27321683125358037f,
+                ],
+                [
+                    3.6f * 4992.2486445538634f,
+                    -1.2f,
+                    -1.2f,
+                    -0.8f,
+                    -0.7f,
+                    -0.7f,
+                    -0.4f,
+                    -0.5f,
+                ]
+            ],
+            8));
+
+    /// <summary>
+    /// DCT128x256 quantizer encoding.
+    /// </summary>
+    public static readonly JxlQuantizerEncoding Dct128x256 = JxlQuantizerEncoding.Dct(
+        new JxlDctQuantWeightParameters(
+            [
+                [
+                    2.6f * 23629.073922049845f,
+                    -1.025f,
+                    -0.78f,
+                    -0.65012f,
+                    -0.19041574084286472f,
+                    -0.20819395464f,
+                    -0.421064f,
+                    -0.32733845535848671f,
+                ],
+                [
+                    2.6f * 8611.3238710010046f,
+                    -0.3041958212306401f,
+                    -0.3633036457487539f,
+                    -0.35660379990111464f,
+                    -0.3443074455424403f,
+                    -0.33699592683512467f,
+                    -0.30180866526242109f,
+                    -0.27321683125358037f,
+                ],
+                [
+                    2.6f * 4492.2486445538634f,
+                    -1.2f,
+                    -1.2f,
+                    -0.8f,
+                    -0.7f,
+                    -0.7f,
+                    -0.4f,
+                    -0.5f,
+                ]
+            ],
+            8));
+
+    private static ReadOnlySpan<float> AfvFrequencies =>
+    [
+        0xBAD,
+        0xBAD,
+        0.8517778890324296f,
+        5.37778436506804f,
+        0xBAD,
+        0xBAD,
+        4.734747904497923f,
+        5.449245381693219f,
+        1.6598270267479331f,
+        4,
+        7.275749096817861f,
+        10.423227632456525f,
+        2.662932286148962f,
+        7.630657783650829f,
+        8.962388608184032f,
+        12.97166202570235f,
+    ];
+
+    private static Vector128<float> Gather(ReadOnlySpan<float> data, Vector128<int> indices)
+    {
+        Vector128<float> result = Vector128<float>.Zero;
+
+        for (int i = 0; i < 4; i++)
+        {
+            result = result.WithElement(i, data[indices[i]]);
+        }
+
+        return result;
+    }
+
+    public static void GetQuantWeightsDCT2(float[][] dct2Weights, Span<float> weights)
+    {
+        for (int c = 0; c < 3; c++)
+        {
+            int start = c * 64;
+
+            weights[start] = 0xBAD;
+            weights[start + 1] = weights[start + 8] = dct2Weights[c][0];
+            weights[start + 9] = dct2Weights[c][1];
+
+            for (int y = 0; y < 2; y++)
+            {
+                for (int x = 0; x < 2; x++)
+                {
+                    weights[start + (y * 8) + x + 2] = dct2Weights[c][2];
+                    weights[start + ((y + 2) * 8) + x] = dct2Weights[c][2];
+                }
+            }
+
+            for (int y = 0; y < 2; y++)
+            {
+                for (int x = 0; x < 2; x++)
+                {
+                    weights[start + ((y + 2) * 8) + x + 2] = dct2Weights[c][3];
+                }
+            }
+
+            for (int y = 0; y < 4; y++)
+            {
+                for (int x = 0; x < 4; x++)
+                {
+                    weights[start + (y * 8) + x + 4] = dct2Weights[c][4];
+                    weights[start + ((y + 4) * 8) + x] = dct2Weights[c][4];
+                }
+            }
+
+            for (int y = 0; y < 4; y++)
+            {
+                for (int x = 0; x < 4; x++)
+                {
+                    weights[start + ((y + 4) * 8) + x + 4] = dct2Weights[c][5];
+                }
+            }
+        }
+    }
+
+    public static void GetQuantWeightsIdentity(float[][] idWeights, Span<float> weights)
+    {
+        for (int c = 0; c < 3; c++)
+        {
+            int c64 = 64 * c;
+
+            for (int i = 0; i < 64; i++)
+            {
+                weights[c64 + i] = idWeights[c][0];
+            }
+
+            weights[c64 + 1] = idWeights[c][1];
+            weights[c64 + 8] = idWeights[c][1];
+            weights[c64 + 9] = idWeights[c][2];
+        }
+    }
+
+    public static float Interpolate(float pos, float max, Span<float> array, int len)
+    {
+        float scaledPos = pos * (len - 1) / max;
+        int idx = (int)scaledPos;
+        float a = array[idx];
+        float b = array[idx + 1];
+        return a * MathF.Pow(b / a, scaledPos - idx);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float Mult(float v) => v > 0f
+        ? 1.0f + v
+        : 1.0f / (1.0f - v);
+
+    public static Vector128<float> InterpolateVec(Vector128<float> scaledPos, ReadOnlySpan<float> array)
+    {
+        Vector128<int> idx = Vector128.ConvertToInt32(scaledPos);
+        Vector128<float> frac = scaledPos - Vector128.ConvertToSingle(idx);
+
+        Vector128<float> a = Gather(array, idx);
+        Vector128<float> b = Gather(array[1..], idx);
+
+        return a * JxlSimdUtils.FastPowf(b / a, frac);
+    }
+
+    public static bool GetQuantWeights(
+        int rows,
+        int cols,
+        float[][] distanceBands,
+        int numBands,
+        Span<float> output)
+    {
+        Span<float> bands = stackalloc float[JxlQuantizerConstants.MaxDistanceBands];
+
+        for (int c = 0; c < 3; c++)
+        {
+            bands[0] = distanceBands[c][0];
+
+            if (bands[0] < AlmostZero)
+            {
+                return false;
+            }
+
+            for (int i = 1; i < numBands; i++)
+            {
+                bands[i] = bands[i - 1] * distanceBands[c][i];
+
+                if (bands[i] < AlmostZero)
+                {
+                    return false;
+                }
+            }
+
+            float scale = (numBands - 1) / (JxlDctScales.Sqrt2 + 1e-6f);
+            float rcpCol = scale / (cols - 1);
+            float rcpRow = scale / (rows - 1);
+
+            for (int y = 0; y < rows; y++)
+            {
+                float dy = y * rcpRow;
+                float dy2 = dy * dy;
+
+                for (int x = 0; x < cols; x += 4)
+                {
+                    Vector128<float> dx =
+                        Vector128.Create((float)x, x + 1, x + 2, x + 3)
+                        * Vector128.Create(rcpCol);
+
+                    Vector128<float> scaledDistance =
+                        Vector128.Sqrt(
+                            (dx * dx) + Vector128.Create(dy2));
+
+                    Vector128<float> weight =
+                        numBands == 1
+                            ? Vector128.Create(bands[0])
+                            : InterpolateVec(scaledDistance, bands);
+
+                    weight.CopyTo(output[((c * cols * rows) + (y * cols) + x)..]);
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public static bool ComputeQuantTable(JxlQuantizerEncoding encoding, Span<float> table, Span<float> inverseTable, int tableNum, JxlQuantTable kind, ref int pos)
+    {
+        const int n = JxlFrameDimensions.BlockDimensions;
+
+        int quantSizeTable = (int)kind;
+        int wrows = 8 * JxlDequantMatrices.RequiredSizeX[quantSizeTable];
+        int wcols = 8 * JxlDequantMatrices.RequiredSizeY[quantSizeTable];
+        int num = wrows * wcols;
+
+        Span<float> weights = stackalloc float[3 * num];
+
+        switch (encoding.Mode)
+        {
+            case JxlQuantMode.Library:
+            {
+                // Library and copy quant encoding should get replaced by the actual
+                // parameters by the caller.
+                return false;
+            }
+
+            case JxlQuantMode.Id:
+            {
+                if (num != JxlFrameDimensions.DctBlockSize)
+                {
+                    return false;
+                }
+
+                GetQuantWeightsIdentity(encoding.IdWeights!, weights);
+                break;
+            }
+
+            case JxlQuantMode.Dct2:
+            {
+                if (num != JxlFrameDimensions.DctBlockSize)
+                {
+                    return false;
+                }
+
+                GetQuantWeightsDCT2(encoding.Dct2Weights!, weights);
+                break;
+            }
+
+            case JxlQuantMode.Dct4:
+            {
+                if (num != JxlFrameDimensions.DctBlockSize)
+                {
+                    return false;
+                }
+
+                Span<float> weights4x4 = stackalloc float[3 * 4 * 4];
+
+                // Always use 4x4 GetQuantWeights for DCT4 quantization tables.
+                if (!GetQuantWeights(4, 4, encoding.DctParameters!.DistanceBands, encoding.DctParameters.NumDistanceBands, weights4x4))
+                {
+                    return false;
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    for (int y = 0; y < JxlFrameDimensions.BlockDimensions; y++)
+                    {
+                        for (int x = 0; x < JxlFrameDimensions.BlockDimensions; x++)
+                        {
+                            weights[(c * num) + (y * JxlFrameDimensions.BlockDimensions) + x] = weights4x4[(c * 16) + ((y / 2) * 4) + (x / 2)];
+                        }
+                    }
+
+                    weights[(c * num) + 1] /= encoding.Dct4Multipliers![c][0];
+                    weights[(c * num) + n] /= encoding.Dct4Multipliers[c][0];
+                    weights[(c * num) + n + 1] /= encoding.Dct4Multipliers[c][1];
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Dct4x8:
+            {
+                if (num != JxlFrameDimensions.DctBlockSize)
+                {
+                    return false;
+                }
+
+                Span<float> weights4x8 = stackalloc float[3 * 4 * 8];
+
+                if (!GetQuantWeights(4, 8, encoding.DctParameters!.DistanceBands, encoding.DctParameters.NumDistanceBands, weights4x8))
+                {
+                    return false;
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    for (int y = 0; y < JxlFrameDimensions.BlockDimensions; y++)
+                    {
+                        for (int x = 0; x < JxlFrameDimensions.BlockDimensions; x++)
+                        {
+                            weights[(c * num) + (y * JxlFrameDimensions.BlockDimensions) + x] = weights4x8[(c * 32) + ((y / 2) * 8) + x];
+                        }
+                    }
+
+                    weights[(c * num) + n] /= encoding.Dct4x8Multipliers![c];
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Dct:
+            {
+                if (!GetQuantWeights(wrows, wcols, encoding.DctParameters!.DistanceBands, encoding.DctParameters.NumDistanceBands, weights))
+                {
+                    return false;
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Raw:
+            {
+                if (encoding.QuantizationTable is null || encoding.QuantizationTable.Length != 3 * num)
+                {
+                    throw new InvalidOperationException("Invalid raw quantizer table encoding");
+                }
+
+                Span<int> qtable = encoding.QuantizationTable.AsSpan();
+
+                for (int i = 0; i < 3 * num; i++)
+                {
+                    weights[i] = 1f / (encoding.QuantizationTableDenominator * qtable[i]);
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Afv:
+            {
+                Span<float> weights4x8 = stackalloc float[3 * 4 * 8];
+
+                if (!GetQuantWeights(4, 8, encoding.DctParameters!.DistanceBands, encoding.DctParameters.NumDistanceBands, weights4x8))
+                {
+                    return false;
+                }
+
+                Span<float> weights4x4 = stackalloc float[3 * 4 * 4];
+
+                if (!GetQuantWeights(4, 4, encoding.DctParametersAfv4x4!.DistanceBands, encoding.DctParametersAfv4x4.NumDistanceBands, weights4x4))
+                {
+                    return false;
+                }
+
+                const float lo = 0.8517778890324296f;
+                const float hi = 12.97166202570235f - lo + 1e-6f;
+
+                Span<float> bands = [0, 0, 0, 0];
+
+                for (int c = 0; c < 3; c++)
+                {
+                    bands[0] = encoding.AfvWeights![c][5];
+
+                    if (bands[0] < AlmostZero)
+                    {
+                        throw new InvalidOperationException("Invalid AFV bands");
+                    }
+
+                    for (int i = 1; i < 4; i++)
+                    {
+                        bands[i] = bands[i - 1] * Mult(encoding.AfvWeights[c][i + 5]);
+
+                        if (bands[i] < AlmostZero)
+                        {
+                            throw new InvalidOperationException("Invalid AFV bands");
+                        }
+                    }
+
+                    int start = c * 64;
+
+                    void SetWeight(int x, int y, float value, Span<float> weights) => weights[start + (y * 8) + x] = value;
+
+                    weights[start] = 1;
+
+                    SetWeight(0, 1, encoding.AfvWeights[c][0], weights);
+                    SetWeight(1, 0, encoding.AfvWeights[c][1], weights);
+                    SetWeight(0, 2, encoding.AfvWeights[c][2], weights);
+                    SetWeight(2, 0, encoding.AfvWeights[c][3], weights);
+                    SetWeight(2, 2, encoding.AfvWeights[c][4], weights);
+
+                    // All other AFV weights.
+                    for (int y = 0; y < 4; y++)
+                    {
+                        for (int x = 0; x < 4; x++)
+                        {
+                            if (x < 2 && y < 2)
+                            {
+                                continue;
+                            }
+
+                            float interpolatedVal = Interpolate(AfvFrequencies[(y * 4) + x] - lo, hi, bands, 4);
+
+                            SetWeight(2 * x, 2 * y, interpolatedVal, weights);
+                        }
+                    }
+
+                    // Put 4x8 weights in odd rows, except (1, 0).
+                    for (int y = 0; y < JxlFrameDimensions.BlockDimensions / 2; y++)
+                    {
+                        for (int x = 0; x < JxlFrameDimensions.BlockDimensions; x++)
+                        {
+                            if (x == 0 && y == 0)
+                            {
+                                continue;
+                            }
+
+                            weights[(c * num) + (((2 * y) + 1) * JxlFrameDimensions.BlockDimensions) + x] = weights4x8[(c * 32) + (y * 8) + x];
+                        }
+                    }
+
+                    // Put 4x4 weights in even rows / odd columns, except (0, 1).
+                    for (int y = 0; y < JxlFrameDimensions.BlockDimensions / 2; y++)
+                    {
+                        for (int x = 0; x < JxlFrameDimensions.BlockDimensions / 2; x++)
+                        {
+                            if (x == 0 && y == 0)
+                            {
+                                continue;
+                            }
+
+                            weights[(c * num) + ((2 * y) * JxlFrameDimensions.BlockDimensions) + (2 * x) + 1] = weights4x4[(c * 16) + (y * 4) + x];
+                        }
+                    }
+                }
+
+                break;
+            }
+        }
+
+        int prevPos = pos;
+
+        // Don't zero-init
+        Span<float> invVal = stackalloc float[64];
+        Span<float> val = stackalloc float[64];
+
+        for (int i = 0; i < num * 3; i += 64)
+        {
+            weights.Slice(i, 64).CopyTo(invVal);
+
+            // TODO: there's an unlikely check right here in
+            // reference:
+            //    if (JXL_UNLIKELY(!AllFalse(d, Ge(inv_val, Set(d, 1.0f / kAlmostZero))) ||
+            //             !AllFalse(d, Lt(inv_val, Set(d, kAlmostZero)))))
+            //    {
+            //      throw new InvalidOperationException("Invalid quantization table");
+            //    }
+            // should we trade performance for an unlikely check?
+            val.Fill(1.0f);
+            TensorPrimitives.Divide(val, invVal, val);
+
+            val.CopyTo(table.Slice(pos + i, 64));
+            invVal.CopyTo(inverseTable.Slice(pos + i, 64));
+        }
+
+        pos += 3 * num;
+
+        int xs = JxlDequantMatrices.RequiredSizeX[quantSizeTable];
+        int ys = JxlDequantMatrices.RequiredSizeY[quantSizeTable];
+
+        JxlForwardCoefficientOrder.CoefficientLayout(ref ys, ref xs);
+
+        for (int c = 0; c < 3; c++)
+        {
+            for (int y = 0; y < ys; y++)
+            {
+                for (int x = 0; x < xs; x++)
+                {
+                    inverseTable[prevPos + (c * ys * xs * JxlFrameDimensions.DctBlockSize) + (y * JxlFrameDimensions.BlockDimensions * xs) + x] = 0;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public static bool DecodeDctParameters(JxlBitReader reader, JxlDctQuantWeightParameters parameters)
+    {
+        parameters.NumDistanceBands = (int)reader.ReadBits32(JxlQuantizerConstants.Log2MaxDistanceBands) + 1;
+
+        for (int c = 0; c < 3; c++)
+        {
+            for (int i = 0; i < parameters.NumDistanceBands; i++)
+            {
+                if (!JxlF16Coder.Read(reader, ref parameters.DistanceBands[c][i]))
+                {
+                    return false;
+                }
+            }
+
+            if (parameters.DistanceBands[c][0] < AlmostZero)
+            {
+                throw new InvalidOperationException("Distance band seed is too small");
+            }
+
+            parameters.DistanceBands[c][0] *= 64f;
+        }
+
+        return true;
+    }
+
+    public static bool Decode(Configuration configuration, JxlBitReader br, JxlQuantizerEncoding encoding, int requiredSizeX, int requiredSizeY, int idx, JxlModularFrameDecoder modularFrameDecoder)
+    {
+        int requiredSize = requiredSizeX * requiredSizeY;
+
+        requiredSizeX *= JxlFrameDimensions.BlockDimensions;
+        requiredSizeY *= JxlFrameDimensions.BlockDimensions;
+
+        int mode = (int)br.ReadBits32(JxlQuantizerConstants.Log2NumQuantModes);
+
+        switch ((JxlQuantMode)mode)
+        {
+            case JxlQuantMode.Library:
+            {
+                encoding.Predefined = (byte)br.ReadBits32(CeilLog2NumPredefinedTables);
+
+                if (encoding.Predefined >= NumPredefinedTables)
+                {
+                    throw new InvalidOperationException("Invalid predefined table");
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Id:
+            {
+                if (requiredSize != 1)
+                {
+                    throw new InvalidOperationException("Invalid mode");
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    for (int i = 0; i < 3; i++)
+                    {
+                        if (!JxlF16Coder.Read(br, ref encoding.IdWeights![c][i]))
+                        {
+                            return false;
+                        }
+
+                        if (Math.Abs(encoding.IdWeights[c][i]) < AlmostZero)
+                        {
+                            throw new InvalidOperationException("ID Quantizer is too small");
+                        }
+
+                        encoding.IdWeights[c][i] *= 64;
+                    }
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Dct2:
+            {
+                if (requiredSize != 1)
+                {
+                    throw new InvalidOperationException("Invalid mode");
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    for (int i = 0; i < 6; i++)
+                    {
+                        if (!JxlF16Coder.Read(br, ref encoding.Dct2Weights![c][i]))
+                        {
+                            return false;
+                        }
+
+                        if (Math.Abs(encoding.Dct2Weights[c][i]) < AlmostZero)
+                        {
+                            throw new InvalidOperationException("Quantizer is too small");
+                        }
+
+                        encoding.Dct2Weights[c][i] *= 64;
+                    }
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Dct4x8:
+            {
+                if (requiredSize != 1)
+                {
+                    throw new InvalidOperationException("Invalid mode");
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    if (!JxlF16Coder.Read(br, ref encoding.Dct4x8Multipliers![c]))
+                    {
+                        return false;
+                    }
+
+                    if (Math.Abs(encoding.Dct4x8Multipliers[c]) < AlmostZero)
+                    {
+                        throw new InvalidOperationException("DCT4X8 multiplier is too small");
+                    }
+                }
+
+                if (!DecodeDctParameters(br, encoding.DctParameters!))
+                {
+                    return false;
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Dct4:
+            {
+                if (requiredSize != 1)
+                {
+                    throw new InvalidOperationException("Invalid mode");
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    for (int i = 0; i < 2; i++)
+                    {
+                        if (!JxlF16Coder.Read(br, ref encoding.Dct4Multipliers![c][i]))
+                        {
+                            return false;
+                        }
+
+                        if (Math.Abs(encoding.Dct4Multipliers[c][i]) < AlmostZero)
+                        {
+                            throw new InvalidOperationException("DCT4 multiplier is too small");
+                        }
+                    }
+                }
+
+                if (!DecodeDctParameters(br, encoding.DctParameters!))
+                {
+                    return false;
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Afv:
+            {
+                if (requiredSize != 1)
+                {
+                    throw new InvalidOperationException("Invalid mode");
+                }
+
+                for (int c = 0; c < 3; c++)
+                {
+                    for (int i = 0; i < 9; i++)
+                    {
+                        if (!JxlF16Coder.Read(br, ref encoding.AfvWeights![c][i]))
+                        {
+                            return false;
+                        }
+                    }
+
+                    for (int i = 0; i < 6; i++)
+                    {
+                        encoding.AfvWeights![c][i] *= 64;
+                    }
+                }
+
+                if (!DecodeDctParameters(br, encoding.DctParameters!))
+                {
+                    return false;
+                }
+
+                if (!DecodeDctParameters(br, encoding.DctParametersAfv4x4!))
+                {
+                    return false;
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Dct:
+            {
+                if (!DecodeDctParameters(br, encoding.DctParameters!))
+                {
+                    return false;
+                }
+
+                break;
+            }
+
+            case JxlQuantMode.Raw:
+            {
+                // Set mode early, to avoid mem-leak.
+                encoding.Mode = JxlQuantMode.Raw;
+
+                if (!JxlModularFrameDecoder.DecodeQuantTable(configuration, requiredSizeX, requiredSizeY, br, encoding, idx, modularFrameDecoder))
+                {
+                    return false;
+                }
+
+                break;
+            }
+
+            default:
+                throw new InvalidOperationException("Invalid quant table encoding");
+        }
+
+        encoding.Mode = (JxlQuantMode)mode;
+        return true;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizer.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizer.cs
new file mode 100644
index 0000000000..5788160141
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizer.cs
@@ -0,0 +1,373 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.AcStrategy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// The quantizer for DCT DC/AC coefficients.
+/// </summary>
+/// <remarks>
+/// The quantizer's primary role is to lower the value
+/// of coefficients. For example, during encoding,
+/// coefficients may be divided by 3 and have to be
+/// multiplied by 3 at decoding (which is lossy). Quantization is often
+/// useful for variable-length coding where the amount
+/// of bits depend on how large the number is.
+/// </remarks>
+internal sealed class JxlQuantizer
+{
+    /// <summary>
+    /// Denominator for the global_scale value.
+    /// </summary>
+    private const int GlobalScaleDenominator = 1 << 16;
+
+    /// <summary>
+    /// Numerator for the global_scale value.
+    /// </summary>
+    private const int GlobalScaleNumerator = 4096;
+
+    /// <summary>
+    /// Numerator for biases.
+    /// </summary>
+    private const float BiasNumerator = 0.145f;
+
+    /// <summary>
+    /// The default value of the quant.
+    /// </summary>
+    private const int DefaultQuant = 64;
+
+    /// <summary>
+    /// The maximum value for a quant. Quant cannot be greater than this -
+    /// if attempted to, it will be limited to this value.
+    /// </summary>
+    private const int MaxQuant = 256;
+
+    /// <summary>
+    /// Represents the multipliers for the DC coefficients.
+    /// </summary>
+    private InlineArray4<float> mulDc;
+
+    /// <summary>
+    /// Represents the inverse multipliers for the DC coefficients.
+    /// </summary>
+    private InlineArray4<float> inverseMulDc;
+
+    /// <summary>
+    /// Global scale
+    /// </summary>
+    private int globalScale;
+
+    /// <summary>
+    /// Quantizer DC
+    /// </summary>
+    private int quantDc;
+
+    /// <summary>
+    /// The zero bias.
+    /// </summary>
+    private readonly InlineArray3<float> zeroBias;
+
+    /// <summary>
+    /// The dequant matrices.
+    /// </summary>
+    private readonly JxlDequantMatrices? dequant;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlQuantizer"/> class using the default
+    /// DC quantizer &amp; scale factors.
+    /// </summary>
+    /// <param name="dequant">The dequant.</param>
+    public JxlQuantizer(JxlDequantMatrices dequant)
+        : this(dequant, DefaultQuant, GlobalScaleDenominator / DefaultQuant)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlQuantizer"/> class.
+    /// </summary>
+    /// <param name="dequant">The dequant.</param>
+    /// <param name="quantDc">The DC quantizer.</param>
+    /// <param name="globalScale">The scale factor.</param>
+    public JxlQuantizer(JxlDequantMatrices dequant, int quantDc, int globalScale)
+    {
+        this.dequant = dequant;
+        this.quantDc = quantDc;
+        this.globalScale = globalScale;
+
+        this.RecomputeFromGlobalScale();
+        this.InverseQuantDc = this.InverseGlobalScale / this.quantDc;
+
+        ZeroBiasDefault.CopyTo(this.zeroBias);
+    }
+
+    /// <summary>
+    /// Gets the scaling factor.
+    /// </summary>
+    public float Scale { get; private set; }
+
+    /// <summary>
+    /// Gets the inverse scaling factor. It is a reciprocal of <see cref="Scale"/>.
+    /// </summary>
+    public float InverseGlobalScale { get; private set; }
+
+    /// <summary>
+    /// Gets the inverse DC quantization base value.
+    /// </summary>
+    public float InverseQuantDc { get; private set; }
+
+    public ReadOnlySpan<float> MulDc => this.mulDc;
+
+    public ReadOnlySpan<float> InverseMulDc => this.inverseMulDc;
+
+    /// <summary>
+    /// Gets the zero-biases for quantizing channels X, Y, and B.
+    /// </summary>
+    private static ReadOnlySpan<float> ZeroBiasDefault => [0.5f, 0.5f, 0.5f];
+
+    /// <summary>
+    /// Gets the default bias for quant.
+    /// </summary>
+    public static ReadOnlySpan<float> DefaultQuantBias =>
+    [
+        1.0f - 0.05465007330715401f,
+        1.0f - 0.07005449891748593f,
+        1.0f - 0.049935103337343655f,
+        0.145f,
+    ];
+
+    /// <summary>
+    /// Clears the <see cref="MulDc"/> and <see cref="InverseMulDc"/> values,
+    /// setting their contents to 1.0f.
+    /// </summary>
+    public void ClearDcMultipliers()
+    {
+        ((Span<float>)this.mulDc).Fill(1f);
+        ((Span<float>)this.inverseMulDc).Fill(1f);
+    }
+
+    /// <summary>
+    /// Ensure that the input value stays within the range of 1..MaxQuant.
+    /// </summary>
+    /// <param name="value">Value to clamp</param>
+    /// <returns>The input value clamped into the range of 1..MaxQuant.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Clamp(float value) => (int)MathF.Max(1.0f, MathF.Min(value, MaxQuant));
+
+    /// <summary>
+    /// Scales the global scale value.
+    /// </summary>
+    /// <param name="scale">The new scale</param>
+    /// <returns>The scale value, scaled by the global scale.</returns>
+    public float ScaleGlobalScale(float scale)
+    {
+        int newGlobalScale = (int)MathF.Round(this.globalScale * scale, MidpointRounding.AwayFromZero);
+        float scaleOut = newGlobalScale * 1.0f / this.globalScale;
+        this.globalScale = newGlobalScale;
+
+        this.RecomputeFromGlobalScale();
+
+        return scaleOut;
+    }
+
+    /// <summary>
+    /// Recomputes quant values from the scale.
+    /// </summary>
+    public void RecomputeFromGlobalScale()
+    {
+        this.Scale = this.globalScale * (1.0f / GlobalScaleDenominator);
+        this.InverseGlobalScale = 1.0f * GlobalScaleDenominator / this.globalScale;
+        this.InverseQuantDc = this.InverseGlobalScale / this.quantDc;
+
+        for (int c = 0; c < 3; c++)
+        {
+            this.mulDc[c] = this.GetDcStep(c);
+            this.inverseMulDc[c] = this.GetInverseDcStep(c);
+        }
+    }
+
+    /// <summary>
+    /// Returns the dequant matrix.
+    /// </summary>
+    /// <param name="strategy">The quant kind</param>
+    /// <param name="c">The quantization index</param>
+    /// <returns>The dequant matrix.</returns>
+    public ReadOnlySpan<float> DequantMatrix(JxlAcStrategyType strategy, int c)
+        => this.dequant!.GetMatrix(strategy, c);
+
+    /// <summary>
+    /// Returns the inverse dequant matrix.
+    /// </summary>
+    /// <param name="strategy">The quant kind</param>
+    /// <param name="c">The quantization index</param>
+    /// <returns>The inverse dequant matrix.</returns>
+    public ReadOnlySpan<float> InverseDequantMatrix(JxlAcStrategyType strategy, int c)
+        => this.dequant!.GetInverseMatrix(strategy, c);
+
+    /// <summary>
+    /// Returns the DC quantization step.
+    /// </summary>
+    /// <param name="c">The quantization index</param>
+    /// <returns>The DC quantization step</returns>
+    public float GetDcStep(int c) => this.InverseQuantDc * this.dequant!.GetDcQuant(c);
+
+    /// <summary>
+    /// Returns the inverse DC quantization step.
+    /// </summary>
+    /// <param name="c">The quantization index</param>
+    /// <returns>The inverse DC quantization step</returns>
+    public float GetInverseDcStep(int c) => this.dequant!.GetInverseDcQuant(c) * (this.Scale * this.quantDc);
+
+    /// <summary>
+    /// Creates JXL quantizer parameters with values reflecting those in this quantizer instance.
+    /// </summary>
+    /// <returns>The quantizer parameters.</returns>
+    public JxlQuantizerParameters GetParameters() => new()
+    {
+        QuantDc = (uint)this.quantDc,
+        GlobalScale = (uint)this.globalScale
+    };
+
+    /// <summary>
+    /// Reads the quantizer values from the bit-stream.
+    /// </summary>
+    /// <param name="reader">The bit reader.</param>
+    /// <exception cref="IOException">Thrown when it is not possible to parse the quantizer parameters.</exception>
+    public void Decode(JxlBitReader reader)
+    {
+        JxlQuantizerParameters qp = new();
+        if (!JxlBundle.Read(reader, qp))
+        {
+            throw new IOException("Could not read quantizer parameters");
+        }
+
+        this.globalScale = (int)qp.GlobalScale;
+        this.quantDc = (int)qp.QuantDc;
+
+        this.RecomputeFromGlobalScale();
+    }
+
+    /// <summary>
+    /// Recomputes the scaling factors and quant.
+    /// </summary>
+    public void ComputeGlobalScaleAndQuant(float quantDc, float quantMedian, float quantMedianAbsd)
+    {
+        const int quantFieldTarget = 5;
+        float scale = GlobalScaleDenominator * (quantMedian - quantMedianAbsd) / quantFieldTarget;
+
+        scale = Math.Clamp(scale, 1, 1 << 15);
+
+        int newGlobalScale = (int)scale;
+        int scaledQuantDc = (int)(quantDc * GlobalScaleNumerator * 1.6f);
+
+        if (newGlobalScale > scaledQuantDc)
+        {
+            newGlobalScale = scaledQuantDc;
+
+            if (newGlobalScale <= 0)
+            {
+                newGlobalScale = 1;
+            }
+        }
+
+        this.globalScale = newGlobalScale;
+
+        this.RecomputeFromGlobalScale();
+
+        float valueF = (quantDc * this.InverseGlobalScale) + 0.5f;
+        float clipValueF = MathF.Min(1 << 16, valueF);
+        int newQuant = (int)clipValueF;
+        this.quantDc = newQuant;
+
+        this.RecomputeFromGlobalScale();
+    }
+
+    /// <summary>
+    /// Quantizes the specified rectangular selection.
+    /// </summary>
+    public void SetQuantFieldRect(JxlImageF qf, in Rectangle rect, JxlImageI rawQuantField)
+    {
+        for (int y = 0; y < rect.Height; y++)
+        {
+            ReadOnlySpan<float> rowQf = qf.GetRow(rect, y);
+            Span<int> rowQi = rawQuantField.GetRow(rect, y);
+
+            for (int x = 0; x < rect.Width; x++)
+            {
+                int val = Clamp((rowQf[x] * this.InverseGlobalScale) + 0.5f);
+
+                rowQi[x] = val;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Set the quant field.
+    /// </summary>
+    public bool SetQuantField(Configuration configuration, float quantDc, JxlImageF qf, JxlImageI? rawQuantField)
+    {
+        IMemoryOwner<float> data = configuration.MemoryAllocator.Allocate<float>(qf.XSize * qf.YSize);
+        Span<float> dataSpan = data.Memory.Span;
+
+        for (int y = 0; y < qf.YSize; y++)
+        {
+            ReadOnlySpan<float> rowQf = qf.GetRow(y);
+
+            for (int x = 0; x < qf.XSize; y++)
+            {
+                float quant = rowQf[x];
+
+                dataSpan[(qf.XSize * y) + x] = quant;
+            }
+        }
+
+        dataSpan[dataSpan.Length / 2] = JxlSpanHelper.NthElement(dataSpan, dataSpan.Length / 2);
+        float quantMedian = dataSpan[dataSpan.Length / 2];
+
+        IMemoryOwner<float> deviations = configuration.MemoryAllocator.Allocate<float>(dataSpan.Length);
+        Span<float> deviationsSpan = deviations.Memory.Span;
+        for (int i = 0; i < dataSpan.Length; i++)
+        {
+            deviationsSpan[i] = MathF.Abs(dataSpan[i] - quantMedian);
+        }
+
+        deviationsSpan[deviationsSpan.Length / 2] = JxlSpanHelper.NthElement(deviationsSpan, deviationsSpan.Length / 2);
+        float quantMedianAbsd = deviationsSpan[deviationsSpan.Length / 2];
+
+        this.ComputeGlobalScaleAndQuant(quantDc, quantMedian, quantMedianAbsd);
+
+        if (rawQuantField != null)
+        {
+            if (rawQuantField.GetRectangle() != qf.GetRectangle())
+            {
+                data.Dispose();
+                deviations.Dispose();
+
+                return false;
+            }
+
+            this.SetQuantFieldRect(qf, qf.GetRectangle(), rawQuantField);
+        }
+
+        data.Dispose();
+        deviations.Dispose();
+
+        return true;
+    }
+
+    public void SetQuant(float quantDc, float quantAc, JxlImageI rawQuantField)
+    {
+        this.ComputeGlobalScaleAndQuant(quantDc, quantAc, 0);
+
+        int value = Clamp((quantAc * this.InverseGlobalScale) + 0.5f);
+        JxlImageOperations.FillImage(value, rawQuantField);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerConstants.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerConstants.cs
new file mode 100644
index 0000000000..bc0042afaa
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerConstants.cs
@@ -0,0 +1,54 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// Shared constants used by the quantizer.
+/// </summary>
+internal static class JxlQuantizerConstants
+{
+    public const int Log2MaxDistanceBands = 4;
+
+    public const int MaxDistanceBands = 1 + (1 << Log2MaxDistanceBands);
+
+    public const int CeilLog2NumPredefinedTables = 0;
+
+    public const int Log2NumQuantModes = 3;
+
+    /// <summary>
+    /// Total number of quantization tables.
+    /// </summary>
+    public const byte NumberOfQuantizerTables = (byte)(JxlQuantTable.DCT128X256 + 1);
+
+    /// <summary>
+    /// Gets the inverse DC quantization table.
+    /// </summary>
+    public static ReadOnlySpan<float> InverseDcQuant => [4096f, 512f, 256f];
+
+    /// <summary>
+    /// Gets the forward DC quantization table.
+    /// </summary>
+    public static ReadOnlySpan<float> DcQuant => [
+        1f / 4096f,
+        1f / 512f,
+        1f / 256f];
+
+    /// <summary>
+    /// Gets a translation table for converting AC strategies to quant tables.
+    /// Simply pass the index of the AC strategy enum and you'll get back the
+    /// matching quant table.
+    /// </summary>
+    public static ReadOnlySpan<JxlQuantTable> AcStrategyToQuantTableMap =>
+    [
+        JxlQuantTable.DCT,        JxlQuantTable.IDENTITY,   JxlQuantTable.DCT2X2,
+        JxlQuantTable.DCT4X4,     JxlQuantTable.DCT16X16,   JxlQuantTable.DCT32X32,
+        JxlQuantTable.DCT8X16,    JxlQuantTable.DCT8X16,    JxlQuantTable.DCT8X32,
+        JxlQuantTable.DCT8X32,    JxlQuantTable.DCT16X32,   JxlQuantTable.DCT16X32,
+        JxlQuantTable.DCT4X8,     JxlQuantTable.DCT4X8,     JxlQuantTable.AFV0,
+        JxlQuantTable.AFV0,       JxlQuantTable.AFV0,       JxlQuantTable.AFV0,
+        JxlQuantTable.DCT64X64,   JxlQuantTable.DCT32X64,   JxlQuantTable.DCT32X64,
+        JxlQuantTable.DCT128X128, JxlQuantTable.DCT64X128,  JxlQuantTable.DCT64X128,
+        JxlQuantTable.DCT256X256, JxlQuantTable.DCT128X256, JxlQuantTable.DCT128X256
+    ];
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerEncoding.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerEncoding.cs
new file mode 100644
index 0000000000..283892392a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerEncoding.cs
@@ -0,0 +1,227 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// Specifies weights and quantizer modes.
+/// </summary>
+internal sealed class JxlQuantizerEncoding
+{
+    public JxlQuantizerEncoding()
+    {
+    }
+
+    public JxlQuantizerEncoding(JxlQuantizerEncoding other)
+    {
+        // Simple shallow copy
+        this.AfvWeights = other.AfvWeights;
+        this.Dct2Weights = other.Dct2Weights;
+        this.Dct4Multipliers = other.Dct4Multipliers;
+        this.Dct4x8Multipliers = other.Dct4x8Multipliers;
+        this.DctParameters = other.DctParameters;
+        this.DctParametersAfv4x4 = other.DctParametersAfv4x4;
+        this.IdWeights = other.IdWeights;
+        this.Mode = other.Mode;
+        this.Predefined = other.Predefined;
+        this.QuantizationTable = other.QuantizationTable;
+        this.QuantizationTableDenominator = other.QuantizationTableDenominator;
+
+        if (other.QuantizationTable is not null)
+        {
+            // Do a deep clone for the quantization table.
+            // Using AsSpan() should be way faster than a normal array copy...
+            this.QuantizationTable = GC.AllocateUninitializedArray<int>(other.QuantizationTable.Length);
+            other.QuantizationTable.AsSpan().CopyTo(this.QuantizationTable);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the kind of transform used for this quantizer encoding.
+    /// </summary>
+    public JxlQuantMode Mode { get; set; }
+
+    /// <summary>
+    /// Gets or sets the weights for DCT4+ tables.
+    /// </summary>
+    public JxlDctQuantWeightParameters? DctParameters { get; set; }
+
+    /// <summary>
+    /// Gets or sets the weights for the 4x4 sub-block in AFV.
+    /// </summary>
+    public JxlDctQuantWeightParameters? DctParametersAfv4x4 { get; set; }
+
+    /// <summary>
+    /// Gets or sets the weights for the identity transform.
+    /// </summary>
+    public float[][]? IdWeights { get; set; }
+
+    /// <summary>
+    /// Gets or sets the weights for the DCT2 transform.
+    /// </summary>
+    public float[][]? Dct2Weights { get; set; }
+
+    /// <summary>
+    /// Gets or sets the multipliers for the DCT4 transform.
+    /// </summary>
+    public float[][]? Dct4Multipliers { get; set; }
+
+    /// <summary>
+    /// Gets or sets the weights for the AFV transform.
+    /// </summary>
+    public float[][]? AfvWeights { get; set; }
+
+    /// <summary>
+    /// Gets or sets the multipliers for the 4x8 DCT block-based transform.
+    /// </summary>
+    public float[]? Dct4x8Multipliers { get; set; }
+
+    /// <summary>
+    /// Gets or sets the explicit quantization table (like in JPEG).
+    /// </summary>
+    /// <remarks>
+    /// Only used when <see cref="Mode"/> == <see cref="JxlQuantMode.Raw"/>.
+    /// </remarks>
+    public int[]? QuantizationTable { get; set; }
+
+    /// <summary>
+    /// Gets or sets the denominator for each item in the explicit quantization table.
+    /// </summary>
+    /// <remarks>
+    /// Only used when <see cref="Mode"/> == <see cref="JxlQuantMode.Raw"/>.
+    /// </remarks>
+    public float QuantizationTableDenominator { get; set; } = 1f / (8 * 255);
+
+    /// <summary>
+    /// Gets or sets a value indicating which predefined table to use. The value is
+    /// only used when <see cref="Mode"/> == <see cref="JxlQuantMode.Library"/>.
+    /// </summary>
+    public byte Predefined { get; set; }
+
+    /// <summary>
+    /// Creates a new quantizer encoding with the Library quantizer mode
+    /// and the specified library index.
+    /// </summary>
+    /// <param name="libraryIndex">The library index (aka predefined table).</param>
+    /// <returns>A new Library quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Library(int libraryIndex)
+    {
+        DebugGuard.MustBeLessThan(libraryIndex, JxlQuantWeights.NumPredefinedTables, nameof(libraryIndex));
+
+        return new()
+        {
+            Mode = JxlQuantMode.Library,
+            Predefined = (byte)libraryIndex
+        };
+    }
+
+    /// <summary>
+    /// Creates a new quantizer encoding with the Identity quantizer mode
+    /// and the specified XYB/identity weights.
+    /// </summary>
+    /// <param name="xybWeights">Weights for the identity transform.</param>
+    /// <returns>A new Identity quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Identity(float[][] xybWeights)
+        => new()
+        {
+            Mode = JxlQuantMode.Id,
+            IdWeights = xybWeights
+        };
+
+    /// <summary>
+    /// Creates a new quantizer encoding with the DCT2x2 quantizer mode
+    /// and the specified XYB/DCT2x2 weights.
+    /// </summary>
+    /// <param name="xybWeights">Weights for the DCT2x2 transform.</param>
+    /// <returns>A new DCT2x2 quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Dct2(float[][] xybWeights)
+        => new()
+        {
+            Mode = JxlQuantMode.Dct2,
+            Dct2Weights = xybWeights
+        };
+
+    /// <summary>
+    /// Creates a new quantizer encoding with the DCT4x4 quantizer mode,
+    /// the specified XYB/DCT4x4 multipliers, and quantizer weight parameters.
+    /// </summary>
+    /// <param name="parameters">Quantizer weights for the DCT4x4 transform.</param>
+    /// <param name="xybMul">XYB multipliers for the DCT4x4 transform.</param>
+    /// <returns>A new DCT4x4 quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Dct4(JxlDctQuantWeightParameters parameters, float[][] xybMul)
+        => new()
+        {
+            Mode = JxlQuantMode.Dct4,
+            DctParameters = parameters,
+            Dct4Multipliers = xybMul
+        };
+
+    /// <summary>
+    /// Creates a new quantizer encoding with the DCT4x8 quantizer mode,
+    /// the specified XYB/DCT4x8 multipliers, and quantizer weight parameters.
+    /// </summary>
+    /// <param name="parameters">Quantizer weights for the DCT4x8 transform.</param>
+    /// <param name="xybMul">XYB multipliers for the DCT4x8 transform.</param>
+    /// <returns>A new DCT4x8 quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Dct4x8(JxlDctQuantWeightParameters parameters, float[] xybMul)
+        => new()
+        {
+            Mode = JxlQuantMode.Dct4x8,
+            DctParameters = parameters,
+            Dct4x8Multipliers = xybMul
+        };
+
+    /// <summary>
+    /// Creates a new quantizer encoding with the DCT quantizer mode
+    /// and quantizer weight parameters.
+    /// </summary>
+    /// <param name="parameters">Quantizer weights for the DCT transform.</param>
+    /// <returns>A new DCT quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Dct(JxlDctQuantWeightParameters parameters)
+        => new()
+        {
+            Mode = JxlQuantMode.Dct,
+            DctParameters = parameters,
+        };
+
+    /// <summary>
+    /// Creates a new quantizer encoding with the AFV quantizer mode,
+    /// quantizer weight parameters for 4x8/4x4 blocks, and weights.
+    /// </summary>
+    /// <param name="params4x8">Quantizer weights for the 4x8 sub-block for the AFV transform.</param>
+    /// <param name="params4x4">Quantizer weights for the 4x4 sub-block for the AFV transform.</param>
+    /// <param name="weights">Quantizer weights.</param>
+    /// <returns>A new DCT quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Afv(
+        JxlDctQuantWeightParameters params4x8,
+        JxlDctQuantWeightParameters params4x4,
+        float[][] weights)
+        => new()
+        {
+            Mode = JxlQuantMode.Afv,
+            DctParameters = params4x8,
+            AfvWeights = weights,
+            DctParametersAfv4x4 = params4x4
+        };
+
+    /// <summary>
+    /// Creates a new raw quantizer encoding.
+    /// </summary>
+    /// <param name="quantizationTable">The quantization table for raw quantization.</param>
+    /// <param name="shift">The shift value for the denominator.</param>
+    /// <returns>A raw quantizer encoding.</returns>
+    public static JxlQuantizerEncoding Raw(Span<int> quantizationTable, int shift = 0)
+    {
+        JxlQuantizerEncoding encoding = new()
+        {
+            Mode = JxlQuantMode.Raw,
+            QuantizationTableDenominator = (1 << shift) * (1f / (8 * 255)),
+            QuantizationTable = GC.AllocateUninitializedArray<int>(quantizationTable.Length)
+        };
+
+        quantizationTable.CopyTo(encoding.QuantizationTable);
+        return encoding;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerParameters.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerParameters.cs
new file mode 100644
index 0000000000..2963d4c329
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerParameters.cs
@@ -0,0 +1,60 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// Represents parameters for the JPEG XL quantizer.
+/// </summary>
+internal sealed class JxlQuantizerParameters : IJxlFields
+{
+    private uint globalScale;
+    private uint quantDc;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JxlQuantizerParameters"/> class.
+    /// </summary>
+    public JxlQuantizerParameters() => JxlBundle.Init(this);
+
+    /// <summary>
+    /// Gets or sets the global scale value.
+    /// </summary>
+    public uint GlobalScale
+    {
+        get => this.globalScale;
+        set => this.globalScale = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the quant DC value.
+    /// </summary>
+    public uint QuantDc
+    {
+        get => this.quantDc;
+        set => this.quantDc = value;
+    }
+
+    public bool Visit(JxlVisitor visitor)
+    {
+        if (!visitor.U32(
+            JxlFieldExpressions.BitsOffset(11, 1),
+            JxlFieldExpressions.BitsOffset(11, 2049),
+            JxlFieldExpressions.BitsOffset(12, 4097),
+            JxlFieldExpressions.BitsOffset(16, 8193),
+            1,
+            ref this.globalScale))
+        {
+            return false;
+        }
+
+        return visitor.U32(
+            JxlFieldExpressions.Value(16),
+            JxlFieldExpressions.BitsOffset(5, 1),
+            JxlFieldExpressions.BitsOffset(8, 1),
+            JxlFieldExpressions.BitsOffset(16, 1),
+            1,
+            ref this.quantDc);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerSimd.cs b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerSimd.cs
new file mode 100644
index 0000000000..66d92467cb
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Quantization/JxlQuantizerSimd.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Quantization;
+
+/// <summary>
+/// SIMD utilities used by the quantizer.
+/// </summary>
+internal static class JxlQuantizerSimd
+{
+    public static Vector<float> AdjustQuantBias(int c, Vector<int> quantI, Span<float> biases)
+    {
+        Vector<float> quant = quantI.As<int, float>();
+        Vector<float> constSign = Vector.Create(int.MinValue).As<int, float>();
+        Vector<float> sign = quant & constSign;
+        Vector<float> absoluteQuant = Vector.AndNot(constSign, quant);
+
+        Vector<int> is01 = Vector.LessThan(absoluteQuant, Vector.Create(1.125f));
+        Vector<int> not0 = Vector.GreaterThan(absoluteQuant, Vector<float>.One);
+
+        Vector<float> oneBias = Vector.ConditionalSelect(not0, Vector.Create(biases[c]) ^ sign, Vector<float>.Zero);
+        Vector<float> bias = -(Vector.Create(biases[3]) * quant.ReciprocalEstimate()) + quant;
+
+        return Vector.ConditionalSelect(is01, oneBias, bias);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf0Stage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf0Stage.cs
new file mode 100644
index 0000000000..a7bcafcc3d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf0Stage.cs
@@ -0,0 +1,171 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// Edge Preserving Filter (type 0) stage
+/// </summary>
+internal sealed class Epf0Stage : RenderPipelineStageBase
+{
+    private static readonly int[][] SadOffsets =
+    [
+        [-2, 0], [-1, -1], [-1, 0], [-1, 1], [0, -2], [0, -1],
+        [0, 1], [0, 2], [1, -1], [1, 0], [1, 1], [2, 0]
+    ];
+
+    private static readonly int[][] PlusOffsets =
+    [
+        [0, 0], [-1, 0], [0, -1], [1, 0], [0, 1]
+    ];
+
+    private readonly JxlLoopFilter loopFilter;
+    private readonly JxlImageF sigma;
+
+    public Epf0Stage(JxlLoopFilter loopFilter, JxlImageF sigma, Configuration configuration) : base(configuration)
+    {
+        this.loopFilter = loopFilter;
+        this.sigma = sigma;
+        this.Settings = RenderPipelineStageConfiguration.CreateSymmetricBorderOnly(3);
+    }
+
+    /// <inheritdoc />
+    public override string Name => "EPF0";
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void AddPixel(
+        int row,
+        InlineArray3<InlineArray7<Memory<float>>> rows,
+        int x,
+        Vector256<float> sad,
+        Vector256<float> inverseSigma,
+        ref Vector256<float> xOut,
+        ref Vector256<float> yOut,
+        ref Vector256<float> bOut,
+        ref Vector256<float> wOut)
+    {
+        int rowPlus3 = row + 3;
+        Vector256<float> cx = Vector256.Create<float>(rows[0][rowPlus3].Span[x..]);
+        Vector256<float> cy = Vector256.Create<float>(rows[1][rowPlus3].Span[x..]);
+        Vector256<float> cb = Vector256.Create<float>(rows[2][rowPlus3].Span[x..]);
+        Vector256<float> weight = EpfUtils.Weight(sad, inverseSigma);
+        wOut += weight;
+        xOut += (weight * cx) + xOut;
+        yOut += (weight * cy) + yOut;
+        bOut += (weight * cb) + bOut;
+    }
+
+    /// <inheritdoc />
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        Span<Vector256<float>> sads = stackalloc Vector256<float>[16].Slice(0, 12);
+        sads.Clear();
+
+        int xStart = -JxlMath.RoundUpTo(xExtraLeft, Vector256<float>.Count);
+        int xEnd = width + xExtraRight;
+        Span<float> rowSigma = this.sigma.GetRow((yPos / JxlFrameDimensions.BlockDimensions) + JxlDecoderCache.SigmaPadding);
+
+        float sm = this.loopFilter.EpfPass0SigmaScale * 1.65f;
+        float bsm = sm * this.loopFilter.EpfBorderSadMul;
+
+        Span<float> sadMulCenter = [bsm, sm, sm, sm, sm, sm, sm, bsm];
+        Span<float> sadMulBorder = [bsm, bsm, bsm, bsm, bsm, bsm, bsm, bsm];
+
+        int yPosModBlockDim = yPos % JxlFrameDimensions.BlockDimensions;
+        Span<float> sadMul = yPosModBlockDim is 0 or JxlFrameDimensions.BlockDimensions - 1
+            ? sadMulBorder
+            : sadMulCenter;
+
+        InlineArray3<InlineArray7<Memory<float>>> rows = default;
+        for (int c = 0; c < 3; c++)
+        {
+            for (int i = 0; i < 7; i++)
+            {
+                rows[c][i] = this.GetInputRowMemory(inputRows, c, i - 3);
+            }
+        }
+
+        for (int x = xStart; x < xEnd; x += Vector256<float>.Count)
+        {
+            int xPlusXpos = x + xPos;
+
+            int bx = (xPlusXpos + (JxlDecoderCache.SigmaPadding * JxlFrameDimensions.BlockDimensions)) / JxlFrameDimensions.BlockDimensions;
+            int ix = xPlusXpos % JxlFrameDimensions.BlockDimensions;
+
+            if (rowSigma[bx] < JxlLoopFilter.MinimumSigma)
+            {
+                for (int c = 0; c < 3; c++)
+                {
+                    Vector256<float> px = Vector256.Create<float>(rows[c][3].Span[x..]);
+                    px.CopyTo(GetOutputRow(outputRows, c, 0)[x..]);
+                }
+
+                continue;
+            }
+
+            Vector256<float> vsm = Vector256.Create<float>(sadMul[ix..]);
+            Vector256<float> inverseSigma = Vector256.Create<float>(rowSigma[bx]) * vsm;
+
+            sads.Clear();
+
+            for (int c = 0; c < 3; c++)
+            {
+                Vector256<float> scale = Vector256.Create(this.loopFilter.EpfChannelScale[c]);
+
+                for (int i = 0; i < 12; i++)
+                {
+                    Vector256<float> sad = Vector256<float>.Zero;
+
+                    foreach (Span<int> offset in PlusOffsets)
+                    {
+                        Vector256<float> r11 = Vector256.Create((ReadOnlySpan<float>)rows[c][3 + offset[0]][(x + offset[1])..].Span);
+                        Vector256<float> c11 = Vector256.Create((ReadOnlySpan<float>)rows[c][3 + SadOffsets[i][0] + offset[0]][(x + SadOffsets[i][1] + offset[1])..].Span);
+                        sad += Vector256.Abs(r11 - c11);
+                    }
+
+                    sads[i] = (sad * scale) + sads[i];
+                }
+            }
+
+            Vector256<float> xCC = Vector256.Create((ReadOnlySpan<float>)rows[0][3 + 0][x..].Span);
+            Vector256<float> yCC = Vector256.Create((ReadOnlySpan<float>)rows[1][3 + 0][x..].Span);
+            Vector256<float> bCC = Vector256.Create((ReadOnlySpan<float>)rows[2][3 + 0][x..].Span);
+
+            Vector256<float> w = Vector256<float>.One;
+            Vector256<float> X = xCC;
+            Vector256<float> Y = yCC;
+            Vector256<float> B = bCC;
+
+            for (int i = 0; i < 12; i++)
+            {
+                AddPixel(SadOffsets[i][0], rows, x + SadOffsets[i][1], sads[i], inverseSigma, ref X, ref Y, ref B, ref w);
+            }
+
+            Vector256<float> inverseW = Vector256<float>.One / w;
+
+            (X * inverseW).CopyTo(GetOutputRow(outputRows, 0, 0)[x..]);
+            (Y * inverseW).CopyTo(GetOutputRow(outputRows, 1, 0)[x..]);
+            (B * inverseW).CopyTo(GetOutputRow(outputRows, 2, 0)[x..]);
+        }
+    }
+
+    /// <inheritdoc />
+    public override RenderPipelineChannelMode GetChannelMode(int channel)
+    {
+        if (channel < 3)
+        {
+            return RenderPipelineChannelMode.InOut;
+        }
+        else
+        {
+            return RenderPipelineChannelMode.Ignored;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf1Stage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf1Stage.cs
new file mode 100644
index 0000000000..5dc19b6626
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf1Stage.cs
@@ -0,0 +1,206 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// Edge Preserving Filter (type 1) stage.
+/// </summary>
+internal sealed class Epf1Stage : RenderPipelineStageBase
+{
+    private readonly JxlLoopFilter loopFilter;
+    private readonly JxlImageF sigma;
+
+    public Epf1Stage(Configuration configuration, JxlLoopFilter loopFilter, JxlImageF sigma)
+        : base(configuration)
+    {
+        this.loopFilter = loopFilter;
+        this.sigma = sigma;
+        this.Settings = RenderPipelineStageConfiguration.CreateSymmetricBorderOnly(2);
+    }
+
+    /// <inheritdoc />
+    public override string Name => "EPF1";
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void AddPixel(
+        int row,
+        InlineArray3<InlineArray5<Memory<float>>> rows,
+        int x,
+        Vector256<float> sad,
+        Vector256<float> inverseSigma,
+        ref Vector256<float> xOut,
+        ref Vector256<float> yOut,
+        ref Vector256<float> bOut,
+        ref Vector256<float> wOut)
+    {
+        Vector256<float> cx = Vector256.Create((ReadOnlySpan<float>)rows[0][2 + row][x..].Span);
+        Vector256<float> cy = Vector256.Create((ReadOnlySpan<float>)rows[1][2 + row][x..].Span);
+        Vector256<float> cb = Vector256.Create((ReadOnlySpan<float>)rows[2][2 + row][x..].Span);
+
+        Vector256<float> weight = EpfUtils.Weight(sad, inverseSigma);
+        wOut += weight;
+        xOut = (weight + cx) * xOut;
+        yOut = (weight + cy) * yOut;
+        bOut = (weight + cb) * bOut;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> AbsoluteDifference(Vector256<float> x, Vector256<float> y) => Vector256.Abs(x - y);
+
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        int xStart = -JxlMath.RoundUpTo(xExtraLeft, Vector256<float>.Count);
+        int xEnd = width + xExtraRight;
+
+        Span<float> rowSigma = this.sigma.GetRow((yPos / JxlFrameDimensions.BlockDimensions) + JxlDecoderCache.SigmaPadding);
+        float sm = 1.65f;
+        float bsm = sm * this.loopFilter.EpfBorderSadMul;
+
+        Span<float> sadMulCenter = [bsm, sm, sm, sm, sm, sm, sm, bsm];
+        Span<float> sadMulBorder = [bsm, bsm, bsm, bsm, bsm, bsm, bsm, bsm];
+
+        InlineArray3<InlineArray5<Memory<float>>> rows = default;
+        for (int c = 0; c < 3; c++)
+        {
+            for (int i = 0; i < 5; i++)
+            {
+                rows[c][i] = this.GetInputRowMemory(inputRows, c, i - 2);
+            }
+        }
+
+        Span<float> sadMul = (yPos % JxlFrameDimensions.BlockDimensions is 0 or JxlFrameDimensions.BlockDimensions - 1)
+            ? sadMulBorder
+            : sadMulCenter;
+
+        for (int x = xStart; x < xEnd; x += Vector256<float>.Count)
+        {
+            int bx = (x + xPos + (JxlDecoderCache.SigmaPadding * JxlFrameDimensions.BlockDimensions)) / JxlFrameDimensions.BlockDimensions;
+            int ix = (x + xPos) % JxlFrameDimensions.BlockDimensions;
+
+            if (rowSigma[bx] < JxlLoopFilter.MinimumSigma)
+            {
+                for (int c = 0; c < 3; c++)
+                {
+                    Vector256<float> px = Vector256.Create((ReadOnlySpan<float>)rows[c][2][x..].Span);
+                    px.CopyTo(GetOutputRow(outputRows, c, 0)[x..]);
+                }
+
+                continue;
+            }
+
+            Vector256<float> vsm = Vector256.Create((ReadOnlySpan<float>)sadMul[ix..]);
+            Vector256<float> inverseSigma = Vector256.Create(rowSigma[bx]) * vsm;
+            Vector256<float> sad0 = Vector256<float>.Zero;
+            Vector256<float> sad1 = Vector256<float>.Zero;
+            Vector256<float> sad2 = Vector256<float>.Zero;
+            Vector256<float> sad3 = Vector256<float>.Zero;
+
+            // Compute sum of absolute differences (SAD)
+            for (int c = 0; c < 3; c++)
+            {
+                // center px = 22, px above = 21
+                Vector256<float> t;
+
+                Vector256<float> p20 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + -2][x..].Span);
+                Vector256<float> p21 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + -1][x..].Span);
+                Vector256<float> sad0c = AbsoluteDifference(p20, p21);  // SAD 2, 1
+
+                Vector256<float> p11 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + -1][(x - 1)..].Span);
+                Vector256<float> sad1c = AbsoluteDifference(p11, p21);  // SAD 1, 2
+
+                Vector256<float> p31 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + -1][(x + 1)..].Span);
+                Vector256<float> sad2c = AbsoluteDifference(p31, p21);  // SAD 3, 2
+
+                Vector256<float> p02 = Vector256.Create((ReadOnlySpan<float>)rows[c][2][(x - 2)..].Span);
+                Vector256<float> p12 = Vector256.Create((ReadOnlySpan<float>)rows[c][2][(x - 1)..].Span);
+                sad1c += AbsoluteDifference(p02, p12);  // SAD 1, 2
+                sad0c += AbsoluteDifference(p11, p12);  // SAD 2, 1
+
+                // TODO(eustas): why unaligned?
+                Vector256<float> p22 = Vector256.Create((ReadOnlySpan<float>)rows[c][2][x..].Span);
+                t = AbsoluteDifference(p12, p22);
+                sad1c += t;  // SAD 1, 2
+                sad2c += t;  // SAD 3, 2
+                t = AbsoluteDifference(p22, p21);
+                Vector256<float> sad3c = t;         // SAD 2, 3
+                sad0c += t;  // SAD 2, 1
+
+                Vector256<float> p32 = Vector256.Create((ReadOnlySpan<float>)rows[c][2][(x + 1)..].Span);
+                sad0c += AbsoluteDifference(p31, p32);  // SAD 2, 1
+                t = AbsoluteDifference(p22, p32);
+                sad1c += t;  // SAD 1, 2
+                sad2c += t;  // SAD 3, 2
+
+                Vector256<float> p42 = Vector256.Create((ReadOnlySpan<float>)rows[c][2][(x + 2)..].Span);
+                sad2c += AbsoluteDifference(p42, p32);  // SAD 3, 2
+
+                Vector256<float> p13 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + 1][(x - 1)..].Span);
+                sad3c += AbsoluteDifference(p13, p12);  // SAD 2, 3
+
+                Vector256<float> p23 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + 1][x..].Span);
+                t = AbsoluteDifference(p22, p23);
+                sad0c += t;                  // SAD 2, 1
+                sad3c += t;                  // SAD 2, 3
+                sad1c += AbsoluteDifference(p13, p23);  // SAD 1, 2
+
+                Vector256<float> p33 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + 1][(x + 1)..].Span);
+                sad2c += AbsoluteDifference(p33, p23);  // SAD 3, 2
+                sad3c += AbsoluteDifference(p33, p32);  // SAD 2, 3
+
+                Vector256<float> p24 = Vector256.Create((ReadOnlySpan<float>)rows[c][2 + 2][x..].Span);
+                sad3c += AbsoluteDifference(p24, p23);  // SAD 2, 3
+
+                Vector256<float> scale = Vector256.Create(this.loopFilter.EpfChannelScale[c]);
+                sad0 = (sad0c * scale) + sad0;
+                sad1 = (sad1c * scale) + sad1;
+                sad2 = (sad2c * scale) + sad2;
+                sad3 = (sad3c * scale) + sad3;
+            }
+
+            Vector256<float> xCC = Vector256.Create((ReadOnlySpan<float>)rows[0][2 + 0][x..].Span);
+            Vector256<float> yCC = Vector256.Create((ReadOnlySpan<float>)rows[1][2 + 0][x..].Span);
+            Vector256<float> bCC = Vector256.Create((ReadOnlySpan<float>)rows[2][2 + 0][x..].Span);
+
+            Vector256<float> w = Vector256<float>.One;
+            Vector256<float> X = xCC;
+            Vector256<float> Y = yCC;
+            Vector256<float> B = bCC;
+
+            // Top row
+            AddPixel(-1, rows, x, sad0, inverseSigma, ref X, ref Y, ref B, ref w);
+
+            // Center
+            AddPixel(0, rows, x - 1, sad1, inverseSigma, ref X, ref Y, ref B, ref w);
+            AddPixel(0, rows, x + 1, sad2, inverseSigma, ref X, ref Y, ref B, ref w);
+
+            // Bottom
+            AddPixel(1, rows, x + 1, sad3, inverseSigma, ref X, ref Y, ref B, ref w);
+
+            Vector256<float> inverseW = Vector256<float>.One / w;
+            (X * inverseW).CopyTo(GetOutputRow(outputRows, 0, 0)[x..]);
+            (Y * inverseW).CopyTo(GetOutputRow(outputRows, 1, 0)[x..]);
+            (B * inverseW).CopyTo(GetOutputRow(outputRows, 2, 0)[x..]);
+        }
+    }
+
+    /// <inheritdoc />
+    public override RenderPipelineChannelMode GetChannelMode(int channel)
+    {
+        if (channel < 3)
+        {
+            return RenderPipelineChannelMode.InOut;
+        }
+        else
+        {
+            return RenderPipelineChannelMode.Ignored;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf2Stage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf2Stage.cs
new file mode 100644
index 0000000000..7100df484c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/Epf2Stage.cs
@@ -0,0 +1,146 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// Edge Preserving Filter (type 2) stage
+/// </summary>
+internal sealed class Epf2Stage : RenderPipelineStageBase
+{
+    private readonly JxlLoopFilter loopFilter;
+    private readonly JxlImageF sigma;
+
+    public Epf2Stage(JxlLoopFilter loopFilter, JxlImageF sigma, Configuration configuration)
+        : base(configuration)
+    {
+        this.loopFilter = loopFilter;
+        this.sigma = sigma;
+        this.Settings = RenderPipelineStageConfiguration.CreateSymmetricBorderOnly(2);
+    }
+
+    /// <inheritdoc />
+    public override string Name => "EPF2";
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> AbsoluteDifference(Vector256<float> x, Vector256<float> y) => Vector256.Abs(x - y);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AddPixel(
+        int row,
+        InlineArray3<InlineArray3<Memory<float>>> rows,
+        int x,
+        Vector256<float> rx,
+        Vector256<float> ry,
+        Vector256<float> rb,
+        Vector256<float> inverseSigma,
+        ref Vector256<float> X,
+        ref Vector256<float> Y,
+        ref Vector256<float> B,
+        ref Vector256<float> w)
+    {
+        Vector256<float> cx = Vector256.Create((ReadOnlySpan<float>)rows[0][1 + row][x..].Span);
+        Vector256<float> cy = Vector256.Create((ReadOnlySpan<float>)rows[1][1 + row][x..].Span);
+        Vector256<float> cb = Vector256.Create((ReadOnlySpan<float>)rows[2][1 + row][x..].Span);
+
+        Vector256<float> sad = AbsoluteDifference(cx, rx) * Vector256.Create(this.loopFilter.EpfChannelScale[0]);
+        sad = (AbsoluteDifference(cy, ry) * Vector256.Create(this.loopFilter.EpfChannelScale[1])) + sad;
+        sad = (AbsoluteDifference(cb, rb) * Vector256.Create(this.loopFilter.EpfChannelScale[2])) + sad;
+
+        Vector256<float> weight = EpfUtils.Weight(sad, inverseSigma);
+        w += weight;
+        X = (weight * cx) + X;
+        Y = (weight * cy) + Y;
+        B = (weight * cb) + B;
+    }
+
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        int xStart = -JxlMath.RoundUpTo(xExtraLeft, Vector256<float>.Count);
+        int xEnd = width + xExtraRight;
+
+        Span<float> rowSigma = this.sigma.GetRow((yPos / JxlFrameDimensions.BlockDimensions) + JxlDecoderCache.SigmaPadding);
+        float sm = 1.65f;
+        float bsm = sm * this.loopFilter.EpfBorderSadMul;
+
+        Span<float> sadMulCenter = [bsm, sm, sm, sm, sm, sm, sm, bsm];
+        Span<float> sadMulBorder = [bsm, bsm, bsm, bsm, bsm, bsm, bsm, bsm];
+
+        InlineArray3<InlineArray3<Memory<float>>> rows = default;
+        for (int c = 0; c < 3; c++)
+        {
+            for (int i = 0; i < 3; i++)
+            {
+                rows[c][i] = this.GetInputRowMemory(inputRows, c, i - 1);
+            }
+        }
+
+        Span<float> sadMul = (yPos % JxlFrameDimensions.BlockDimensions is 0 or JxlFrameDimensions.BlockDimensions - 1)
+            ? sadMulBorder
+            : sadMulCenter;
+
+        for (int x = xStart; x < xEnd; x += Vector256<float>.Count)
+        {
+            int bx = (x + xPos + (JxlDecoderCache.SigmaPadding * JxlFrameDimensions.BlockDimensions)) / JxlFrameDimensions.BlockDimensions;
+            int ix = (x + xPos) % JxlFrameDimensions.BlockDimensions;
+
+            if (rowSigma[bx] < JxlLoopFilter.MinimumSigma)
+            {
+                for (int c = 0; c < 3; c++)
+                {
+                    Vector256<float> px = Vector256.Create((ReadOnlySpan<float>)rows[c][1][x..].Span);
+                    px.CopyTo(GetOutputRow(outputRows, c, 0)[x..]);
+                }
+
+                continue;
+            }
+
+            Vector256<float> vsm = Vector256.Create((ReadOnlySpan<float>)sadMul[ix..]);
+            Vector256<float> inverseSigma = Vector256.Create(rowSigma[bx]) * vsm;
+
+            Vector256<float> xCC = Vector256.Create((ReadOnlySpan<float>)rows[0][1 + 0][x..].Span);
+            Vector256<float> yCC = Vector256.Create((ReadOnlySpan<float>)rows[1][1 + 0][x..].Span);
+            Vector256<float> bCC = Vector256.Create((ReadOnlySpan<float>)rows[2][1 + 0][x..].Span);
+
+            Vector256<float> w = Vector256<float>.One;
+            Vector256<float> X = xCC;
+            Vector256<float> Y = yCC;
+            Vector256<float> B = bCC;
+
+            // Top row
+            this.AddPixel(-1, rows, x, xCC, yCC, bCC, inverseSigma, ref X, ref Y, ref B, ref w);
+
+            // Center
+            this.AddPixel(0, rows, x - 1, xCC, yCC, bCC, inverseSigma, ref X, ref Y, ref B, ref w);
+            this.AddPixel(0, rows, x + 1, xCC, yCC, bCC, inverseSigma, ref X, ref Y, ref B, ref w);
+
+            // Bottom
+            this.AddPixel(1, rows, x, xCC, yCC, bCC, inverseSigma, ref X, ref Y, ref B, ref w);
+
+            Vector256<float> inverseW = Vector256<float>.One / w;
+            (X * inverseW).CopyTo(GetOutputRow(outputRows, 0, 0)[x..]);
+            (Y * inverseW).CopyTo(GetOutputRow(outputRows, 1, 0)[x..]);
+            (B * inverseW).CopyTo(GetOutputRow(outputRows, 2, 0)[x..]);
+        }
+    }
+
+    /// <inheritdoc />
+    public override RenderPipelineChannelMode GetChannelMode(int channel)
+    {
+        if (channel < 3)
+        {
+            return RenderPipelineChannelMode.InOut;
+        }
+        else
+        {
+            return RenderPipelineChannelMode.Ignored;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/EpfStageType.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/EpfStageType.cs
new file mode 100644
index 0000000000..8a85367158
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/EpfStageType.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// Used by the EPF render pipeline stage.
+/// </summary>
+internal enum EpfStageType : byte
+{
+    Zero,
+    One,
+    Two
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/EpfUtils.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/EpfUtils.cs
new file mode 100644
index 0000000000..52150ae27f
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/EpfUtils.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// Utilities for EPF stages.
+/// </summary>
+internal static class EpfUtils
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Weight(Vector256<float> sad, Vector256<float> inverseSigma)
+    {
+        Vector256<float> v = (sad * inverseSigma) + Vector256<float>.One;
+        Vector256<float> whereNegative = Vector256.LessThan(v, Vector256<float>.Zero);
+        Vector256<float> zeroIfNegative = Vector256.ConditionalSelect(whereNegative, Vector256<float>.Zero, whereNegative);
+        return zeroIfNegative;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/GaborishStage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/GaborishStage.cs
new file mode 100644
index 0000000000..fbc83ab214
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/GaborishStage.cs
@@ -0,0 +1,100 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+internal sealed class GaborishStage : RenderPipelineStageBase
+{
+    private InlineArray9<float> weights;
+
+    public GaborishStage(Configuration configuration, JxlLoopFilter lf)
+        : base(configuration)
+    {
+        this.Settings = RenderPipelineStageConfiguration.CreateSymmetricBorderOnly(1);
+
+        this.weights[0] = 1;
+        this.weights[1] = lf.GaborishXWeight1;
+        this.weights[2] = lf.GaborishXWeight2;
+        this.weights[3] = 1;
+        this.weights[4] = lf.GaborishYWeight1;
+        this.weights[5] = lf.GaborishYWeight2;
+        this.weights[6] = 1;
+        this.weights[7] = lf.GaborishBWeight1;
+        this.weights[8] = lf.GaborishBWeight2;
+
+        // Normalization
+        for (int c = 0; c < 3; c++)
+        {
+            int c3 = c * 3; // prevent repeated multiplication
+
+            float div = this.weights[c3] + (4 * (this.weights[c3 + 1] + this.weights[c3 + 2]));
+            float mul = 1.0f / div;
+
+            this.weights[c3] *= mul;
+            this.weights[c3 + 1] *= mul;
+            this.weights[c3 + 2] *= mul;
+        }
+    }
+
+    /// <inheritdoc />
+    public override string Name => "Gab";
+
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        int xStart = -JxlMath.RoundUpTo(xExtraLeft, Vector<float>.Count);
+        int xEnd = width + xExtraRight;
+
+        for (int c = 0; c < 3; c++)
+        {
+            int c3 = c * 3; // prevent repeated multiplication
+
+            Span<float> rowT = this.GetInputRow(inputRows, c, -1);
+            Span<float> rowM = this.GetInputRow(inputRows, c, 0);
+            Span<float> rowB = this.GetInputRow(inputRows, c, 1);
+            Span<float> rowOut = GetOutputRow(outputRows, c, 0);
+
+            Vector<float> w0 = Vector.Create(this.weights[c3]);
+            Vector<float> w1 = Vector.Create(this.weights[c3 + 1]);
+            Vector<float> w2 = Vector.Create(this.weights[c3 + 2]);
+
+            // Ref for performance
+            ref float refRowT = ref MemoryMarshal.GetReference(rowT);
+            ref float refRowM = ref MemoryMarshal.GetReference(rowM);
+            ref float refRowB = ref MemoryMarshal.GetReference(rowB);
+            ref float refRowOut = ref MemoryMarshal.GetReference(rowOut);
+
+            for (int x = xStart; x < xEnd; x += Vector<float>.Count)
+            {
+                Vector<float> t = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowT, x));
+                Vector<float> tl = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowT, x - 1));
+                Vector<float> tr = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowT, x + 1));
+
+                Vector<float> m = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowM, x));
+                Vector<float> l = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowM, x - 1));
+                Vector<float> r = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowM, x + 1));
+
+                Vector<float> b = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowB, x));
+                Vector<float> bl = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowB, x - 1));
+                Vector<float> br = Vector.LoadUnsafe(ref Unsafe.Add(ref refRowB, x + 1));
+
+                Vector<float> sum0 = m;
+                Vector<float> sum1 = (l + r) + (t + b);
+                Vector<float> sum2 = (tl + tr) + (bl + br);
+
+                Vector<float> pixels = (sum2 * w2) + ((sum1 * w1) + (sum0 * w0));
+                pixels.StoreUnsafe(ref Unsafe.Add(ref refRowOut, x));
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    public override RenderPipelineChannelMode GetChannelMode(int channel) =>
+        channel < 3
+            ? RenderPipelineChannelMode.InPlace
+            : RenderPipelineChannelMode.Ignored;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/PatchDictionaryStage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/PatchDictionaryStage.cs
new file mode 100644
index 0000000000..18660007fc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/PatchDictionaryStage.cs
@@ -0,0 +1,39 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Patch;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+internal sealed class PatchDictionaryStage(Configuration configuration, JxlPatchDictionary patches, List<JxlExtraChannelInfo> extraChannelInfos)
+    : RenderPipelineStageBase(configuration)
+{
+    /// <inheritdoc />
+    public override string Name => "Patches";
+
+    /// <inheritdoc />
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        int channels = 3 + extraChannelInfos.Count;
+
+        Span<Memory<float>> rowPtrs = new Memory<float>[channels];
+
+        for (int i = 0; i < channels; i++)
+        {
+            rowPtrs[i] = this.GetInputRowMemory(inputRows, i, 0, xExtraLeft);
+        }
+
+        return patches.AddOneRow(rowPtrs, yPos, xPos - xExtraLeft, width + xExtraLeft + xExtraRight, extraChannelInfos);
+    }
+
+    /// <inheritdoc />
+    public override RenderPipelineChannelMode GetChannelMode(int channel)
+    {
+        int numChannels = 3 + extraChannelInfos.Count;
+        return channel < numChannels
+            ? RenderPipelineChannelMode.InPlace
+            : RenderPipelineChannelMode.Ignored;
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineChannelMode.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineChannelMode.cs
new file mode 100644
index 0000000000..4d936af8f2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineChannelMode.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// Specifies how does a render pipeline stage apply to channels.
+/// </summary>
+internal enum RenderPipelineChannelMode : byte
+{
+    /// <summary>
+    /// Channel is not modified.
+    /// </summary>
+    Ignored,
+
+    /// <summary>
+    /// Channel is in-place.
+    /// </summary>
+    InPlace,
+
+    /// <summary>
+    /// Channel is modified and written to a new buffer.
+    /// </summary>
+    InOut,
+
+    /// <summary>
+    /// Read-only channel.
+    /// </summary>
+    Input
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineStageBase.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineStageBase.cs
new file mode 100644
index 0000000000..07cb0f59db
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineStageBase.cs
@@ -0,0 +1,98 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// Base class for a render pipeline stage.
+/// </summary>
+[DebuggerDisplay($"{{{nameof(Name)}}}")]
+internal abstract class RenderPipelineStageBase(Configuration configuration) : IDisposable
+{
+    private const int RenderPipelineXOffset = 32;
+
+    /// <summary>
+    /// Gets or sets the configuration for this render pipeline stage.
+    /// </summary>
+    public RenderPipelineStageConfiguration Settings { get; set; }
+
+    /// <summary>
+    /// Gets a value indicating whether this stage is initialized and is therefore
+    /// ready to use.
+    /// </summary>
+    public virtual bool IsInitialized => true;
+
+    /// <summary>
+    /// Gets a value indicating whether, from this stage on, the pipeline will operate
+    /// on an image rather than the frame-sized buffer. Only one stage in the pipeline
+    /// should return true, and it should implement <see cref="ProcessPaddingRow(Buffer2D{Memory{float}}, int, int, int)"/>.
+    /// </summary>
+    public virtual bool SwitchToImageDimensions => false;
+
+    /// <summary>
+    /// Gets a friendly name representing this stage.
+    /// </summary>
+    public virtual string Name => "(invalid pipeline stage)";
+
+    /// <summary>
+    /// If any unmanaged or pooled memory is present by the derived stage, releases
+    /// memory used by that.
+    /// </summary>
+    public virtual void Dispose()
+    {
+    }
+
+    public virtual void ProcessRow(
+        Buffer2D<Memory<float>> inputRows,
+        Buffer2D<Memory<float>> outputRows,
+        int xExtraLeft,
+        int xExtraRight,
+        int width,
+        int xPos,
+        int yPos)
+    {
+    }
+
+    /// <summary>
+    /// Represents how each channel will be processed.
+    /// </summary>
+    /// <param name="channel">Desired channel.</param>
+    /// <returns>Mode specifying how the specified channel will be processed.</returns>
+    public virtual RenderPipelineChannelMode GetChannelMode(int channel)
+        => RenderPipelineChannelMode.Ignored;
+
+    public virtual void SetInputSizes(Span<Size> inputSizes)
+    {
+    }
+
+    public Span<float> GetInputRow(Buffer2D<Memory<float>> inputRows, int c, int offset)
+        => inputRows[c, this.Settings.BorderY + offset].Span[RenderPipelineXOffset..];
+
+    public Span<float> GetInputRow(Buffer2D<Memory<float>> inputRows, int c, int offset, int xExtraLeft)
+        => inputRows[c, this.Settings.BorderY + offset].Span[(RenderPipelineXOffset - xExtraLeft)..];
+
+    public Memory<float> GetInputRowMemory(Buffer2D<Memory<float>> inputRows, int c, int offset)
+        => inputRows[c, this.Settings.BorderY + offset][RenderPipelineXOffset..];
+
+    public Memory<float> GetInputRowMemory(Buffer2D<Memory<float>> inputRows, int c, int offset, int xExtraLeft)
+        => inputRows[c, this.Settings.BorderY + offset][(RenderPipelineXOffset - xExtraLeft)..];
+
+    public static Span<float> GetOutputRow(Buffer2D<Memory<float>> outputRows, int c, int offset)
+        => outputRows[c, offset].Span[RenderPipelineXOffset..];
+
+    public virtual void GetImageDimensions(out int width, out int height, out Point frameOrigin)
+    {
+        width = 0;
+        height = 0;
+        frameOrigin = default;
+    }
+
+    public virtual void ProcessPaddingRow(Buffer2D<Memory<float>> outputRows, int width, int xPos, int yPos)
+    {
+    }
+
+    protected Configuration GetConfiguration() => configuration;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineStageConfiguration.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineStageConfiguration.cs
new file mode 100644
index 0000000000..282876b6bc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/RenderPipelineStageConfiguration.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+internal readonly record struct RenderPipelineStageConfiguration(int BorderX, int BorderY, int ShiftX, int ShiftY)
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RenderPipelineStageConfiguration CreateShiftX(int shift, int border) => new(border, 0, shift, 0);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RenderPipelineStageConfiguration CreateShiftY(int shift, int border) => new(0, border, 0, shift);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RenderPipelineStageConfiguration CreateSymmetric(int shift, int border) => new(border, border, shift, shift);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RenderPipelineStageConfiguration CreateSymmetricBorderOnly(int border) => CreateSymmetric(shift: 0, border);
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/SplineStage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/SplineStage.cs
new file mode 100644
index 0000000000..39864265d0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/SplineStage.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+internal sealed class SplineStage(Configuration configuration, JxlSplines splines) : RenderPipelineStageBase(configuration)
+{
+    public override string Name => "Splines";
+
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        Span<float> rowX = this.GetInputRow(inputRows, 0, 0, xExtraLeft);
+        Span<float> rowY = this.GetInputRow(inputRows, 1, 0, xExtraLeft);
+        Span<float> rowB = this.GetInputRow(inputRows, 2, 0, xExtraLeft);
+        splines.AddToRow(rowX, rowY, rowB, yPos, xPos - xExtraLeft, xPos + width + xExtraRight);
+    }
+
+    public override RenderPipelineChannelMode GetChannelMode(int channel) => channel < 3 ? RenderPipelineChannelMode.InPlace : RenderPipelineChannelMode.Ignored;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/SpotColorStage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/SpotColorStage.cs
new file mode 100644
index 0000000000..6b0fc97ed8
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/SpotColorStage.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+internal sealed class SpotColorStage(Configuration configuration, int spotColorOffset, Memory<float> spotColor)
+    : RenderPipelineStageBase(configuration)
+{
+    private readonly int spotC = 3 + spotColorOffset;
+
+    public override string Name => "Spot";
+
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        Span<float> spotColors = spotColor.Span;
+
+        float scale = 0;
+        for (int c = 0; c < 3; c++)
+        {
+            Span<float> p = this.GetInputRow(inputRows, c, 0);
+            Span<float> s = this.GetInputRow(inputRows, this.spotC, 0);
+
+            for (int x = 0; x < width; x++)
+            {
+                float mix = scale * s[x];
+                p[x] = (mix * spotColors[c]) + ((1.0f - mix) * p[x]);
+            }
+        }
+    }
+
+    public override RenderPipelineChannelMode GetChannelMode(int channel)
+        => channel < 3 ? RenderPipelineChannelMode.InPlace
+            : channel == this.spotC ? RenderPipelineChannelMode.Input
+            : RenderPipelineChannelMode.Ignored;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/WriteToOutputStage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/WriteToOutputStage.cs
new file mode 100644
index 0000000000..62ae1a00fa
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/WriteToOutputStage.cs
@@ -0,0 +1,334 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+internal sealed class WriteToOutputStage
+{
+    private const int ChunkSize = 1024;
+
+    private int width;
+    private int height;
+    private IJxlImageOutput main;
+    private int numColors;
+    private bool wantAlpha;
+    private bool hasAlpha;
+    private bool unpremultiplyAlpha;
+    private int alphaC;
+    private bool flipX;
+    private bool flipY;
+    private bool transpose;
+    private readonly List<IJxlImageOutput> extraChannels = [];
+    private readonly List<float> opaqueAlpha = [];
+    private readonly Configuration configuration;
+    private List<Memory<byte>> tempIn;
+    private List<Memory<byte>> tempOut;
+
+    /// <summary>
+    /// Gets the 32x32 blue noise dithering pattern lookup
+    /// table (from <see href="https://github.com/MomentsInGraphics/BlueNoise"/>),
+    /// scaled to have an average of 0 and be fully contained in (0.49219
+    /// to -0.49219). Rows are padded to 48 (32 + 16) to allow SIMD to wrap around
+    /// horizontally.
+    /// </summary>
+    private static ReadOnlySpan<float> DitheringPattern =>
+    [
+        -0.26057f, 0.32619f, 0.21039f, -0.03281f, -0.10616f, 0.16792f, 0.43042f, -0.48061f,
+        -0.00965f, -0.31075f, 0.24899f, -0.35322f, -0.02509f, -0.25285f, 0.02895f, 0.10230f,
+        -0.28373f, -0.00193f, 0.23355f, 0.43428f, -0.23741f, 0.18336f, -0.31847f, -0.11002f,
+        -0.36094f, 0.26057f, -0.19108f, -0.29531f, 0.40726f, -0.09458f, 0.11002f, -0.48833f,
+        -0.26057f, 0.32619f, 0.21039f, -0.03281f, -0.10616f, 0.16792f, 0.43042f, -0.48061f,
+        -0.00965f, -0.31075f, 0.24899f, -0.35322f, -0.02509f, -0.25285f, 0.02895f, 0.10230f,
+        0.16020f, -0.35708f, -0.18336f, 0.36094f, -0.28373f, -0.34550f, -0.20267f, 0.07914f,
+        0.35708f, -0.41498f, 0.47675f, -0.21811f, -0.12546f, 0.44200f, -0.41884f, -0.17178f,
+        0.39954f, 0.33778f, -0.33778f, 0.04053f, -0.46517f, 0.27215f, -0.16792f, 0.39182f,
+        0.20653f, -0.43814f, -0.02895f, 0.17950f, -0.41498f, 0.01737f, 0.24899f, 0.49219f,
+        0.16020f, -0.35708f, -0.18336f, 0.36094f, -0.28373f, -0.34550f, -0.20267f, 0.07914f,
+        0.35708f, -0.41498f, 0.47675f, -0.21811f, -0.12546f, 0.44200f, -0.41884f, -0.17178f,
+        -0.00965f, 0.08300f, 0.41112f, -0.46903f, 0.04053f, 0.47289f, 0.26057f, -0.05983f,
+        -0.13704f, 0.14862f, 0.03281f, 0.29531f, -0.45744f, 0.22583f, 0.14862f, -0.09072f,
+        -0.37638f, 0.19881f, -0.14476f, 0.14476f, -0.09072f, 0.48447f, -0.39954f, 0.06369f,
+        -0.05983f, -0.26829f, 0.43428f, -0.12546f, 0.28759f, -0.22969f, -0.32619f, -0.15248f,
+        -0.00965f, 0.08300f, 0.41112f, -0.46903f, 0.04053f, 0.47289f, 0.26057f, -0.05983f,
+        -0.13704f, 0.14862f, 0.03281f, 0.29531f, -0.45744f, 0.22583f, 0.14862f, -0.09072f,
+        -0.42270f, 0.23741f, -0.23355f, -0.11774f, 0.18722f, 0.11388f, -0.43814f, -0.24899f,
+        0.41884f, 0.21039f, -0.28373f, -0.06756f, 0.07914f, 0.36480f, -0.31075f, 0.30303f,
+        -0.03281f, 0.07142f, -0.42656f, 0.38024f, -0.27987f, 0.00579f, 0.12546f, -0.22197f,
+        0.29917f, 0.36866f, 0.13704f, -0.47289f, 0.09072f, 0.35708f, -0.04825f, 0.38796f,
+        -0.42270f, 0.23741f, -0.23355f, -0.11774f, 0.18722f, 0.11388f, -0.43814f, -0.24899f,
+        0.41884f, 0.21039f, -0.28373f, -0.06756f, 0.07914f, 0.36480f, -0.31075f, 0.30303f,
+        -0.28759f, -0.07142f, 0.44200f, 0.27601f, -0.38024f, -0.16020f, -0.01737f, 0.30303f,
+        -0.33006f, -0.40340f, -0.16792f, 0.40726f, -0.36480f, -0.00579f, -0.19108f, 0.41498f,
+        -0.26443f, 0.46903f, -0.21811f, 0.28759f, -0.04053f, 0.22197f, 0.34550f, -0.44972f,
+        -0.14476f, -0.34164f, 0.04053f, -0.19494f, 0.45358f, -0.37252f, 0.21425f, 0.05597f,
+        -0.28759f, -0.07142f, 0.44200f, 0.27601f, -0.38024f, -0.16020f, -0.01737f, 0.30303f,
+        -0.33006f, -0.40340f, -0.16792f, 0.40726f, -0.36480f, -0.00579f, -0.19108f, 0.41498f,
+        0.31075f, 0.14090f, -0.33778f, 0.00579f, 0.34550f, -0.29917f, 0.38796f, 0.13704f,
+        0.05983f, -0.10230f, 0.34164f, 0.10616f, -0.23741f, 0.19494f, -0.47675f, 0.04439f,
+        -0.39568f, 0.24127f, 0.10616f, -0.49219f, -0.17950f, -0.36094f, -0.30303f, 0.45744f,
+        -0.01351f, 0.24513f, -0.39182f, -0.07528f, 0.18722f, -0.26057f, -0.11002f, -0.45358f,
+        0.31075f, 0.14090f, -0.33778f, 0.00579f, 0.34550f, -0.29917f, 0.38796f, 0.13704f,
+        0.05983f, -0.10230f, 0.34164f, 0.10616f, -0.23741f, 0.19494f, -0.47675f, 0.04439f,
+        0.46903f, -0.17178f, -0.41112f, 0.07528f, -0.09458f, 0.21811f, -0.20267f, -0.48833f,
+        0.44972f, 0.00965f, 0.24127f, -0.42656f, 0.48447f, -0.11774f, 0.26443f, 0.14090f,
+        -0.15634f, -0.07142f, -0.32233f, 0.36094f, 0.42270f, 0.19108f, 0.07142f, -0.11002f,
+        0.15634f, 0.38024f, -0.28759f, 0.27987f, -0.00193f, 0.33006f, 0.11388f, -0.21039f,
+        0.46903f, -0.17178f, -0.41112f, 0.07528f, -0.09458f, 0.21811f, -0.20267f, -0.48833f,
+        0.44972f, 0.00965f, 0.24127f, -0.42656f, 0.48447f, -0.11774f, 0.26443f, 0.14090f,
+        0.02123f, 0.17950f, 0.38024f, -0.24127f, -0.44586f, 0.48833f, -0.03667f, 0.26829f,
+        -0.36866f, -0.22583f, 0.17178f, -0.30689f, 0.29145f, -0.04825f, -0.35322f, 0.43042f,
+        0.34936f, 0.00193f, 0.16792f, -0.12932f, 0.03667f, -0.06756f, 0.31847f, -0.40726f,
+        -0.24513f, 0.09458f, -0.17564f, 0.47675f, -0.43042f, -0.32233f, 0.40340f, 0.26057f,
+        0.02123f, 0.17950f, 0.38024f, -0.24127f, -0.44586f, 0.48833f, -0.03667f, 0.26829f,
+        -0.36866f, -0.22583f, 0.17178f, -0.30689f, 0.29145f, -0.04825f, -0.35322f, 0.43042f,
+        -0.47675f, -0.12160f, -0.04825f, 0.28759f, 0.10230f, 0.15634f, -0.14862f, -0.27601f,
+        0.36094f, -0.12932f, -0.05983f, -0.45358f, -0.17950f, 0.01737f, 0.09458f, -0.29145f,
+        -0.22969f, -0.43428f, 0.45744f, -0.38796f, -0.27601f, -0.21039f, -0.46131f, 0.22969f,
+        0.41112f, -0.05211f, -0.48061f, 0.16406f, 0.05211f, -0.14862f, -0.03281f, -0.36866f,
+        -0.47675f, -0.12160f, -0.04825f, 0.28759f, 0.10230f, 0.15634f, -0.14862f, -0.27601f,
+        0.36094f, -0.12932f, -0.05983f, -0.45358f, -0.17950f, 0.01737f, 0.09458f, -0.29145f,
+        -0.27215f, 0.34164f, -0.31075f, 0.42656f, -0.38410f, -0.32619f, 0.02895f, 0.19881f,
+        0.08300f, 0.42270f, 0.31461f, 0.13318f, 0.45744f, 0.37638f, -0.40726f, 0.31847f,
+        -0.08686f, 0.21425f, 0.29917f, 0.07914f, 0.26829f, 0.13704f, 0.48447f, -0.15248f,
+        0.02509f, -0.34936f, 0.34936f, -0.10230f, 0.42656f, -0.23741f, 0.22583f, 0.09072f,
+        -0.27215f, 0.34164f, -0.31075f, 0.42656f, -0.38410f, -0.32619f, 0.02895f, 0.19881f,
+        0.08300f, 0.42270f, 0.31461f, 0.13318f, 0.45744f, 0.37638f, -0.40726f, 0.31847f,
+        0.44972f, 0.20267f, 0.04825f, -0.21425f, 0.24513f, -0.07142f, 0.39954f, -0.46131f,
+        -0.39568f, -0.01351f, -0.33392f, 0.05597f, -0.26443f, 0.22197f, -0.20653f, 0.15248f,
+        0.04439f, -0.46517f, -0.16406f, -0.04439f, -0.34936f, 0.37252f, -0.01351f, -0.30689f,
+        0.29917f, 0.20653f, -0.26829f, 0.26443f, 0.13318f, -0.39954f, 0.30303f, -0.08686f,
+        0.44972f, 0.20267f, 0.04825f, -0.21425f, 0.24513f, -0.07142f, 0.39954f, -0.46131f,
+        -0.39568f, -0.01351f, -0.33392f, 0.05597f, -0.26443f, 0.22197f, -0.20653f, 0.15248f,
+        -0.42656f, 0.12932f, -0.14476f, -0.46903f, -0.00579f, 0.34936f, -0.18722f, 0.28373f,
+        -0.23741f, 0.22969f, -0.16020f, -0.38024f, -0.08300f, -0.48447f, -0.02123f, -0.14862f,
+        0.48061f, -0.31847f, 0.39568f, -0.24899f, 0.18722f, -0.41884f, 0.10230f, -0.08300f,
+        -0.38796f, 0.06369f, -0.19881f, -0.44972f, 0.00579f, -0.33392f, 0.37252f, -0.19108f,
+        -0.42656f, 0.12932f, -0.14476f, -0.46903f, -0.00579f, 0.34936f, -0.18722f, 0.28373f,
+        -0.23741f, 0.22969f, -0.16020f, -0.38024f, -0.08300f, -0.48447f, -0.02123f, -0.14862f,
+        -0.02509f, -0.35708f, 0.32619f, 0.46517f, 0.17178f, -0.28373f, 0.10616f, 0.47675f,
+        -0.09458f, 0.15248f, 0.43428f, 0.35322f, 0.17564f, 0.27215f, 0.41112f, -0.36480f,
+        0.24899f, 0.11774f, 0.01351f, 0.33006f, -0.11388f, -0.18336f, 0.41884f, -0.23355f,
+        0.16406f, 0.46131f, 0.38410f, -0.04825f, -0.15634f, 0.49219f, 0.17564f, 0.03667f,
+        -0.02509f, -0.35708f, 0.32619f, 0.46517f, 0.17178f, -0.28373f, 0.10616f, 0.47675f,
+        -0.09458f, 0.15248f, 0.43428f, 0.35322f, 0.17564f, 0.27215f, 0.41112f, -0.36480f,
+        0.40726f, 0.23355f, -0.25285f, -0.08300f, -0.41112f, -0.12160f, -0.35708f, 0.05211f,
+        -0.41884f, -0.29531f, 0.02123f, -0.21425f, 0.09844f, -0.30689f, -0.11388f, 0.34550f,
+        -0.26443f, -0.07142f, -0.39954f, 0.44586f, 0.05983f, -0.48833f, 0.24127f, 0.34936f,
+        -0.44200f, -0.12546f, 0.12160f, -0.30303f, 0.27215f, 0.07528f, -0.48447f, -0.29145f,
+        0.40726f, 0.23355f, -0.25285f, -0.08300f, -0.41112f, -0.12160f, -0.35708f, 0.05211f,
+        -0.41884f, -0.29531f, 0.02123f, -0.21425f, 0.09844f, -0.30689f, -0.11388f, 0.34550f,
+        0.28373f, -0.17564f, 0.09458f, 0.02123f, 0.30689f, 0.41884f, 0.20653f, -0.03667f,
+        0.32233f, 0.25671f, -0.45744f, -0.05597f, 0.46517f, -0.41498f, 0.00965f, 0.07142f,
+        -0.44586f, 0.16406f, -0.20653f, 0.21811f, -0.29917f, 0.28759f, -0.05597f, 0.03281f,
+        -0.32619f, -0.00965f, 0.31847f, -0.37252f, 0.18722f, -0.11002f, -0.22969f, -0.06369f,
+        0.28373f, -0.17564f, 0.09458f, 0.02123f, 0.30689f, 0.41884f, 0.20653f, -0.03667f,
+        0.32233f, 0.25671f, -0.45744f, -0.05597f, 0.46517f, -0.41498f, 0.00965f, 0.07142f,
+        -0.39568f, 0.36866f, -0.45744f, -0.31847f, 0.14476f, -0.22583f, -0.49219f, 0.37638f,
+        -0.19494f, -0.13318f, 0.39182f, -0.35322f, 0.29531f, -0.24127f, 0.21039f, -0.18722f,
+        0.45358f, 0.31461f, -0.13318f, -0.01737f, -0.36094f, 0.12932f, -0.25671f, 0.43814f,
+        -0.16792f, 0.23355f, -0.22197f, 0.44972f, -0.42270f, 0.33392f, 0.42656f, 0.11774f,
+        -0.39568f, 0.36866f, -0.45744f, -0.31847f, 0.14476f, -0.22583f, -0.49219f, 0.37638f,
+        -0.19494f, -0.13318f, 0.39182f, -0.35322f, 0.29531f, -0.24127f, 0.21039f, -0.18722f,
+        -0.13318f, 0.19494f, -0.03667f, 0.44972f, 0.24513f, -0.15248f, 0.08300f, -0.33006f,
+        0.00579f, 0.12546f, 0.19494f, 0.05983f, -0.15634f, 0.14476f, 0.36480f, -0.04053f,
+        -0.33006f, 0.25671f, -0.46903f, 0.37252f, 0.48833f, -0.09458f, -0.41112f, 0.19108f,
+        0.08686f, -0.46903f, -0.07528f, 0.04053f, -0.26829f, -0.02895f, 0.22197f, -0.34164f,
+        -0.13318f, 0.19494f, -0.03667f, 0.44972f, 0.24513f, -0.15248f, 0.08300f, -0.33006f,
+        0.00579f, 0.12546f, 0.19494f, 0.05983f, -0.15634f, 0.14476f, 0.36480f, -0.04053f,
+        0.47289f, -0.21811f, 0.06756f, -0.38410f, -0.27987f, -0.06369f, 0.27987f, 0.43814f,
+        -0.25671f, -0.39182f, 0.49219f, -0.27601f, -0.07914f, -0.48061f, 0.42656f, -0.38410f,
+        0.11002f, 0.03667f, -0.27215f, 0.15634f, 0.07528f, -0.22197f, 0.33006f, 0.38410f,
+        -0.34936f, 0.27987f, 0.15248f, 0.40340f, 0.09844f, -0.16406f, -0.46131f, 0.03281f,
+        0.47289f, -0.21811f, 0.06756f, -0.38410f, -0.27987f, -0.06369f, 0.27987f, 0.43814f,
+        -0.25671f, -0.39182f, 0.49219f, -0.27601f, -0.07914f, -0.48061f, 0.42656f, -0.38410f,
+        -0.29531f, 0.31461f, -0.10616f, 0.39954f, 0.01351f, 0.33778f, -0.43814f, 0.17178f,
+        -0.08686f, 0.23741f, -0.44586f, 0.33778f, -0.00193f, -0.31461f, 0.23741f, -0.12932f,
+        -0.22583f, -0.06756f, 0.40340f, -0.16792f, -0.43428f, 0.01351f, -0.14476f, -0.04053f,
+        -0.29145f, 0.46517f, -0.13704f, -0.39182f, -0.32233f, 0.29531f, 0.38410f, 0.16020f,
+        -0.29531f, 0.31461f, -0.10616f, 0.39954f, 0.01351f, 0.33778f, -0.43814f, 0.17178f,
+        -0.08686f, 0.23741f, -0.44586f, 0.33778f, -0.00193f, -0.31461f, 0.23741f, -0.12932f,
+        -0.44200f, 0.26443f, 0.12546f, -0.42270f, 0.21425f, -0.19881f, -0.35708f, 0.04825f,
+        0.36480f, -0.02895f, -0.21425f, 0.09072f, 0.41498f, 0.18336f, 0.04439f, 0.29917f,
+        0.47675f, -0.40340f, 0.27601f, -0.31461f, 0.31075f, 0.17564f, 0.24899f, -0.45744f,
+        0.05597f, -0.19494f, 0.00193f, 0.36094f, 0.24127f, -0.09844f, -0.24513f, -0.00965f,
+        -0.44200f, 0.26443f, 0.12546f, -0.42270f, 0.21425f, -0.19881f, -0.35708f, 0.04825f,
+        0.36480f, -0.02895f, -0.21425f, 0.09072f, 0.41498f, 0.18336f, 0.04439f, 0.29917f,
+        -0.17564f, -0.05597f, -0.34550f, -0.24899f, 0.48061f, 0.15248f, -0.11388f, 0.45358f,
+        -0.16406f, -0.32233f, 0.31461f, -0.11774f, -0.36866f, -0.18722f, -0.25671f, -0.44200f,
+        0.13318f, -0.02123f, 0.19881f, -0.10616f, 0.43042f, -0.36866f, -0.24899f, 0.41112f,
+        0.11002f, 0.21425f, -0.25671f, -0.47675f, -0.04439f, 0.13704f, -0.37252f, 0.43814f,
+        -0.17564f, -0.05597f, -0.34550f, -0.24899f, 0.48061f, 0.15248f, -0.11388f, 0.45358f,
+        -0.16406f, -0.32233f, 0.31461f, -0.11774f, -0.36866f, -0.18722f, -0.25671f, -0.44200f,
+        0.19108f, 0.03667f, 0.35708f, -0.14090f, 0.08300f, -0.02123f, -0.30303f, -0.48061f,
+        0.11774f, 0.20267f, -0.43042f, 0.25285f, 0.14090f, -0.04439f, 0.38796f, 0.34550f,
+        -0.34164f, -0.19494f, 0.05983f, -0.48447f, 0.09844f, -0.00579f, -0.07914f, 0.33778f,
+        -0.41498f, -0.10230f, 0.30689f, 0.17178f, 0.48833f, -0.20267f, 0.07914f, 0.33392f,
+        0.19108f, 0.03667f, 0.35708f, -0.14090f, 0.08300f, -0.02123f, -0.30303f, -0.48061f,
+        0.11774f, 0.20267f, -0.43042f, 0.25285f, 0.14090f, -0.04439f, 0.38796f, 0.34550f,
+        -0.48833f, -0.30689f, 0.41498f, 0.22969f, -0.44586f, 0.32233f, 0.25285f, 0.39182f,
+        -0.23355f, 0.01737f, 0.42270f, -0.27987f, 0.46903f, -0.47289f, 0.02123f, -0.09072f,
+        0.21811f, 0.44586f, -0.25285f, 0.36480f, -0.29145f, 0.47289f, -0.18722f, 0.14476f,
+        -0.31461f, 0.43814f, -0.36094f, 0.04439f, -0.29917f, -0.41884f, 0.25285f, -0.11774f,
+        -0.48833f, -0.30689f, 0.41498f, 0.22969f, -0.44586f, 0.32233f, 0.25285f, 0.39182f,
+        -0.23355f, 0.01737f, 0.42270f, -0.27987f, 0.46903f, -0.47289f, 0.02123f, -0.09072f,
+        0.46131f, 0.11388f, -0.21039f, -0.07528f, -0.38024f, -0.26057f, 0.06369f, -0.05983f,
+        0.29145f, -0.40340f, -0.09072f, 0.06756f, -0.16020f, 0.27601f, -0.31075f, 0.10616f,
+        -0.14090f, -0.43042f, 0.25671f, -0.05211f, -0.13318f, 0.23355f, -0.44972f, 0.02895f,
+        0.26829f, -0.02895f, -0.17950f, 0.37252f, -0.13704f, 0.40726f, 0.01351f, -0.26443f,
+        0.46131f, 0.11388f, -0.21039f, -0.07528f, -0.38024f, -0.26057f, 0.06369f, -0.05983f,
+        0.29145f, -0.40340f, -0.09072f, 0.06756f, -0.16020f, 0.27601f, -0.31075f, 0.10616f,
+        -0.03281f, -0.40340f, 0.27987f, 0.17564f, 0.02509f, 0.44200f, -0.15248f, -0.34550f,
+        0.14862f, -0.19881f, -0.01351f, 0.36866f, -0.38796f, 0.19494f, -0.22197f, 0.32619f,
+        -0.37638f, 0.00193f, 0.30689f, 0.12160f, -0.39182f, 0.16792f, -0.34550f, 0.39954f,
+        -0.23355f, 0.09072f, -0.43428f, 0.22969f, -0.06369f, 0.12546f, -0.35322f, 0.30689f,
+        -0.03281f, -0.40340f, 0.27987f, 0.17564f, 0.02509f, 0.44200f, -0.15248f, -0.34550f,
+        0.14862f, -0.19881f, -0.01351f, 0.36866f, -0.38796f, 0.19494f, -0.22197f, 0.32619f,
+        -0.09844f, 0.06756f, 0.38410f, -0.33392f, -0.18336f, 0.35322f, 0.21039f, -0.42270f,
+        0.48833f, 0.33006f, 0.21811f, -0.33392f, 0.12932f, -0.05211f, 0.39568f, 0.04825f,
+        0.48061f, 0.17950f, -0.31847f, -0.21811f, 0.38024f, 0.05211f, 0.32233f, -0.06756f,
+        -0.12546f, 0.46131f, 0.16020f, -0.25285f, 0.29531f, -0.44972f, 0.17950f, -0.16406f,
+        -0.09844f, 0.06756f, 0.38410f, -0.33392f, -0.18336f, 0.35322f, 0.21039f, -0.42270f,
+        0.48833f, 0.33006f, 0.21811f, -0.33392f, 0.12932f, -0.05211f, 0.39568f, 0.04825f,
+        0.22583f, -0.46131f, -0.27601f, -0.00579f, 0.12932f, -0.47289f, -0.09844f, 0.10230f,
+        -0.28759f, -0.12160f, -0.49219f, -0.24127f, 0.44586f, -0.11388f, -0.45358f, -0.27215f,
+        -0.17178f, -0.07528f, -0.47675f, 0.43042f, -0.02509f, -0.27215f, -0.19108f, 0.19881f,
+        -0.49219f, -0.37252f, 0.33392f, -0.00193f, -0.33006f, -0.20267f, 0.48061f, 0.34164f,
+        0.22583f, -0.46131f, -0.27601f, -0.00579f, 0.12932f, -0.47289f, -0.09844f, 0.10230f,
+        -0.28759f, -0.12160f, -0.49219f, -0.24127f, 0.44586f, -0.11388f, -0.45358f, -0.27215f,
+        -0.22969f, 0.42270f, -0.12160f, 0.31075f, 0.46903f, -0.22583f, 0.27215f, -0.02509f,
+        0.03281f, 0.40340f, 0.25671f, 0.08686f, 0.00965f, 0.29145f, -0.41112f, 0.14090f,
+        0.24513f, 0.34164f, 0.08686f, -0.14862f, 0.27601f, -0.42656f, 0.48447f, 0.09844f,
+        0.26443f, -0.27987f, 0.05597f, -0.10230f, 0.43428f, 0.08686f, 0.02895f, -0.38024f,
+        -0.22969f, 0.42270f, -0.12160f, 0.31075f, 0.46903f, -0.22583f, 0.27215f, -0.02509f,
+        0.03281f, 0.40340f, 0.25671f, 0.08686f, 0.00965f, 0.29145f, -0.41112f, 0.14090f,
+        0.15634f, 0.09458f, -0.36480f, 0.18336f, -0.05211f, -0.40726f, 0.36866f, -0.33778f,
+        -0.19881f, 0.16020f, -0.37638f, -0.16020f, -0.29917f, 0.20267f, 0.41884f, -0.01737f,
+        -0.34936f, -0.24127f, 0.02509f, 0.20653f, -0.36480f, -0.08686f, 0.01737f, -0.33778f,
+        0.41498f, -0.03667f, 0.37638f, -0.17178f, -0.47289f, 0.26829f, -0.28759f, -0.05597f,
+        0.15634f, 0.09458f, -0.36480f, 0.18336f, -0.05211f, -0.40726f, 0.36866f, -0.33778f,
+        -0.19881f, 0.16020f, -0.37638f, -0.16020f, -0.29917f, 0.20267f, 0.41884f, -0.01737f,
+        0.35708f, 0.00193f, 0.25285f, -0.15634f, -0.30303f, 0.06369f, 0.22197f, 0.45358f,
+        -0.43814f, 0.30303f, -0.04053f, 0.46517f, 0.35322f, -0.21039f, 0.06756f, -0.14090f,
+        0.37638f, -0.43042f, 0.45744f, -0.29531f, 0.39568f, 0.14862f, 0.23741f, -0.13704f,
+        -0.21425f, 0.16406f, -0.40726f, 0.22583f, 0.13318f, 0.38796f, -0.12932f, -0.43428f,
+        0.35708f, 0.00193f, 0.25285f, -0.15634f, -0.30303f, 0.06369f, 0.22197f, 0.45358f,
+        -0.43814f, 0.30303f, -0.04053f, 0.46517f, 0.35322f, -0.21039f, 0.06756f, -0.14090f,
+        -0.31461f, -0.20653f, 0.46131f, -0.45358f, 0.39568f, -0.24513f, -0.14090f, 0.11002f,
+        -0.08300f, -0.26829f, 0.05211f, -0.46517f, -0.09844f, -0.39568f, -0.32619f, -0.06369f,
+        0.16792f, 0.28373f, 0.11388f, -0.04439f, -0.18336f, -0.44200f, 0.35322f, -0.26057f,
+        -0.46517f, 0.31075f, -0.07914f, -0.34164f, -0.24513f, -0.02123f, 0.19108f, 0.44200f,
+        -0.31461f, -0.20653f, 0.46131f, -0.45358f, 0.39568f, -0.24513f, -0.14090f, 0.11002f,
+        -0.08300f, -0.26829f, 0.05211f, -0.46517f, -0.09844f, -0.39568f, -0.32619f, -0.06369f,
+        0.04825f, -0.07914f, -0.39954f, 0.12160f, 0.29145f, 0.00965f, -0.37638f, 0.32233f,
+        0.20267f, -0.17564f, 0.39182f, 0.12160f, 0.18336f, 0.32619f, 0.26057f, 0.49219f,
+        -0.48447f, -0.20653f, -0.10616f, -0.38796f, 0.31847f, 0.07528f, -0.01737f, 0.44586f,
+        0.11774f, 0.02509f, 0.47289f, 0.07142f, 0.33392f, -0.38410f, -0.17950f, 0.28373f,
+        0.04825f, -0.07914f, -0.39954f, 0.12160f, 0.29145f, 0.00965f, -0.37638f, 0.32233f,
+        0.20267f, -0.17564f, 0.39182f, 0.12160f, 0.18336f, 0.32619f, 0.26057f, 0.49219f
+    ];
+
+    private static bool ShouldFlipX(JxlExifOrientation orientation) =>
+        orientation is JxlExifOrientation.FlipHorizontal or
+            JxlExifOrientation.Rotate180 or
+            JxlExifOrientation.Rotate270 or
+            JxlExifOrientation.AntiTranspose;
+
+    private static bool ShouldFlipY(JxlExifOrientation orientation) =>
+        orientation is JxlExifOrientation.FlipVertical or
+            JxlExifOrientation.Rotate180 or
+            JxlExifOrientation.Rotate90 or
+            JxlExifOrientation.AntiTranspose;
+
+    private static bool ShouldTranspose(JxlExifOrientation orientation) =>
+        orientation is JxlExifOrientation.Transpose or
+            JxlExifOrientation.Rotate90 or
+            JxlExifOrientation.Rotate270 or
+            JxlExifOrientation.AntiTranspose;
+
+    private unsafe void UnpremultiplyAlpha(int threadId, int len, float** lineBuffers)
+    {
+        // Highly unsafe code! ⚠️
+        float** tempIn = stackalloc float*[4];
+        Vector<float> one = Vector<float>.One;
+
+        for (int c = 0; c < this.main.PixelFormat.Channels; ++c)
+        {
+            // size_t tix = thread_id * main_.num_channels_ + c;
+            // temp_in[c] = temp_in_[tix].address<float>();
+            // memcpy(temp_in[c], line_buffers[c], sizeof(float) * len);
+            int tix = (threadId * this.main.PixelFormat.Channels) + c;
+
+            tempIn[c] = (float*)Unsafe.AsPointer(ref MemoryMarshal.Cast<byte, float>(this.tempIn[tix].Span)[0]);
+
+            MemoryMarshal.CreateSpan(ref Unsafe.AsRef<float>(lineBuffers[c]), len)
+                .CopyTo(MemoryMarshal.CreateSpan(ref Unsafe.AsRef<float>(tempIn[c]), len));
+        }
+
+        Vector<float> smallAlpha = Vector.Create(SmallAlpha);
+
+        for (int ix = 0; ix < len; ix += Vector<float>.Count)
+        {
+            float* ptr = tempIn[this.numColors + ix];
+
+            // Using an aligned and unaligned branch
+            // REVIEW: does the branch outweigh alignment? we will have to benchmark this
+            // when the codec can build
+            if (JxlUnsafe.IsSimdAligned(ptr))
+            {
+                Vector<float> alpha = Vector.LoadAlignedNonTemporal(tempIn[this.numColors] + ix);
+                Vector<float> mul = one / Vector.Max(smallAlpha, alpha);
+
+                for (int c = 0; c < this.numColors; ++c)
+                {
+                    float* currPtr = tempIn[c] + ix;
+
+                    if (JxlUnsafe.IsSimdAligned(currPtr))
+                    {
+                        Vector<float> val = Vector.LoadAlignedNonTemporal(currPtr);
+                        Vector.StoreAlignedNonTemporal(val * mul, currPtr);
+                    }
+                    else
+                    {
+                        Vector<float> val = Vector.Load(currPtr);
+                        Vector.Store(val * mul, currPtr);
+                    }
+                }
+            }
+            else
+            {
+                Vector<float> alpha = Vector.Load(tempIn[this.numColors] + ix);
+                Vector<float> mul = one / Vector.Max(smallAlpha, alpha);
+
+                for (int c = 0; c < this.numColors; ++c)
+                {
+                    float* currPtr = tempIn[c] + ix;
+
+                    if (JxlUnsafe.IsSimdAligned(currPtr))
+                    {
+                        Vector<float> val = Vector.LoadAlignedNonTemporal(currPtr);
+                        Vector.StoreAlignedNonTemporal(val * mul, currPtr);
+                    }
+                    else
+                    {
+                        Vector<float> val = Vector.Load(currPtr);
+                        Vector.Store(val * mul, currPtr);
+                    }
+                }
+            }
+        }
+
+        for (int c = 0; c < this.main.PixelFormat.Channels; c++)
+        {
+            fixed (byte* ptr = this.tempIn[c].Span)
+            {
+                lineBuffers[c] = (float*)ptr;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/YCbCrStage.cs b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/YCbCrStage.cs
new file mode 100644
index 0000000000..7c6ad0362b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/RenderPipeline/YCbCrStage.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.RenderPipeline;
+
+/// <summary>
+/// SIMD-based conversion from Y'Cb'Cr to RGB pixel buffers.
+/// </summary>
+internal sealed class YCbCrStage(Configuration configuration) : RenderPipelineStageBase(configuration)
+{
+    /// <inheritdoc />
+    public override string Name => "YCbCr";
+
+    /// <inheritdoc />
+    public override void ProcessRow(Buffer2D<Memory<float>> inputRows, Buffer2D<Memory<float>> outputRows, int xExtraLeft, int xExtraRight, int width, int xPos, int yPos)
+    {
+        // Vectors for conversion, defined by the ITU
+        Vector<float> c128 = Vector.Create(128.0f / 255);
+        Vector<float> crcr = Vector.Create(1.402f);
+        Vector<float> cgcb = Vector.Create(-0.114f * 1.772f / 0.587f);
+        Vector<float> cgcr = Vector.Create(-0.299f * 1.402f / 0.587f);
+        Vector<float> cbcb = Vector.Create(1.772f);
+
+        Span<float> row0 = this.GetInputRow(inputRows, 0, 0);
+        Span<float> row1 = this.GetInputRow(inputRows, 1, 0);
+        Span<float> row2 = this.GetInputRow(inputRows, 2, 0);
+
+        // Using refs for better performance
+        ref float row0Ref = ref MemoryMarshal.GetReference(row0);
+        ref float row1Ref = ref MemoryMarshal.GetReference(row1);
+        ref float row2Ref = ref MemoryMarshal.GetReference(row2);
+
+        for (int x = 0; x < width; x += Vector<float>.Count)
+        {
+            // Y'Cb'Cr input vectors
+            Vector<float> yVec = Vector.LoadUnsafe(ref Unsafe.Add(ref row1Ref, x)) + c128;
+            Vector<float> cbVec = Vector.LoadUnsafe(ref Unsafe.Add(ref row0Ref, x));
+            Vector<float> crVec = Vector.LoadUnsafe(ref Unsafe.Add(ref row2Ref, x));
+
+            // RGB output vectors
+            Vector<float> rVec = (crcr * crVec) + yVec;
+            Vector<float> gVec = (cgcr * crVec) + ((cgcb * cbVec) + yVec);
+            Vector<float> bVec = (cbcb * cbVec) + yVec;
+
+            // Copying to the output...
+            rVec.StoreUnsafe(ref Unsafe.Add(ref row0Ref, x));
+            gVec.StoreUnsafe(ref Unsafe.Add(ref row1Ref, x));
+            bVec.StoreUnsafe(ref Unsafe.Add(ref row2Ref, x));
+        }
+    }
+
+    /// <inheritdoc />
+    public override RenderPipelineChannelMode GetChannelMode(int channel) =>
+        channel < 3
+            ? RenderPipelineChannelMode.InPlace
+            : RenderPipelineChannelMode.Ignored;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/Dct32.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/Dct32.cs
new file mode 100644
index 0000000000..e7509e8c05
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/Dct32.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+/// <summary>
+/// Storage for 32 DCT coefficients (floating-point).
+/// </summary>
+[InlineArray(32)]
+internal struct Dct32
+{
+    private float first;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlControlPoint.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlControlPoint.cs
new file mode 100644
index 0000000000..48d94b3455
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlControlPoint.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+/// <summary>
+/// A simple pair of first and second 32-bit signed integers
+/// that represent a single control point.
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+internal struct JxlControlPoint(int first, int second)
+{
+    public int First = first;
+    public int Second = second;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlQuantizedSpline.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlQuantizedSpline.cs
new file mode 100644
index 0000000000..e87f08a09a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlQuantizedSpline.cs
@@ -0,0 +1,329 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal sealed class JxlQuantizedSpline : IDisposable
+{
+    private IMemoryOwner<JxlControlPoint>? memoryOwner;
+
+    public JxlQuantizedSpline()
+    {
+        for (int i = 0; i < 3; i++)
+        {
+            this.ColorDct[i] = new int[32];
+        }
+    }
+
+    private static ReadOnlySpan<int> Loops => [1, 0, 2];
+
+    private static ReadOnlySpan<float> ChannelWeight => [0.0042f, 0.075f, 0.07f, .3333f];
+
+    public Memory<JxlControlPoint> ControlPoints { get; set; }
+
+    // NOTE: Do not use Configuration.MemoryAllocator.Allocate2D. This is
+    // a 3x32 array, and renting memory introduces too much overhead for
+    // 384 bytes of memory.
+    // Additionally, prefer jagged arrays instead of multidimensional arrays
+    // for performance.
+    public int[][] ColorDct { get; set; } = new int[3][];
+
+    public int[] SigmaDct { get; set; } = new int[32];
+
+    public void Dispose()
+    {
+        this.memoryOwner?.Dispose();
+        this.ControlPoints = Memory<JxlControlPoint>.Empty;
+    }
+
+    public void ReserveControlPoints(Configuration configuration, int n)
+    {
+        this.memoryOwner = configuration.MemoryAllocator.Allocate<JxlControlPoint>(n);
+
+        this.ControlPoints = this.memoryOwner.Memory;
+    }
+
+    public static JxlQuantizedSpline Create(Configuration configuration, JxlSpline original, int quantizationAdjustment, float yToX, float yToB)
+    {
+        JxlQuantizedSpline spline = new();
+        Span<PointF> controlPoints = original.ControlPoints.Span;
+
+        spline.ReserveControlPoints(configuration, controlPoints.Length - 1);
+
+        PointF startingPoint = controlPoints[0];
+        int previousX = (int)MathF.Round(startingPoint.X);
+        int previousY = (int)MathF.Round(startingPoint.Y);
+        int previousDx = 0; // D stands for delta
+        int previousDy = 0; // D stands for delta
+
+        int length = original.ControlPoints.Length;
+        IMemoryOwner<JxlControlPoint> newControls = configuration.MemoryAllocator.Allocate<JxlControlPoint>(length);
+        Span<JxlControlPoint> controlsSpan = newControls.Memory.Span;
+
+        for (int i = 0; i < length; i++)
+        {
+            PointF controlPoint = controlPoints[i];
+
+            int newX = (int)MathF.Round(controlPoint.X);
+            int newY = (int)MathF.Round(controlPoint.Y);
+            int newDx = newX - previousX;   // D stands for delta
+            int newDy = newY - previousY;   // D stands for delta
+
+            controlsSpan[i] = new(newDx - previousDx, newDy - previousDy);
+
+            previousDx = newDx;
+            previousDy = newDy;
+            previousX = newX;
+            previousY = newY;
+        }
+
+        float quant = AdjustedQuant(quantizationAdjustment);
+        float inverseQuant = InverseAdjustedQuant(quantizationAdjustment);
+
+        for (int j = 0; j < 3; j++)
+        {
+            int c = Loops[j];
+
+            float factor = (c == 0) ? yToX : (c == 1) ? 0 : yToB;
+
+            // TODO: lower amount of branches by duplicating code
+            // for i=0 and adding a separate loop for i=1..31
+            for (int i = 0; i < 32; i++)
+            {
+                float dctFactor = (i == 0) ? JxlDctScales.Sqrt2 : 1.0f;
+                float inverseDctFactor = (i == 0) ? JxlDctScales.Sqrt05 : 1.0f;
+                float restoredY = spline.ColorDct[1][i] * inverseDctFactor * ChannelWeight[1] * inverseQuant;
+                float decorrelated = spline.ColorDct[c][i] - (factor * restoredY);
+                spline.ColorDct[c][i] = ConvertToInteger(decorrelated * dctFactor * quant / ChannelWeight[c]);
+            }
+        }
+
+        for (int i = 0; i < 32; i++)
+        {
+            float dctFactor = (i == 0) ? JxlDctScales.Sqrt2 : 1.0f;
+            spline.SigmaDct[i] = ConvertToInteger(original.SigmaDct[i] * dctFactor * quant / ChannelWeight[1]);
+        }
+
+        return spline;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static int ConvertToInteger(float value)
+        {
+            const float max = int.MaxValue - 127f;
+            const float min = -max;
+
+            return (int)MathF.Round(Math.Clamp(value, min, max));
+        }
+    }
+
+    public bool Dequantize(
+        Configuration configuration,
+        PointF startingPoint,
+        int quantizationAdjustment,
+        float yToX,
+        float yToB,
+        long imageSize,
+        ref long totalEstimatedAreaReached,
+        JxlSpline result)
+    {
+        long areaLimit = Math.Min(1024 * imageSize * (1L << 32), 1L << 42);
+        result.ClearControlPoints();
+        result.ReserveControlPoints(configuration, this.ControlPoints.Length + 1);
+
+        float px = MathF.Round(startingPoint.X);
+        float py = MathF.Round(startingPoint.Y);
+
+        if (!this.ValidateSplinePointPos(px, py))
+        {
+            throw new InvalidOperationException("Spline points out of range");
+        }
+
+        int currentX = (int)px;
+        int currentY = (int)py;
+
+        Span<PointF> controlPoints = result.ControlPoints.Span;
+        Span<JxlControlPoint> thisControlPoints = this.ControlPoints.Span;
+
+        controlPoints[0] = new(currentX, currentY);
+
+        int currentDx = 0;  // D stands for delta
+        int currentDy = 0;  // D stands for delta
+
+        long manhattanDistance = 0;
+
+        int length = this.ControlPoints.Length;
+
+        for (int i = 0; i < length; i++)
+        {
+            JxlControlPoint point = thisControlPoints[i];
+            currentDx += point.First;
+            currentDy += point.Second;
+            manhattanDistance = Math.Abs(currentDx) + Math.Abs(currentDy);
+
+            if (manhattanDistance > areaLimit)
+            {
+                throw new InvalidOperationException("Manhattan distance is too large");
+            }
+
+            if (!ValidateSplinePointPos(currentDx, currentDy))
+            {
+                throw new InvalidOperationException("Delta points out of range");
+            }
+
+            currentX += currentDx;
+            currentY += currentDy;
+
+            if (!ValidateSplinePointPos(currentX, currentY))
+            {
+                throw new InvalidOperationException("Current points out of range");
+            }
+
+            controlPoints[i + 1] = new(currentX, currentY);
+        }
+
+        float inverseQuant = InverseAdjustedQuant(quantizationAdjustment);
+
+        for (int c = 0; c < 3; c++)
+        {
+            for (int i = 0; i < 32; i++)
+            {
+                float inverseDctFactor = (i == 0) ? JxlDctScales.Sqrt05 : 1.0f;
+                result.ColorDct[c][i] = this.ColorDct[c][i] * inverseDctFactor * ChannelWeight[c] * inverseQuant;
+            }
+        }
+
+        for (int i = 0; i < 32; i++)
+        {
+            result.ColorDct[0][i] += yToX * result.ColorDct[1][i];
+            result.ColorDct[2][i] += yToB * result.ColorDct[1][i];
+        }
+
+        long widthEstimate = 0;
+        Span<long> color = stackalloc long[3];
+
+        for (int c = 0; c < 3; c++)
+        {
+            for (int i = 0; i < 32; i++)
+            {
+                color[c] += (long)MathF.Ceiling(inverseQuant * MathF.Abs(this.ColorDct[c][i]));
+            }
+        }
+
+        color[0] += (long)MathF.Ceiling(MathF.Abs(yToX)) * color[1];
+        color[2] += (long)MathF.Ceiling(MathF.Abs(yToB)) * color[1];
+
+        long maxColor = Math.Max(color[1], Math.Max(color[0], color[2]));
+        long logColor = Math.Max(1L, JxlMath.CeilLog2Nonzero(1L + maxColor));
+        float weightLimit = MathF.Ceiling(MathF.Sqrt((float)areaLimit / logColor) / MathF.Max(1, manhattanDistance));
+
+        for (int i = 0; i < 32; i++)
+        {
+            float inverseDctFactor = (i == 0) ? JxlDctScales.Sqrt05 : 1.0f;
+            result.SigmaDct[i] = this.SigmaDct[i] * inverseDctFactor * ChannelWeight[3] * inverseQuant;
+            float weightF = MathF.Ceiling(inverseQuant * MathF.Abs(this.SigmaDct[i]));
+            long weight = (long)Math.Min(weightLimit, Math.Max(1.0f, weightF));
+            widthEstimate += weight * weight * logColor;
+        }
+
+        totalEstimatedAreaReached = widthEstimate * manhattanDistance;
+        if (totalEstimatedAreaReached > areaLimit)
+        {
+            throw new InvalidOperationException("Total estimated area is too large");
+        }
+
+        return true;
+    }
+
+    public bool TryDecode(
+        Configuration configuration,
+        Span<byte> contextMap,
+        JxlAnsSymbolReader decoder,
+        JxlBitReader br,
+        int maxControlPoints,
+        ref int totalControlPoints)
+    {
+        int numControlPoints = decoder.ReadHybridUnsignedInteger(NumControlPointsContext, br, contextMap);
+        if (numControlPoints > maxControlPoints)
+        {
+            throw new InvalidOperationException("Too many control points");
+        }
+
+        totalControlPoints += numControlPoints;
+
+        if (totalControlPoints >= maxControlPoints)
+        {
+            throw new InvalidOperationException("Too many control points");
+        }
+
+        this.ResizeControlPoints(configuration, numControlPoints);
+
+        const long deltaLimit = 1L << 30;
+        Span<JxlControlPoint> controlPoints = this.ControlPoints.Span;
+
+        int length = this.ControlPoints.Length;
+
+        for (int i = 0; i < length; i++)
+        {
+            ref JxlControlPoint controlPoint = ref controlPoints[i];
+
+            controlPoint.First = JxlPackSigned.UnpackSigned(decoder.ReadHybridUnsignedInteger(ControlPointsContext, br, contextMap));
+            controlPoint.Second = JxlPackSigned.UnpackSigned(decoder.ReadHybridUnsignedInteger(ControlPointsContext, br, contextMap));
+
+            if (controlPoint.First >= deltaLimit || controlPoint.First <= -deltaLimit ||
+                controlPoint.Second >= deltaLimit || controlPoint.Second <= -deltaLimit)
+            {
+                throw new InvalidOperationException("Spline delta-delta is out of bounds");
+            }
+        }
+
+        for (int i = 0; i < this.ColorDct.Length; i++)
+        {
+            if (!TryDecodeDct(contextMap, this.ColorDct[i]))
+            {
+                return false;
+            }
+        }
+
+        if (!TryDecodeDct(contextMap, this.SigmaDct))
+        {
+            return false;
+        }
+
+        return true;
+
+        bool TryDecodeDct(ReadOnlySpan<byte> contextMap, Span<int> dct)
+        {
+            const int invalidCoefficient = int.MinValue;
+
+            for (int i = 0; i < 32; i++)
+            {
+                dct[i] = JxlPackSigned.UnpackSigned(decoder.ReadHybridUnsignedInteger(DctContext, br, contextMap));
+                if (dct[i] == invalidCoefficient)
+                {
+                    throw new InvalidOperationException("The DCT coefficient is invalid");
+                }
+            }
+
+            return true;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float AdjustedQuant(int adjustment)
+        => (adjustment >= 0)
+            ? (1f + (.125f * adjustment))
+            : 1f / (1f - (.125f * adjustment));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float InverseAdjustedQuant(int adjustment)
+        => (adjustment >= 0)
+                ? 1f / (1f + (.125f * adjustment))
+                : (1f - (.125f * adjustment));
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSpline.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSpline.cs
new file mode 100644
index 0000000000..e3c35d5e09
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSpline.cs
@@ -0,0 +1,39 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal sealed class JxlSpline : IDisposable
+{
+    private IMemoryOwner<PointF>? controlPoints;
+
+    public Memory<PointF> ControlPoints { get; private set; }
+
+    public Dct32[] ColorDct { get; set; } = [];
+
+    public Dct32 SigmaDct { get; set; }
+
+    public void ClearControlPoints()
+    {
+        this.controlPoints?.Dispose();
+        this.controlPoints = null;
+
+        this.ControlPoints = Memory<PointF>.Empty;
+    }
+
+    public void ReserveControlPoints(Configuration configuration, int n)
+    {
+        this.ClearControlPoints();
+
+        this.controlPoints = configuration.MemoryAllocator.Allocate<PointF>(n);
+        this.ControlPoints = this.controlPoints.Memory;
+    }
+
+    public void Dispose()
+    {
+        this.ClearControlPoints();
+        GC.SuppressFinalize(this);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineDataView.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineDataView.cs
new file mode 100644
index 0000000000..7b3822d783
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineDataView.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal sealed class JxlSplineDataView
+{
+    public List<JxlQuantizedSpline> Splines { get; set; } = [];
+
+    public List<PointF> StartingPoints { get; set; } = [];
+
+    public bool HasAny => this.Splines.Count > 0;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineEntropyContext.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineEntropyContext.cs
new file mode 100644
index 0000000000..b6be2fe517
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineEntropyContext.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal enum JxlSplineEntropyContext : byte
+{
+    QuantizationAdjustment,
+    StartingPosition,
+    NumSplines,
+    NumControlPoints,
+    ControlPoints,
+    Dct,
+    NumSplineContexts
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineSegment.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineSegment.cs
new file mode 100644
index 0000000000..fd9a068edd
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineSegment.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal struct JxlSplineSegment
+{
+    public PointF Center { get; set; }
+
+    public float MaximumDistance { get; set; }
+
+    public float InverseSigma { get; set; }
+
+    public float SigmaOver4TimesIntensity { get; set; }
+
+    public InlineArray3<float> Color { get; set; }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineSegmentSpan.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineSegmentSpan.cs
new file mode 100644
index 0000000000..2c65b1695d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineSegmentSpan.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal struct JxlSplineSegmentSpan(int startInclusive, int endInclusive)
+{
+    public int StartInclusive { get; set; } = startInclusive;
+
+    public int EndInclusive { get; set; } = endInclusive;
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineUtils.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineUtils.cs
new file mode 100644
index 0000000000..93f240da0d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplineUtils.cs
@@ -0,0 +1,396 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Dct;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal static class JxlSplineUtils
+{
+    public const float DesiredRenderingDistance = 1f;
+
+    private const float PiBy32 = MathF.PI / 32;
+
+    private static ReadOnlySpan<float> ContinuousIDCTMultipliers =>
+    [
+        PiBy32 * 0,  PiBy32 * 1,  PiBy32 * 2,  PiBy32 * 3,  PiBy32 * 4,
+        PiBy32 * 5,  PiBy32 * 6,  PiBy32 * 7,  PiBy32 * 8,  PiBy32 * 9,
+        PiBy32 * 10, PiBy32 * 11, PiBy32 * 12, PiBy32 * 13, PiBy32 * 14,
+        PiBy32 * 15, PiBy32 * 16, PiBy32 * 17, PiBy32 * 18, PiBy32 * 19,
+        PiBy32 * 20, PiBy32 * 21, PiBy32 * 22, PiBy32 * 23, PiBy32 * 24,
+        PiBy32 * 25, PiBy32 * 26, PiBy32 * 27, PiBy32 * 28, PiBy32 * 29,
+        PiBy32 * 30, PiBy32 * 31,
+    ];
+
+    public static float ContinuousInverseDCT(in Dct32 dct, float t)
+    {
+        ref float multipliers = ref MemoryMarshal.GetReference(ContinuousIDCTMultipliers);
+        ReadOnlySpan<float> dctData = dct;
+        ref float dctDataRef = ref MemoryMarshal.GetReference(dctData);
+
+        if (Vector<float>.Count <= 32 && Vector.IsHardwareAccelerated)
+        {
+            Vector<float> result = Vector<float>.Zero;
+            Vector<float> tandhalf = Vector.Create(t + 0.5f);
+
+            for (int i = 0; i < 32; i += Vector<float>.Count)
+            {
+                Vector<float> cosArg = Vector.LoadUnsafe(ref Unsafe.Add(ref multipliers, i)) * tandhalf;
+                Vector<float> cos = Vector.Cos(cosArg);
+                Vector<float> localRes = Vector.LoadUnsafe(ref Unsafe.Add(ref dctDataRef, i)) * cos;
+                result = (Vector.Create(JxlDctScales.Sqrt2) * localRes) + result;
+            }
+
+            return Vector.Sum(result);
+        }
+
+        // Might have SIMD support but Vector<T> > 32 (e.g. on some CPUs),
+        // so let's try different fixed-size vectors first.
+        else if (Vector512.IsHardwareAccelerated)
+        {
+            Vector512<float> result = Vector512<float>.Zero;
+            Vector512<float> tandhalf = Vector512.Create(t + 0.5f);
+
+            for (int i = 0; i < 32; i += Vector512<float>.Count)
+            {
+                Vector512<float> cosArg = Vector512.LoadUnsafe(ref Unsafe.Add(ref multipliers, i)) * tandhalf;
+                Vector512<float> cos = Vector512.Cos(cosArg);
+                Vector512<float> localRes = Vector512.LoadUnsafe(ref Unsafe.Add(ref dctDataRef, i)) * cos;
+                result = (Vector512.Create(JxlDctScales.Sqrt2) * localRes) + result;
+            }
+
+            return Vector512.Sum(result);
+        }
+        else if (Vector256.IsHardwareAccelerated)
+        {
+            Vector256<float> result = Vector256<float>.Zero;
+            Vector256<float> tandhalf = Vector256.Create(t + 0.5f);
+
+            for (int i = 0; i < 32; i += Vector256<float>.Count)
+            {
+                Vector256<float> cosArg = Vector256.LoadUnsafe(ref Unsafe.Add(ref multipliers, i)) * tandhalf;
+                Vector256<float> cos = Vector256.Cos(cosArg);
+                Vector256<float> localRes = Vector256.LoadUnsafe(ref Unsafe.Add(ref dctDataRef, i)) * cos;
+                result = (Vector256.Create(JxlDctScales.Sqrt2) * localRes) + result;
+            }
+
+            return Vector256.Sum(result);
+        }
+        else if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<float> result = Vector128<float>.Zero;
+            Vector128<float> tandhalf = Vector128.Create(t + 0.5f);
+
+            for (int i = 0; i < 32; i += Vector128<float>.Count)
+            {
+                Vector128<float> cosArg = Vector128.LoadUnsafe(ref Unsafe.Add(ref multipliers, i)) * tandhalf;
+                Vector128<float> cos = Vector128.Cos(cosArg);
+                Vector128<float> localRes = Vector128.LoadUnsafe(ref Unsafe.Add(ref dctDataRef, i)) * cos;
+                result = (Vector128.Create(JxlDctScales.Sqrt2) * localRes) + result;
+            }
+
+            return Vector128.Sum(result);
+        }
+        else if (Vector64.IsHardwareAccelerated)
+        {
+            Vector64<float> result = Vector64<float>.Zero;
+            Vector64<float> tandhalf = Vector64.Create(t + 0.5f);
+
+            for (int i = 0; i < 32; i += Vector64<float>.Count)
+            {
+                Vector64<float> cosArg = Vector64.LoadUnsafe(ref Unsafe.Add(ref multipliers, i)) * tandhalf;
+                Vector64<float> cos = Vector64.Cos(cosArg);
+                Vector64<float> localRes = Vector64.LoadUnsafe(ref Unsafe.Add(ref dctDataRef, i)) * cos;
+                result = (Vector64.Create(JxlDctScales.Sqrt2) * localRes) + result;
+            }
+
+            return Vector64.Sum(result);
+        }
+        else
+        {
+            // Scalar fallback.
+            float result = 0f;
+            float tandhalf = t + 0.5f;
+
+            for (int i = 0; i < 32; i++)
+            {
+                float cosArg = Unsafe.Add(ref multipliers, i) * tandhalf;
+                float cos = MathF.Cos(cosArg);
+                float localRes = Unsafe.Add(ref dctDataRef, i) * cos;
+                result = (JxlDctScales.Sqrt2 * localRes) + result;
+            }
+
+            return result;
+        }
+    }
+
+    // SIMD version
+    private static void DrawSegmentPacked(ref JxlSplineSegment segment, bool add, int y, int x, int x0, InlineArray3<Memory<float>> rows)
+    {
+        Vector<float> inverseSigma = Vector.Create(segment.InverseSigma);
+        Vector<float> half = Vector.Create(0.5f);
+        Vector<float> oneOver2s2 = Vector.Create(0.353553391f);
+        Vector<float> sigmaOver4TimesIntensity = Vector.Create(segment.SigmaOver4TimesIntensity);
+
+        Vector<float> dx = JxlSimdUtils.Iota(x + x0).As<int, float>() - Vector.Create(segment.Center.X);
+        Vector<float> dy = Vector.Create(y - segment.Center.Y);
+
+        Vector<float> sqd = (dx * dx) + (dy * dy);
+        Vector<float> distance = Vector.SquareRoot(sqd);
+
+        Vector<float> oneDimensionalFactor =
+            JxlSimdUtils.FastErff(((distance * half) + oneOver2s2) * inverseSigma)
+            - JxlSimdUtils.FastErff(((distance * half) - oneOver2s2) * inverseSigma);
+
+        Vector<float> localIntensity = sigmaOver4TimesIntensity * (oneDimensionalFactor * oneDimensionalFactor);
+
+        for (int c = 0; c < 3; c++)
+        {
+            Span<float> currRow = rows[c].Span;
+            ref float currRowRef = ref MemoryMarshal.GetReference(currRow);
+
+            // TODO: move the add branch outside the loop and duplicate the
+            // loops twice? this removes the branch
+            Vector<float> cm = Vector.Create(add ? segment.Color[c] : -segment.Color[c]);
+
+            Vector<float> @in = Vector.LoadUnsafe(ref Unsafe.Add(ref currRowRef, x));
+            ((cm * localIntensity) + @in).StoreUnsafe(ref Unsafe.Add(ref currRowRef, x));
+        }
+    }
+
+    // Scalar version (for remaining items left to process)
+    private static void DrawSegmentScalar(ref JxlSplineSegment segment, bool add, int y, int x, int x0, InlineArray3<Memory<float>> rows)
+    {
+        float inverseSigma = segment.InverseSigma;
+        float half = 0.5f;
+        float oneOver2s2 = 0.353553391f;
+        float sigmaOver4TimesIntensity = segment.SigmaOver4TimesIntensity;
+
+        float dx = (x + x0) - segment.Center.X;
+        float dy = y - segment.Center.Y;
+
+        float sqd = (dx * dx) + (dy * dy);
+        float distance = MathF.Sqrt(sqd);
+
+        float oneDimensionalFactor =
+            JxlSimdUtils.FastErff(((distance * half) + oneOver2s2) * inverseSigma)
+            - JxlSimdUtils.FastErff(((distance * half) - oneOver2s2) * inverseSigma);
+
+        float localIntensity = sigmaOver4TimesIntensity * (oneDimensionalFactor * oneDimensionalFactor);
+
+        for (int c = 0; c < 3; c++)
+        {
+            Span<float> currRow = rows[c].Span;
+            float cm = add ? segment.Color[c] : -segment.Color[c];
+            currRow[x] = (cm * localIntensity) + currRow[x];
+        }
+    }
+
+    public static void DrawSegment(ref JxlSplineSegment segment, bool add, int y, int x0, int x1, InlineArray3<Memory<float>> rows)
+    {
+        int start = (int)MathF.Round(segment.Center.X - segment.MaximumDistance, MidpointRounding.AwayFromZero);
+        int end = (int)MathF.Round(segment.Center.X + segment.MaximumDistance, MidpointRounding.AwayFromZero);
+
+        if (end < x0 || start >= x1)
+        {
+            return;  // span does not intersect scan
+        }
+
+        int spanX0 = Math.Max(x0, start) - x0;
+        int spanX1 = Math.Min(x1, end + 1) - x0;
+
+        int x = spanX0;
+        for (; x + Vector<float>.Count <= spanX1; x += Vector<float>.Count)
+        {
+            DrawSegmentPacked(ref segment, add, y, x, x0, rows);
+        }
+
+        for (; x < spanX1; ++x)
+        {
+            DrawSegmentScalar(ref segment, add, y, x, x0, rows);
+        }
+    }
+
+    public static void ComputeSegments(int imageYSize, PointF center, float intensity, InlineArray3<float> color, float sigma, List<JxlSplineSegment> segments, List<JxlSplineSegmentSpan> segmentSpans)
+    {
+        if (!(float.IsFinite(sigma) && sigma != 0.0f && float.IsFinite(1.0f / sigma) && float.IsFinite(intensity)))
+        {
+            return;
+        }
+
+        // This is about 30% faster, but for higher precision
+        // one can change this to 5 instead.
+        const float distanceExp = 3f;
+
+        float maxColor = MathF.Max(0.01f, MathF.Abs(color[0] * intensity));
+        maxColor = MathF.Max(maxColor, MathF.Abs(color[1] * intensity));
+        maxColor = MathF.Max(maxColor, MathF.Abs(color[2] * intensity));
+
+        float maximumDistance = MathF.Sqrt(-2.0f * sigma * sigma * ((MathF.Log(0.1f) * distanceExp) - MathF.Log(maxColor)));
+
+        int y0 = (int)MathF.Round(center.Y - maximumDistance, MidpointRounding.AwayFromZero);
+        y0 = Math.Max(y0, 0);
+
+        int y1 = (int)MathF.Round(center.Y + maximumDistance, MidpointRounding.AwayFromZero) + 1;
+        y1 = Math.Min(y1, imageYSize);
+
+        if (y1 <= y0)
+        {
+            return;
+        }
+
+        JxlSplineSegment segment = new()
+        {
+            Center = center,
+            InverseSigma = 1.0f / sigma,
+            SigmaOver4TimesIntensity = 0.25f * sigma * intensity,
+            MaximumDistance = maximumDistance,
+            Color = color
+        };
+
+        segments.Add(segment);
+        segmentSpans.Add(new JxlSplineSegmentSpan(y0, y1));
+    }
+
+    public static void DrawSegments(Memory<float> rowX, Memory<float> rowY, Memory<float> rowB, int y, int x0, int x1, bool add, Span<JxlSplineSegment> segments, Span<int> segmentIndices, Span<int> segmentYStart)
+    {
+        InlineArray3<Memory<float>> rows = default;
+        rows[0] = rowX;
+        rows[1] = rowY;
+        rows[2] = rowB;
+
+        for (int i = segmentYStart[y]; i < segmentYStart[y + 1]; i++)
+        {
+            DrawSegment(ref segments[segmentIndices[i]], add, y, x0, x1, rows);
+        }
+    }
+
+    public static void SegmentsFromPoints(int imageYSize, JxlSpline spline, List<(PointF Point, float Multiplier)> pointsToDraw, float arcLength, List<JxlSplineSegment> segments, List<JxlSplineSegmentSpan> segmentsSpans)
+    {
+        float inverseArcLength = 1.0f / arcLength;
+        int k = 0;
+
+        foreach ((PointF point, float multiplier) in pointsToDraw)
+        {
+            float progressAlongArc = MathF.Min(1.0f, (k++ * DesiredRenderingDistance) * inverseArcLength);
+
+            InlineArray3<float> color = default;
+            color[0] = ContinuousInverseDCT(spline.ColorDct[0], (32 - 1) * progressAlongArc);
+            color[1] = ContinuousInverseDCT(spline.ColorDct[1], (32 - 1) * progressAlongArc);
+            color[2] = ContinuousInverseDCT(spline.ColorDct[2], (32 - 1) * progressAlongArc);
+
+            float sigma = ContinuousInverseDCT(spline.SigmaDct, (32 - 1) * progressAlongArc);
+            ComputeSegments(imageYSize, point, multiplier, color, sigma, segments, segmentsSpans);
+        }
+    }
+
+    public static void DrawCentripetalCatmullRomSpline(Span<PointF> points, List<PointF> result)
+    {
+        if (points.Length == 0)
+        {
+            return;
+        }
+
+        if (points.Length == 1)
+        {
+            result.Add(points[0]);
+            return;
+        }
+
+        List<PointF> pointsCopy = [];
+        for (int i = 0; i < points.Length; i++)
+        {
+            pointsCopy.Add(points[i]);
+        }
+
+        const int numPoints = 16;
+        pointsCopy.Insert(0, pointsCopy[0] + (pointsCopy[0] - pointsCopy[1]));
+        pointsCopy.Add(pointsCopy[^1] + (pointsCopy[^1] - pointsCopy[^2]));
+
+        for (int start = 0; start < pointsCopy.Count - 3; start++)
+        {
+            Span<PointF> p = CollectionsMarshal.AsSpan(pointsCopy)[start..];
+            result.Add(p[1]);
+
+            InlineArray3<float> d = default;
+            InlineArray4<float> t = default;
+
+            for (int k = 0; k < 3; ++k)
+            {
+                d[k] = MathF.Sqrt(JxlMath.Hypot(p[k + 1].X - p[k].X, p[k + 1].Y - p[k].Y));
+                t[k + 1] = t[k] + d[k];
+            }
+
+            for (int i = 1; i < numPoints; ++i)
+            {
+                float tt = d[0] + (((float)i / numPoints) * d[1]);
+                InlineArray3<PointF> a = default;
+
+                for (int k = 0; k < 3; ++k)
+                {
+                    a[k] = p[k] + (((tt - t[k]) / d[k]) * (p[k + 1] - p[k]));
+                }
+
+                InlineArray3<PointF> b = default;
+
+                for (int k = 0; k < 2; ++k)
+                {
+                    b[k] = a[k] + (((tt - t[k]) / (d[k] + d[k + 1])) * (a[k + 1] - a[k]));
+                }
+
+                result.Add(b[0] + (((tt - t[1]) / d[1]) * (b[1] - b[0])));
+            }
+        }
+
+        result.Add(pointsCopy[^2]);
+    }
+
+    public static void ForEachEquallySpacedPoint(Span<PointF> points, Action<PointF, float> functor)
+    {
+        PointF current = points[0];
+        functor(current, DesiredRenderingDistance);
+
+        ref PointF next = ref points[0];
+        ref PointF end = ref points[^1]; // last
+
+        while (!Unsafe.AreSame(ref next, ref end))
+        {
+            ref PointF previous = ref current;
+            float arcLengthFromPrevious = 0f;
+
+            while (true)
+            {
+                if (next == end)
+                {
+                    functor(previous, arcLengthFromPrevious);
+                    return;
+                }
+
+                float arcLengthToNext = MathF.Sqrt(SquaredNorm(next - previous));
+
+                if (arcLengthFromPrevious + arcLengthToNext >= DesiredRenderingDistance)
+                {
+                    current = previous + (((DesiredRenderingDistance - arcLengthFromPrevious) / arcLengthToNext) * (next - previous));
+                    functor(current, DesiredRenderingDistance);
+                    break;
+                }
+
+                arcLengthFromPrevious += arcLengthToNext;
+                previous = ref next;
+                next = ref Unsafe.Add(ref next, 1);
+            }
+        }
+    }
+
+    private static float SquaredNorm(PointF pointF)
+    {
+        float x = pointF.X;
+        float y = pointF.Y;
+
+        return (x * x) + (y * y);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplines.cs b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplines.cs
new file mode 100644
index 0000000000..c40462b8c5
--- /dev/null
+++ b/src/ImageSharp/Formats/Jxl/Processing/Splines/JxlSplines.cs
@@ -0,0 +1,290 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Splines;
+
+internal sealed class JxlSplines
+{
+    private List<JxlQuantizedSpline> splinesStorage = [];
+    private readonly List<PointF> startingPointsStorage = [];
+    private JxlSplineDataView data = new();
+    private readonly List<JxlSplineSegment> segments = [];
+    private IMemoryOwner<byte> segmentIndices = EmptyMemoryOwner.Instance;
+    private IMemoryOwner<byte> segmentYStart = EmptyMemoryOwner.Instance;
+
+    public bool HasAny => this.data.HasAny;
+
+    public Span<JxlQuantizedSpline> QuantizedSplines => CollectionsMarshal.AsSpan(this.data.Splines);
+
+    public Span<PointF> StartingPoints => CollectionsMarshal.AsSpan(this.data.StartingPoints);
+
+    public int QuantizationAdjustment { get; private set; }
+
+    public void SetData(JxlSplineDataView data)
+    {
+        this.Clear();
+        this.data = data;
+    }
+
+    public void Clear()
+    {
+        this.QuantizationAdjustment = 0;
+        this.splinesStorage.Clear();
+        this.startingPointsStorage.Clear();
+        this.data = new();
+        this.segments.Clear();
+        this.segmentIndices = EmptyMemoryOwner.Instance;
+        this.segmentYStart = EmptyMemoryOwner.Instance;
+    }
+
+    public void Decode(Configuration configuration, JxlBitReader reader, int numPixels)
+    {
+        List<byte> contextMap = [];
+
+        JxlAnsReader.DecodeHistograms(reader, NumSplineContexts, out JxlAnsCode code, contextMap);
+        JxlAnsSymbolReader decoder = new(code, reader);
+
+        int numSplines = decoder.ReadHybridUint(NumSplinesContext, reader, contextMap);
+        int maxControlPoints = Math.Min(MaxNumControlPoints, numPixels / MaxNumControlPointsPerPixelRatio);
+
+        if (numSplines > maxControlPoints || numSplines + 1 > maxControlPoints)
+        {
+            throw new InvalidOperationException("Too many splines: " + numSplines);
+        }
+
+        numSplines++;
+
+        DecodeAllStartingPoints(this.startingPointsStorage, reader, decoder, contextMap, numSplines);
+
+        this.QuantizationAdjustment = JxlPackSigned.UnpackSigned(decoder.ReadHybridUint(QuantizationAdjustmentContext, reader, contextMap));
+        this.splinesStorage = new List<JxlQuantizedSpline>(numSplines);
+
+        int numControlPoints = numSplines;
+
+        for (int i = 0; i < numSplines; ++i)
+        {
+            JxlQuantizedSpline spline = new();
+            if (!spline.TryDecode(
+                configuration,
+                CollectionsMarshal.AsSpan(contextMap),
+                decoder,
+                reader,
+                maxControlPoints,
+                ref numControlPoints))
+            {
+                throw new InvalidOperationException("Could not decode quantized spline. Index of the quantized spline: " + i);
+            }
+
+            this.splinesStorage.Add(spline);
+        }
+
+        if (!decoder.CheckAnsFinalState())
+        {
+            throw new InvalidOperationException("Not ANS final state");
+        }
+
+        this.data = new JxlSplineDataView()
+        {
+            Splines = this.splinesStorage,
+            StartingPoints = this.startingPointsStorage
+        };
+
+        if (!this.HasAny)
+        {
+            throw new InvalidOperationException("Decoded splines but got none");
+        }
+    }
+
+    public void InitializeDrawCache(Configuration configuration, int imageXSize, int imageYSize, JxlColorCorrelation colorCorrelation)
+    {
+        this.segments.Clear();
+        this.segmentIndices = EmptyMemoryOwner.Instance;
+        this.segmentYStart = EmptyMemoryOwner.Instance;
+
+        List<JxlSplineSegmentSpan> segmentsSpans = [];
+        List<PointF> intermediatePoints = [];
+        List<JxlSpline> splines = [];
+        long totalEstimatedAreaReached = 0;
+
+        for (int i = 0; i < this.data.Splines.Count; i++)
+        {
+            JxlSpline spline = new();
+
+            if (!this.data.Splines[i].Dequantize(
+                configuration,
+                this.data.StartingPoints[i],
+                this.QuantizationAdjustment,
+                colorCorrelation.YToXRatio(0),
+                colorCorrelation.YToBRatio(0),
+                imageXSize * imageYSize,
+                ref totalEstimatedAreaReached,
+                spline))
+            {
+                throw new InvalidOperationException("Could not dequantize a quantized spline");
+            }
+
+            if (AdjacentFind(spline.ControlPoints.Span) != spline.ControlPoints.Length - 1)
+            {
+                throw new InvalidOperationException("Identical successive control points in spline " + i);
+            }
+
+            splines.Add(spline);
+        }
+
+#if JPEG_XL_THROW_ON_LARGE_SPLINE_AREA
+        if (totalEstimatedAreaReached > Math.Min((8 * imageXSize * imageYSize) + (1 << 25), 1 << 30))
+        {
+            throw new InvalidOperationException("Total spline area is too large");
+        }
+#endif
+
+        foreach (JxlSpline spline in splines)
+        {
+            List<(PointF Point, float Multiplier)> pointsToDraw = [];
+
+            void AddPoint(PointF point, float multiplier) => pointsToDraw.Add((point, multiplier));
+
+            intermediatePoints.Clear();
+
+            JxlSplineUtils.DrawCentripetalCatmullRomSpline(spline.ControlPoints.Span, intermediatePoints);
+            JxlSplineUtils.ForEachEquallySpacedPoint(CollectionsMarshal.AsSpan(intermediatePoints), AddPoint);
+
+            float arcLength = ((pointsToDraw.Count - 2) * JxlSplineUtils.DesiredRenderingDistance) + pointsToDraw[^1].Multiplier;
+            if (arcLength <= 0f)
+            {
+                // This spline wouldn't have any effect.
+                continue;
+            }
+
+            JxlSplineUtils.SegmentsFromPoints(imageYSize, spline, pointsToDraw, arcLength, this.segments, segmentsSpans);
+        }
+
+        int segmentYStartNumBytes = (imageYSize + 2) * 4;
+        this.segmentYStart = configuration.MemoryAllocator.Allocate<byte>(segmentYStartNumBytes);
+
+        Span<byte> segmentYStart = this.segmentYStart.Memory.Span;
+        segmentYStart.Clear();
+
+        Span<byte> population = segmentYStart[1..];
+
+        foreach (JxlSplineSegmentSpan segmentSpan in segmentsSpans)
+        {
+            population[segmentSpan.StartInclusive]++;
+            population[segmentSpan.EndInclusive]--;
+        }
+
+        int total = 0;
+        int coverage = 0;
+
+        for (int y = 0; y < imageYSize; y++)
+        {
+            if (population[y] < 0)
+            {
+                if (coverage < -population[y])
+                {
+                    throw new InvalidOperationException("Coverage is invalid");
+                }
+            }
+
+            coverage += population[y];
+            population[y] = (byte)total;
+            total += coverage;
+        }
+
+        this.segmentIndices = configuration.MemoryAllocator.Allocate<byte>(total * 4);
+        Span<int> segmentIndices = MemoryMarshal.Cast<byte, int>(this.segmentIndices.Memory.Span);
+
+        for (int i = 0; i < this.segments.Count; i++)
+        {
+            JxlSplineSegmentSpan segmentSpan = segmentsSpans[i];
+
+            for (int y = segmentSpan.StartInclusive; y < segmentSpan.EndInclusive; y++)
+            {
+                segmentIndices[population[y]++] = i;
+            }
+        }
+    }
+
+    private static int AdjacentFind<T>(Span<T> span)
+        where T : IEquatable<T>
+    {
+        for (int i = 0; i < span.Length - 1; i++)
+        {
+            if (span[i].Equals(span[i + 1]))
+            {
+                return i;
+            }
+        }
+
+        return span.Length;
+    }
+
+    public void AddTo(JxlImage3F opsin, Rectangle opsinRect) => this.Apply(add: true, opsin, opsinRect);
+
+    public void AddToRow(Memory<float> rowX, Memory<float> rowY, Memory<float> rowB, int y, int x0, int x1)
+        => this.ApplyToRow(add: true, rowX, rowY, rowB, y, x0, x1);
+
+    public void SubtractFrom(JxlImage3F opsin) => this.Apply(add: false, opsin, opsin.GetRectangle());
+
+    private void ApplyToRow(bool add, Memory<float> rowX, Memory<float> rowY, Memory<float> rowB, int y, int x0, int x1)
+    {
+        if (this.segments.Count == 0)
+        {
+            return;
+        }
+
+        JxlSplineUtils.DrawSegments(
+            rowX,
+            rowY,
+            rowB,
+            y,
+            x0,
+            x1,
+            add,
+            CollectionsMarshal.AsSpan(this.segments),
+            MemoryMarshal.Cast<byte, int>(this.segmentIndices.Memory.Span),
+            MemoryMarshal.Cast<byte, int>(this.segmentYStart.Memory.Span));
+    }
+
+    private void Apply(bool add, JxlImage3F opsin, Rectangle opsinRect)
+    {
+        if (this.segments.Count == 0)
+        {
+            return;
+        }
+
+        int y0 = RectangleUtils.Y0(in opsinRect);
+        int x0 = RectangleUtils.X0(in opsinRect);
+        int x1 = RectangleUtils.X1(in opsinRect);
+
+        for (int y = 0; y < opsinRect.Height; y++)
+        {
+            this.ApplyToRow(
+                add,
+                opsin.PlaneRowMemory(0, y0 + y)[x0..],
+                opsin.PlaneRowMemory(1, y0 + y)[x0..],
+                opsin.PlaneRowMemory(2, y0 + y)[x0..],
+                y0 + y,
+                x0,
+                x1);
+        }
+    }
+
+    private sealed class EmptyMemoryOwner : IMemoryOwner<byte>
+    {
+        public static readonly EmptyMemoryOwner Instance = new();
+
+        public Memory<byte> Memory => Memory<byte>.Empty;
+
+        public void Dispose()
+        {
+        }
+    }
+}
diff --git a/src/ImageSharp/ImageSharp.csproj b/src/ImageSharp/ImageSharp.csproj
index 971d73b849..b3925b7a7c 100644
--- a/src/ImageSharp/ImageSharp.csproj
+++ b/src/ImageSharp/ImageSharp.csproj
@@ -44,6 +44,11 @@
     <None Include="..\..\LICENSE" Pack="true" PackagePath="" />
     <None Include="..\..\shared-infrastructure\branding\icons\imagesharp\sixlabors.imagesharp.128.png" Pack="true" PackagePath="" />
     <None Include="..\..\SixLabors.ImageSharp.props" Pack="true" PackagePath="build" />
+    <None Include="Formats\Jxl\Processing\JxlSimdUtils.StoreInterleaved.Generated.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>JxlSimdUtils.StoreInterleaved.tt</DependentUpon>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -57,6 +62,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>InlineArray.tt</DependentUpon>
     </Compile>
+    <Compile Update="Formats\Jxl\Processing\JxlSimdUtils.StoreInterleaved.Generated.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>JxlSimdUtils.StoreInterleaved.tt</DependentUpon>
+    </Compile>
     <Compile Update="Formats\_Generated\ImageExtensions.Save.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -164,6 +174,10 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>InlineArray.cs</LastGenOutput>
     </None>
+    <None Update="Formats\Jxl\Processing\JxlSimdUtils.StoreInterleaved.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>JxlSimdUtils.StoreInterleaved.Generated.cs</LastGenOutput>
+    </None>
     <None Update="Formats\_Generated\ImageMetadataExtensions.tt">
       <LastGenOutput>ImageMetadataExtensions.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.cs
index c5464c8d72..faa94dea40 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.cs
@@ -3,6 +3,8 @@
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
+#pragma warning disable IDE0032 // Use auto property
+
 /// <summary>
 /// Provides methods to read ICC data types
 /// </summary>
@@ -25,6 +27,11 @@ internal sealed partial class IccDataReader
     public IccDataReader(byte[] data)
         => this.data = data ?? throw new ArgumentNullException(nameof(data));
 
+    /// <summary>
+    /// Gets the reading position.
+    /// </summary>
+    public int Index => this.currentIndex;
+
     /// <summary>
     /// Gets the length in bytes of the raw data
     /// </summary>
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs b/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs
index c0167e0e39..532e08a344 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs
@@ -53,7 +53,7 @@ internal sealed class IccReader
         return ReadTagData(reader);
     }
 
-    private static IccProfileHeader ReadHeader(IccDataReader reader)
+    internal static IccProfileHeader ReadHeader(IccDataReader reader)
     {
         reader.SetIndex(0);
 
@@ -79,7 +79,7 @@ internal sealed class IccReader
         };
     }
 
-    private static IccTagDataEntry[] ReadTagData(IccDataReader reader)
+    internal static IccTagDataEntry[] ReadTagData(IccDataReader reader)
     {
         IccTagTableEntry[] tagTable = ReadTagTable(reader);
         List<IccTagDataEntry> entries = new(tagTable.Length);
diff --git a/tests/ImageSharp.Tests/Common/Vector256UtilitiesTests.cs b/tests/ImageSharp.Tests/Common/Vector256UtilitiesTests.cs
new file mode 100644
index 0000000000..1c294afa44
--- /dev/null
+++ b/tests/ImageSharp.Tests/Common/Vector256UtilitiesTests.cs
@@ -0,0 +1,48 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Tests.Common;
+
+public class Vector256UtilitiesTests
+{
+    [Theory]
+    [InlineData(new int[] { 4, 5, 6, 7, 8, 9, 10, 11 }, new int[] { 1, 2, 3, 4, 0, -1, -2, -3 }, new int[] { 4, 1, 5, 2, 6, 3, 7, 4 })]
+    public void TestVector256InterleaveLower(int[] a, int[] b, int[] expected)
+    {
+        Vector256<int> v256a = Vector256.Create(a);
+        Vector256<int> v256b = Vector256.Create(b);
+
+        Vector256<int> v256 = Vector256_.InterleaveLower(v256a, v256b);
+
+        int[] result = new int[Vector256<int>.Count];
+        v256.CopyTo(result);
+
+        bool isEqual = expected.SequenceEqual(result);
+        if (!isEqual)
+        {
+            Assert.Fail($"Lower shuffle failed.\n\nExpected: [{string.Join(", ", expected)}]\nActual: [{string.Join(", ", result)}]");
+        }
+    }
+
+    [Theory]
+    [InlineData(new int[] { 4, 5, 6, 7, 8, 9, 10, 11 }, new int[] { 1, 2, 3, 4, 0, -1, -2, -3 }, new int[] { 8, 0, 9, -1, 10, -2, 11, -3 })]
+    public void TestVector256InterleaveUpper(int[] a, int[] b, int[] expected)
+    {
+        Vector256<int> v256a = Vector256.Create(a);
+        Vector256<int> v256b = Vector256.Create(b);
+
+        Vector256<int> v256 = Vector256_.InterleaveUpper(v256a, v256b);
+
+        int[] result = new int[Vector256<int>.Count];
+        v256.CopyTo(result);
+
+        bool isEqual = expected.SequenceEqual(result);
+        if (!isEqual)
+        {
+            Assert.Fail($"Lower shuffle failed.\n\nExpected: [{string.Join(", ", expected)}]\nActual: [{string.Join(", ", result)}]");
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/IO/FieldsTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/IO/FieldsTests.cs
new file mode 100644
index 0000000000..b715b48a60
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/IO/FieldsTests.cs
@@ -0,0 +1,674 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Fields;
+using SixLabors.ImageSharp.Formats.Jxl.IO.FrameHeader;
+using SixLabors.ImageSharp.Formats.Jxl.IO.Metadata;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.AuxiliaryOutput;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.IO;
+
+public class FieldsTests
+{
+    private sealed class OldBundle : IJxlFields
+    {
+        private uint oldSmall;
+        private float oldF;
+        private uint oldLarge;
+        private ulong extensions;
+
+        public OldBundle() => JxlBundle.Init(this);
+
+        public uint OldSmall
+        {
+            get => this.oldSmall;
+            set => this.oldSmall = value;
+        }
+
+        public float OldF
+        {
+            get => this.oldF;
+            set => this.oldF = value;
+        }
+
+        public uint OldLarge
+        {
+            get => this.oldLarge;
+            set => this.oldLarge = value;
+        }
+
+        public ulong Extensions
+        {
+            get => this.extensions;
+            set => this.extensions = value;
+        }
+
+        public bool Visit(JxlVisitor visitor)
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Bits(2),
+                JxlFieldExpressions.Bits(3),
+                JxlFieldExpressions.Bits(4),
+                1,
+                ref this.oldSmall))
+            {
+                return false;
+            }
+
+            if (!visitor.F16(1.125f, ref this.oldF))
+            {
+                return false;
+            }
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Bits(7),
+                JxlFieldExpressions.Bits(12),
+                JxlFieldExpressions.Bits(16),
+                JxlFieldExpressions.Bits(32),
+                0,
+                ref this.oldLarge))
+            {
+                return false;
+            }
+
+            if (!visitor.BeginExtensions(ref this.extensions))
+            {
+                return false;
+            }
+
+            return visitor.EndExtensions();
+        }
+    }
+
+    private sealed class NewBundle : IJxlFields
+    {
+        private uint oldSmall;
+        private float oldF;
+        private uint oldLarge;
+        private ulong extensions;
+        private uint newSmall = 2;
+        private float newF = -2.0f;
+        private uint newLarge;
+
+        public NewBundle() => JxlBundle.Init(this);
+
+        public uint OldSmall
+        {
+            get => this.oldSmall;
+            set => this.oldSmall = value;
+        }
+
+        public float OldF
+        {
+            get => this.oldF;
+            set => this.oldF = value;
+        }
+
+        public uint OldLarge
+        {
+            get => this.oldLarge;
+            set => this.oldLarge = value;
+        }
+
+        public ulong Extensions
+        {
+            get => this.extensions;
+            set => this.extensions = value;
+        }
+
+        public uint NewSmall
+        {
+            get => this.newSmall;
+            set => this.newSmall = value;
+        }
+
+        public float NewF
+        {
+            get => this.newF;
+            set => this.newF = value;
+        }
+
+        public uint NewLarge
+        {
+            get => this.newLarge;
+            set => this.newLarge = value;
+        }
+
+        public bool Visit(JxlVisitor visitor)
+        {
+            if (!visitor.U32(
+                JxlFieldExpressions.Value(1),
+                JxlFieldExpressions.Bits(2),
+                JxlFieldExpressions.Bits(3),
+                JxlFieldExpressions.Bits(4),
+                1,
+                ref this.oldSmall))
+            {
+                return false;
+            }
+
+            if (!visitor.F16(1.125f, ref this.oldF))
+            {
+                return false;
+            }
+
+            if (!visitor.U32(
+                JxlFieldExpressions.Bits(7),
+                JxlFieldExpressions.Bits(12),
+                JxlFieldExpressions.Bits(16),
+                JxlFieldExpressions.Bits(32),
+                0,
+                ref this.oldLarge))
+            {
+                return false;
+            }
+
+            if (!visitor.BeginExtensions(ref this.extensions))
+            {
+                return false;
+            }
+
+            if (visitor.Conditional((this.Extensions & 1) != 0))
+            {
+                if (!visitor.U32(
+                    JxlFieldExpressions.Value(2),
+                    JxlFieldExpressions.Bits(2),
+                    JxlFieldExpressions.Bits(3),
+                    JxlFieldExpressions.Bits(4),
+                    2,
+                    ref this.newSmall))
+                {
+                    return false;
+                }
+
+                if (!visitor.F16(-2.0f, ref this.newF))
+                {
+                    return false;
+                }
+            }
+
+            if (visitor.Conditional((this.Extensions & 2) != 0))
+            {
+                if (!visitor.U32(
+                    JxlFieldExpressions.Bits(9),
+                    JxlFieldExpressions.Bits(12),
+                    JxlFieldExpressions.Bits(16),
+                    JxlFieldExpressions.Bits(32),
+                    0,
+                    ref this.newLarge))
+                {
+                    return false;
+                }
+            }
+
+            return visitor.EndExtensions();
+        }
+    }
+
+    private static void TestU32Coder(uint value, int expectedBitsWritten)
+    {
+        JxlU32Enc enc = new(
+            JxlFieldExpressions.Value(0),
+            JxlFieldExpressions.Bits(4),
+            JxlFieldExpressions.Value(0x7FFFFFFF),
+            JxlFieldExpressions.Bits(32));
+
+        using MemoryStream memoryStream = new();
+        JxlBitWriter bitWriter = new(memoryStream);
+
+        Assert.True(bitWriter.WithMaxBits(
+            (ulong)JxlMath.RoundUpBitsToByteMultiple(JxlU32Coder.MaxEncodedBits(enc)),
+            () =>
+            {
+                int encodedBits = 0;
+                Assert.True(JxlU32Coder.CanEncode(in enc, value, ref encodedBits));
+                Assert.Equal(expectedBitsWritten, encodedBits);
+
+                Assert.True(JxlU32Coder.Write(in enc, value, bitWriter));
+                Assert.Equal(expectedBitsWritten, bitWriter.BitsWritten);
+
+                bitWriter.ZeroPadToByte();
+
+                return true;
+            }));
+
+        memoryStream.Position = 0;
+        JxlBitReader reader = new(memoryStream);
+        uint decodedValue = JxlU32Coder.Read(in enc, reader);
+
+        Assert.Equal(value, decodedValue);
+    }
+
+    private static void TestU64Coder(ulong value, int expectedBitsWritten)
+    {
+        using MemoryStream memoryStream = new();
+        JxlBitWriter bitWriter = new(memoryStream);
+
+        Assert.True(bitWriter.WithMaxBits(
+            (ulong)JxlMath.RoundUpBitsToByteMultiple(JxlU64Coder.MaxEncodedBits()),
+            () =>
+            {
+                int encodedBits = 0;
+                Assert.True(JxlU64Coder.CanEncode(value, ref encodedBits));
+                Assert.Equal(expectedBitsWritten, encodedBits);
+
+                Assert.True(JxlU64Coder.Write(value, bitWriter));
+                Assert.Equal(expectedBitsWritten, bitWriter.BitsWritten);
+
+                bitWriter.ZeroPadToByte();
+
+                return true;
+            }));
+
+        memoryStream.Position = 0;
+        JxlBitReader reader = new(memoryStream);
+        ulong decodedValue = JxlU64Coder.Read(reader);
+
+        Assert.Equal(value, decodedValue);
+    }
+
+    private static void TestF16Coder(float value)
+    {
+        int maxEncodedBits = 0;
+        if (JxlF16Coder.CanEncode(value, ref maxEncodedBits))
+        {
+            throw new InvalidOperationException("This F16 value cannot be encoded: " + value);
+        }
+
+        Assert.Equal(JxlF16Coder.MaxEncodedBits(), maxEncodedBits);
+
+        using MemoryStream memoryStream = new();
+        JxlBitWriter bitWriter = new(memoryStream);
+
+        Assert.True(bitWriter.WithMaxBits(
+            (ulong)JxlMath.RoundUpBitsToByteMultiple(maxEncodedBits),
+            () =>
+            {
+                Assert.True(JxlF16Coder.Write(value, bitWriter));
+                Assert.Equal(JxlF16Coder.MaxEncodedBits(), bitWriter.BitsWritten);
+                bitWriter.ZeroPadToByte();
+                return true;
+            }));
+
+        memoryStream.Position = 0;
+        JxlBitReader reader = new(memoryStream);
+
+        float decodedValue = 0;
+        Assert.True(JxlF16Coder.Read(reader, ref decodedValue));
+        Assert.Equal(value, decodedValue);
+    }
+
+    [Fact]
+    public void U32CoderTest()
+    {
+        TestU32Coder(0, 2);
+        TestU32Coder(1, 6);
+        TestU32Coder(15, 6);
+        TestU32Coder(0x7FFFFFFF, 2);
+        TestU32Coder(128, 34);
+        TestU32Coder(0x7FFFFFFEu, 34);
+        TestU32Coder(0x80000000u, 34);
+        TestU32Coder(0xFFFFFFFFu, 34);
+    }
+
+    [Fact]
+    public void U64CoderTest()
+    {
+        // Values that should take 2 bits (selector 00): 0
+        TestU64Coder(0, 2);
+
+        // Values that should take 6 bits (2 for selector, 4 for value): 1..16
+        TestU64Coder(1, 6);
+        TestU64Coder(2, 6);
+        TestU64Coder(8, 6);
+        TestU64Coder(15, 6);
+        TestU64Coder(16, 6);
+
+        // Values that should take 10 bits (2 for selector, 8 for value): 17..272
+        TestU64Coder(17, 10);
+        TestU64Coder(18, 10);
+        TestU64Coder(100, 10);
+        TestU64Coder(271, 10);
+        TestU64Coder(272, 10);
+
+        // Values that should take 15 bits (2 for selector, 12 for value, 1 for varint
+        // end): (0)..273..4095
+        TestU64Coder(273, 15);
+        TestU64Coder(274, 15);
+        TestU64Coder(1000, 15);
+        TestU64Coder(4094, 15);
+        TestU64Coder(4095, 15);
+
+        // Take 24 bits (of which 20 actual value): (0)..4096..1048575
+        TestU64Coder(4096, 24);
+        TestU64Coder(4097, 24);
+        TestU64Coder(10000, 24);
+        TestU64Coder(1048574, 24);
+        TestU64Coder(1048575, 24);
+
+        // Take 33 bits (of which 28 actual value): (0)..1048576..268435455
+        TestU64Coder(1048576, 33);
+        TestU64Coder(1048577, 33);
+        TestU64Coder(10000000, 33);
+        TestU64Coder(268435454, 33);
+        TestU64Coder(268435455, 33);
+
+        // Take 42 bits (of which 36 actual value): (0)..268435456..68719476735
+        TestU64Coder(268435456uL, 42);
+        TestU64Coder(268435457uL, 42);
+        TestU64Coder(1000000000uL, 42);
+        TestU64Coder(68719476734uL, 42);
+        TestU64Coder(68719476735uL, 42);
+
+        // Take 51 bits (of which 44 actual value): (0)..68719476736..17592186044415
+        TestU64Coder(68719476736uL, 51);
+        TestU64Coder(68719476737uL, 51);
+        TestU64Coder(1000000000000uL, 51);
+        TestU64Coder(17592186044414uL, 51);
+        TestU64Coder(17592186044415uL, 51);
+
+        // Take 60 bits (of which 52 actual value):
+        // (0)..17592186044416..4503599627370495
+        TestU64Coder(17592186044416uL, 60);
+        TestU64Coder(17592186044417uL, 60);
+        TestU64Coder(100000000000000uL, 60);
+        TestU64Coder(4503599627370494uL, 60);
+        TestU64Coder(4503599627370495uL, 60);
+
+        // Take 69 bits (of which 60 actual value):
+        // (0)..4503599627370496..1152921504606846975
+        TestU64Coder(4503599627370496uL, 69);
+        TestU64Coder(4503599627370497uL, 69);
+        TestU64Coder(10000000000000000uL, 69);
+        TestU64Coder(1152921504606846974uL, 69);
+        TestU64Coder(1152921504606846975uL, 69);
+
+        // Take 73 bits (of which 64 actual value):
+        // (0)..1152921504606846976..18446744073709551615
+        TestU64Coder(1152921504606846976uL, 73);
+        TestU64Coder(1152921504606846977uL, 73);
+        TestU64Coder(10000000000000000000uL, 73);
+        TestU64Coder(18446744073709551614uL, 73);
+        TestU64Coder(18446744073709551615uL, 73);
+    }
+
+    [Fact]
+    public void F16CoderTest()
+    {
+        ReadOnlySpan<float> signs = [-1.0f, 1.0f];
+        ReadOnlySpan<float> magnitudes = [0.0f, 0.5f, 1.0f, 2.0f, 2.5f, 16.015625f, 1.0f / 4096, 1.0f / 16384, 65504.0f];
+
+        foreach (float sign in signs)
+        {
+            foreach (float magnitude in magnitudes)
+            {
+                TestF16Coder(sign * magnitude);
+            }
+        }
+
+        // These values are out of range and cannot be represented
+        // by an F16 coder, so they're expected to throw.
+        Assert.Throws<Exception>(() => TestF16Coder(65504.01f));
+        Assert.Throws<Exception>(() => TestF16Coder(-65505.0f));
+    }
+
+    [Fact]
+    public void TestRoundtripSize()
+    {
+        for (int i = 0; i < 8; i++)
+        {
+            JxlSizeHeader size = new();
+            size.Set(123 + (77 * i), 7 + i); // It'll throw if it can't set
+
+            int extensionBits = 999;
+            long totalBits = 999;
+
+            Assert.True(JxlBundle.CanEncode(size, ref extensionBits, ref totalBits));
+            Assert.Equal(0, extensionBits);
+
+            using MemoryStream ms = new();
+            JxlBitWriter writer = new(ms);
+
+            Assert.True(JxlBundle.WriteSizeHeader(size, writer, JxlLayerType.Header, new JxlAuxiliaryOutput()));
+            Assert.Equal(totalBits, writer.BitsWritten);
+
+            writer.ZeroPadToByte();
+
+            JxlSizeHeader size2 = new();
+
+            ms.Position = 0;
+            JxlBitReader reader = new(ms);
+
+            Assert.True(JxlBundle.Read(reader, size2));
+            Assert.Equal(totalBits, reader.TotalBitsConsumed);
+
+            Assert.Equal(size.XSize, size2.XSize);
+            Assert.Equal(size.YSize, size2.YSize);
+        }
+    }
+
+    [Fact]
+    public void TestCropRect()
+    {
+        JxlCodecMetadata metadata = new();
+
+        for (int i = -999; i < 19000; i++)
+        {
+            JxlFrameHeader f = new()
+            {
+                Metadata = metadata,
+                CustomSizeOrOrigin = true,
+                FrameOrigin = new Point(i),
+                FrameSize = new(1000 + i)
+            };
+
+            int extensionBits = 0;
+            long totalBits = 0;
+
+            Assert.True(JxlBundle.CanEncode(f, ref extensionBits, ref totalBits));
+            Assert.Equal(0, extensionBits);
+            Assert.True(totalBits >= 9);
+        }
+    }
+
+    [Fact]
+    public void TestPreview()
+    {
+        for (int i = 1; i < 4360; i++)
+        {
+            JxlPreviewHeader p = new();
+            p.Set(i, i); // Throws if it fails
+
+            int extensionBits = 0;
+            long totalBits = 0;
+
+            Assert.True(JxlBundle.CanEncode(p, ref extensionBits, ref totalBits));
+            Assert.Equal(0, extensionBits);
+            Assert.True(totalBits >= 6);
+        }
+    }
+
+    [Fact]
+    public void TestRoundtripFrame()
+    {
+        JxlCodecMetadata metadata = new();
+
+        JxlFrameHeader h = new()
+        {
+            Metadata = metadata,
+            Extensions = 0x800
+        };
+
+        int extensionBits = 999;
+        long totalBits = 999;
+
+        Assert.True(JxlBundle.CanEncode(h, ref extensionBits, ref totalBits));
+        Assert.Equal(0, extensionBits);
+
+        using MemoryStream ms = new();
+        JxlBitWriter writer = new(ms);
+
+        Assert.True(JxlBundle.WriteFrameHeader(h, writer, null));
+        Assert.Equal(totalBits, writer.BitsWritten);
+
+        writer.ZeroPadToByte();
+
+        JxlFrameHeader h2 = new()
+        {
+            Metadata = metadata
+        };
+
+        ms.Position = 0;
+        JxlBitReader reader = new(ms);
+
+        Assert.True(JxlBundle.Read(reader, h2));
+        Assert.Equal(totalBits, reader.TotalBitsConsumed);
+
+        Assert.Equal(h.Extensions, h2.Extensions);
+        Assert.Equal(h.Flags, h2.Flags);
+    }
+
+    [Fact]
+    public void TestOutOfRange()
+    {
+        JxlSizeHeader h = new();
+        h.Set(unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF));
+
+        int extensionBits = 999;
+        long totalBits = 999;
+
+        Assert.False(JxlBundle.CanEncode(h, ref extensionBits, ref totalBits));
+    }
+
+    [Fact]
+    public void TestNewDecoderOldData()
+    {
+        OldBundle oldBundle = new()
+        {
+            OldLarge = 123,
+            OldF = 3.75f,
+            Extensions = 0
+        };
+
+        const int maxOutBytes = 999;
+
+        using MemoryStream ms = new();
+        JxlBitWriter writer = new(ms);
+
+        int extensionBits = 12345;
+        long totalBits = 12345;
+
+        Assert.True(JxlBundle.CanEncode(oldBundle, ref extensionBits, ref totalBits));
+        Assert.True(totalBits <= maxOutBytes * JxlMath.BitsPerByte);
+        Assert.Equal(0, extensionBits);
+
+        JxlAuxiliaryOutput auxOut = new();
+        Assert.True(
+            JxlBundle.Write(
+                oldBundle,
+                writer,
+                JxlLayerType.Header,
+                auxOut));
+
+        Assert.True(writer.WithMaxBits(
+            (ulong)((maxOutBytes * JxlMath.BitsPerByte) - totalBits),
+            () =>
+            {
+                writer.Write(20, 0xA55A);
+                writer.ZeroPadToByte();
+                return true;
+            }));
+
+        ms.Position = 0;
+        JxlBitReader reader = new(ms);
+        NewBundle newBundle = new();
+
+        Assert.True(JxlBundle.Read(reader, newBundle));
+
+        Assert.Equal(
+            reader.TotalBitsConsumed,
+            auxOut.Layers[(int)JxlLayerType.Header].TotalBits);
+
+        Assert.Equal(0xA55A, (int)reader.ReadBits32(20));
+
+        // Old fields are the same in both.
+        Assert.Equal(oldBundle.Extensions, newBundle.Extensions);
+        Assert.Equal(oldBundle.OldSmall, newBundle.OldSmall);
+        Assert.Equal(oldBundle.OldF, newBundle.OldF);
+        Assert.Equal(oldBundle.OldLarge, newBundle.OldLarge);
+
+        // New fields match their defaults.
+        Assert.Equal(2u, newBundle.NewSmall);
+        Assert.Equal(-2.0f, newBundle.NewF);
+        Assert.Equal(0u, newBundle.NewLarge);
+    }
+
+    [Fact]
+    public void TestOldDecoderNewData()
+    {
+        NewBundle newBundle = new()
+        {
+            OldLarge = 123,
+            Extensions = 3,
+            NewF = 999.0f,
+            NewLarge = 456
+        };
+
+        const int maxOutBytes = 999;
+
+        using MemoryStream ms = new();
+        JxlBitWriter writer = new(ms);
+
+        int extensionBits = 12345;
+        long totalBits = 12345;
+
+        Assert.True(JxlBundle.CanEncode(
+            newBundle,
+            ref extensionBits,
+            ref totalBits));
+
+        Assert.NotEqual(0, extensionBits);
+
+        JxlAuxiliaryOutput auxOut = new();
+        Assert.True(JxlBundle.Write(
+            newBundle,
+            writer,
+            JxlLayerType.Header,
+            auxOut));
+
+        int headerBits = auxOut.Layers[(int)JxlLayerType.Header].TotalBits;
+
+        Assert.True(headerBits <= maxOutBytes * JxlMath.BitsPerByte);
+
+        Assert.True(writer.WithMaxBits(
+            (ulong)((maxOutBytes * JxlMath.BitsPerByte) - headerBits),
+            () =>
+            {
+                writer.Write(20, 0xA55A);
+                writer.ZeroPadToByte();
+                return true;
+            }));
+
+        ms.Position = 0;
+        JxlBitReader reader = new(ms);
+        OldBundle oldBundle = new();
+
+        Assert.True(JxlBundle.Read(reader, oldBundle));
+
+        Assert.Equal(
+            reader.TotalBitsConsumed,
+            auxOut.Layers[(int)JxlLayerType.Header].TotalBits);
+
+        Assert.Equal(0xA55A, (int)reader.ReadBits32(20));
+
+        // Old fields are the same in both.
+        Assert.Equal(newBundle.Extensions, oldBundle.Extensions);
+        Assert.Equal(newBundle.OldSmall, oldBundle.OldSmall);
+        Assert.Equal(newBundle.OldF, oldBundle.OldF);
+        Assert.Equal(newBundle.OldLarge, oldBundle.OldLarge);
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/AlphaBlendingTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/AlphaBlendingTests.cs
new file mode 100644
index 0000000000..57e3a8a629
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/AlphaBlendingTests.cs
@@ -0,0 +1,332 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Blending;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing;
+
+public class AlphaBlendingTests
+{
+    private static float[] RgbToArray(Rgb rgb) => [rgb.R, rgb.G, rgb.B];
+
+    private static readonly float[] Expected = [77.2f, 83.0f, 90.6f];
+
+    [Fact]
+    public void BlendingWithNonPremultiplied()
+    {
+        Rgb bgRgb = new(100, 110, 120);
+        float bgA = 180f / 255;
+
+        Rgb fgRgb = new(25, 21, 23);
+        float fgA = 15420f / 65535;
+        float fgA2 = 2.0f;
+
+        float[] outR = [0];
+        float[] outG = [0];
+        float[] outB = [0];
+        float[] outAlpha = [0];
+
+        JxlAlphaBlendingInputLayer inputBg = new()
+        {
+            R = [bgRgb.R],
+            G = [bgRgb.G],
+            B = [bgRgb.B],
+            A = [bgA],
+        };
+
+        JxlAlphaBlendingInputLayer inputFg = new()
+        {
+            R = [fgRgb.R],
+            G = [fgRgb.G],
+            B = [fgRgb.B],
+            A = [fgA],
+        };
+
+        JxlAlphaBlendingOutput output = new()
+        {
+            R = outR,
+            G = outG,
+            B = outB,
+            A = outAlpha,
+        };
+
+        JxlAlphaHelper.PerformAlphaBlending(
+            inputBg,
+            inputFg,
+            output,
+            1,
+            alphaIsPremultiplied: false,
+            clamp: false);
+
+        Assert.Equal(
+            Expected,
+            [outR[0], outG[0], outB[0]],
+            new ApproximateFloatComparer(0.05f));
+
+        Assert.True(MathF.Abs(outAlpha[0] - (3174f / 4095)) <= 1e-5f);
+
+        inputFg = new()
+        {
+            R = [fgRgb.R],
+            G = [fgRgb.G],
+            B = [fgRgb.B],
+            A = [fgA2],
+        };
+
+        JxlAlphaHelper.PerformAlphaBlending(
+            inputBg,
+            inputFg,
+            output,
+            1,
+            alphaIsPremultiplied: false,
+            clamp: true);
+
+        Assert.Equal(
+            RgbToArray(fgRgb),
+            [outR[0], outG[0], outB[0]],
+            new ApproximateFloatComparer(0.05f));
+
+        Assert.True(MathF.Abs(outAlpha[0] - 1.0f) <= 1e-5f);
+    }
+
+    [Fact]
+    public void BlendingWithPremultiplied()
+    {
+        Rgb bgRgb = new(100, 110, 120);
+        float bgA = 180f / 255;
+
+        Rgb fgRgb = new(25, 21, 23);
+        float fgA = 15420f / 65535;
+        float fgA2 = 2.0f;
+
+        float[] outR = [0];
+        float[] outG = [0];
+        float[] outB = [0];
+        float[] outAlpha = [0];
+
+        JxlAlphaBlendingInputLayer inputBg = new()
+        {
+            R = [bgRgb.R],
+            G = [bgRgb.G],
+            B = [bgRgb.B],
+            A = [bgA],
+        };
+
+        JxlAlphaBlendingInputLayer inputFg = new()
+        {
+            R = [fgRgb.R],
+            G = [fgRgb.G],
+            B = [fgRgb.B],
+            A = [fgA],
+        };
+
+        JxlAlphaBlendingOutput output = new()
+        {
+            R = outR,
+            G = outG,
+            B = outB,
+            A = outAlpha,
+        };
+
+        JxlAlphaHelper.PerformAlphaBlending(
+            inputBg,
+            inputFg,
+            output,
+            1,
+            alphaIsPremultiplied: true,
+            clamp: false);
+
+        Assert.Equal(
+            new float[] { 101.5f, 105.1f, 114.8f },
+            [outR[0], outG[0], outB[0]],
+            new ApproximateFloatComparer(0.05f));
+
+        Assert.True(MathF.Abs(outAlpha[0] - (3174f / 4095)) <= 1e-5f);
+
+        inputFg = new()
+        {
+            R = [fgRgb.R],
+            G = [fgRgb.G],
+            B = [fgRgb.B],
+            A = [fgA2],
+        };
+
+        JxlAlphaHelper.PerformAlphaBlending(
+            inputBg,
+            inputFg,
+            output,
+            1,
+            alphaIsPremultiplied: true,
+            clamp: true);
+
+        Assert.Equal(
+            RgbToArray(fgRgb),
+            [outR[0], outG[0], outB[0]],
+            new ApproximateFloatComparer(0.05f));
+
+        Assert.True(MathF.Abs(outAlpha[0] - 1.0f) <= 1e-5f);
+    }
+
+    [Fact]
+    public void Mul()
+    {
+        Span<float> bg = [100];
+        Span<float> fg = [25];
+        Span<float> output = [0];
+
+        JxlAlphaHelper.PerformMultiplyBlending(
+            bg,
+            fg,
+            output,
+            1,
+            clamp: false);
+
+        Assert.True(MathF.Abs(output[0] - (fg[0] * bg[0])) <= 0.05f);
+
+        JxlAlphaHelper.PerformMultiplyBlending(
+            bg,
+            fg,
+            output,
+            1,
+            clamp: true);
+
+        Assert.True(MathF.Abs(output[0] - bg[0]) <= 0.05f);
+    }
+
+    [Fact]
+    public void PremultiplyAndUnpremultiply()
+    {
+        float[] alpha =
+        {
+            0f,
+            63f / 255,
+            127f / 255,
+            1f
+        };
+
+        float[] r = { 120, 130, 140, 150 };
+        float[] g = { 124, 134, 144, 154 };
+        float[] b = { 127, 137, 147, 157 };
+
+        JxlAlphaHelper.PremultiplyAlpha(r, g, b, alpha, alpha.Length);
+
+        Assert.Equal(
+            new[]
+            {
+                0f,
+                130 * 63f / 255,
+                140 * 127f / 255,
+                150f
+            },
+            r,
+            new ApproximateFloatComparer(1e-5f));
+
+        Assert.Equal(
+            new[]
+            {
+                0f,
+                134 * 63f / 255,
+                144 * 127f / 255,
+                154f
+            },
+            g,
+            new ApproximateFloatComparer(1e-5f));
+
+        Assert.Equal(
+            new[]
+            {
+                0f,
+                137 * 63f / 255,
+                147 * 127f / 255,
+                157f
+            },
+            b,
+            new ApproximateFloatComparer(1e-5f));
+
+        JxlAlphaHelper.UnpremultiplyAlpha(r, g, b, alpha, alpha.Length);
+
+        Assert.Equal(
+            new[] { 120f, 130f, 140f, 150f },
+            r,
+            new ApproximateFloatComparer(1e-4f));
+
+        Assert.Equal(
+            new[] { 124f, 134f, 144f, 154f },
+            g,
+            new ApproximateFloatComparer(1e-4f));
+
+        Assert.Equal(
+            new[] { 127f, 137f, 147f, 157f },
+            b,
+            new ApproximateFloatComparer(1e-4f));
+    }
+
+    [Fact]
+    public void UnpremultiplyAndPremultiply()
+    {
+        float[] alpha =
+        {
+            0f,
+            63f / 255,
+            127f / 255,
+            1f
+        };
+
+        float[] r = { 50, 60, 70, 80 };
+        float[] g = { 54, 64, 74, 84 };
+        float[] b = { 57, 67, 77, 87 };
+
+        JxlAlphaHelper.UnpremultiplyAlpha(r, g, b, alpha, alpha.Length);
+
+        Assert.Equal(
+            new[]
+            {
+                50f * (1 << 26),
+                60 * 255f / 63,
+                70 * 255f / 127,
+                80f
+            },
+            r,
+            new ApproximateFloatComparer(1e-4f));
+
+        Assert.Equal(
+            new[]
+            {
+                54f * (1 << 26),
+                64 * 255f / 63,
+                74 * 255f / 127,
+                84f
+            },
+            g,
+            new ApproximateFloatComparer(1e-4f));
+
+        Assert.Equal(
+            new[]
+            {
+                57f * (1 << 26),
+                67 * 255f / 63,
+                77 * 255f / 127,
+                87f
+            },
+            b,
+            new ApproximateFloatComparer(1e-4f));
+
+        JxlAlphaHelper.PremultiplyAlpha(r, g, b, alpha, alpha.Length);
+
+        Assert.Equal(
+            new[] { 50f, 60f, 70f, 80f },
+            r,
+            new ApproximateFloatComparer(1e-4f));
+
+        Assert.Equal(
+            new[] { 54f, 64f, 74f, 84f },
+            g,
+            new ApproximateFloatComparer(1e-4f));
+
+        Assert.Equal(
+            new[] { 57f, 67f, 77f, 87f },
+            b,
+            new ApproximateFloatComparer(1e-4f));
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/AnsCommonTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/AnsCommonTests.cs
new file mode 100644
index 0000000000..87b2fc6153
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/AnsCommonTests.cs
@@ -0,0 +1,48 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing;
+
+public class AnsCommonTests
+{
+    private static void VerifyAliasDistribution(Span<int> distribution, uint logRange)
+    {
+        const int logAlphaSize = 8;
+
+        Span<JxlAnsEntry> table = stackalloc JxlAnsEntry[1 << logAlphaSize];
+        bool success = JxlAnsHelper.InitAliasTable(distribution, logRange, logAlphaSize, table);
+        Assert.True(success);
+
+        uint range = 1u << (int)logRange;
+        List<int>[] offsets = new List<int>[distribution.Length];
+
+        for (int i = 0; i < range; i++)
+        {
+            JxlAnsSymbol s = JxlAnsHelper.Lookup(table, i, JxlAnsConstants.AnsLogTableSize - 8, (1 << (JxlAnsConstants.AnsLogTableSize - 8)) - 1);
+
+            offsets[s.Value] ??= [];
+            offsets[s.Value].Add(s.Offset);
+        }
+
+        for (int i = 0; i < distribution.Length; i++)
+        {
+            Assert.Equal(distribution[i], offsets[i].Count);
+            offsets[i].Sort();
+
+            for (int j = 0; j < offsets[i].Count; j++)
+            {
+                Assert.Equal(offsets[i][j], j);
+            }
+        }
+    }
+
+    [Fact]
+    public void AliasDistributionSmoke()
+    {
+        VerifyAliasDistribution([JxlAnsConstants.AnsTableSize / 2, JxlAnsConstants.AnsTableSize / 2], JxlAnsConstants.AnsLogTableSize);
+        VerifyAliasDistribution([JxlAnsConstants.AnsTableSize], JxlAnsConstants.AnsLogTableSize);
+        VerifyAliasDistribution([0, 0, 0, JxlAnsConstants.AnsTableSize, 0], JxlAnsConstants.AnsLogTableSize);
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/BitsTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/BitsTests.cs
new file mode 100644
index 0000000000..22f04cbe81
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/BitsTests.cs
@@ -0,0 +1,89 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing;
+
+public class BitsTests
+{
+    [Fact]
+    public void TestNumZeroBits()
+    {
+        Assert.Equal(32u, JxlMath.Num0BitsAboveMS1Bit(0u));
+        Assert.Equal(64u, JxlMath.Num0BitsAboveMS1Bit(0uL));
+        Assert.Equal(32u, JxlMath.Num0BitsBelowLS1Bit(0u));
+        Assert.Equal(64u, JxlMath.Num0BitsBelowLS1Bit(0uL));
+
+        Assert.Equal(31u, JxlMath.Num0BitsAboveMS1Bit(1u));
+        Assert.Equal(30u, JxlMath.Num0BitsAboveMS1Bit(2u));
+        Assert.Equal(63u, JxlMath.Num0BitsAboveMS1Bit(1uL));
+        Assert.Equal(62u, JxlMath.Num0BitsAboveMS1Bit(2uL));
+
+        Assert.Equal(0u, JxlMath.Num0BitsBelowLS1Bit(1u));
+        Assert.Equal(0u, JxlMath.Num0BitsBelowLS1Bit(1uL));
+        Assert.Equal(1u, JxlMath.Num0BitsBelowLS1Bit(2u));
+        Assert.Equal(1u, JxlMath.Num0BitsBelowLS1Bit(2uL));
+
+        Assert.Equal(0u, JxlMath.Num0BitsAboveMS1Bit(0x80000000u));
+        Assert.Equal(0u, JxlMath.Num0BitsAboveMS1Bit(0x8000000000000000uL));
+        Assert.Equal(31u, JxlMath.Num0BitsBelowLS1Bit(0x80000000u));
+        Assert.Equal(63u, JxlMath.Num0BitsBelowLS1Bit(0x8000000000000000uL));
+    }
+
+    [Fact]
+    public void TestFloorLog2()
+    {
+        Span<int> expected = [0, 1, 1, 2, 2, 2, 2];
+
+        for (int i = 1; i <= 7; ++i)
+        {
+            Assert.Equal(expected[i - 1], JxlMath.FloorLog2Nonzero(i));
+            Assert.Equal((ulong)expected[i - 1], JxlMath.FloorLog2Nonzero((ulong)i));
+        }
+
+        Assert.Equal(11u, JxlMath.FloorLog2Nonzero(0x00000fffu));  // 4095
+        Assert.Equal(12u, JxlMath.FloorLog2Nonzero(0x00001000u));  // 4096
+        Assert.Equal(12u, JxlMath.FloorLog2Nonzero(0x00001001u));  // 4097
+
+        Assert.Equal(31u, JxlMath.FloorLog2Nonzero(0x80000000u));
+        Assert.Equal(31u, JxlMath.FloorLog2Nonzero(0x80000001u));
+        Assert.Equal(31u, JxlMath.FloorLog2Nonzero(0xFFFFFFFFu));
+
+        Assert.Equal(31u, JxlMath.FloorLog2Nonzero(0x80000000uL));
+        Assert.Equal(31u, JxlMath.FloorLog2Nonzero(0x80000001uL));
+        Assert.Equal(31u, JxlMath.FloorLog2Nonzero(0xFFFFFFFFuL));
+
+        Assert.Equal(63u, JxlMath.FloorLog2Nonzero(0x8000000000000000uL));
+        Assert.Equal(63u, JxlMath.FloorLog2Nonzero(0x8000000000000001uL));
+        Assert.Equal(63u, JxlMath.FloorLog2Nonzero(0xFFFFFFFFFFFFFFFFuL));
+    }
+
+    [Fact]
+    public void TestCeilLog2()
+    {
+        Span<int> expected = [0, 1, 2, 2, 3, 3, 3];
+
+        for (int i = 1; i <= 7; ++i)
+        {
+            Assert.Equal(expected[i - 1], JxlMath.CeilLog2Nonzero(i));
+            Assert.Equal((ulong)expected[i - 1], JxlMath.CeilLog2Nonzero((ulong)i));
+        }
+
+        Assert.Equal(12u, JxlMath.CeilLog2Nonzero(0x00000fffu));  // 4095
+        Assert.Equal(12u, JxlMath.CeilLog2Nonzero(0x00001000u));  // 4096
+        Assert.Equal(13u, JxlMath.CeilLog2Nonzero(0x00001001u));  // 4097
+
+        Assert.Equal(31u, JxlMath.CeilLog2Nonzero(0x80000000u));
+        Assert.Equal(32u, JxlMath.CeilLog2Nonzero(0x80000001u));
+        Assert.Equal(32u, JxlMath.CeilLog2Nonzero(0xFFFFFFFFu));
+
+        Assert.Equal(31u, JxlMath.CeilLog2Nonzero(0x80000000uL));
+        Assert.Equal(32u, JxlMath.CeilLog2Nonzero(0x80000001uL));
+        Assert.Equal(32u, JxlMath.CeilLog2Nonzero(0xFFFFFFFFuL));
+
+        Assert.Equal(63u, JxlMath.CeilLog2Nonzero(0x8000000000000000uL));
+        Assert.Equal(64u, JxlMath.CeilLog2Nonzero(0x8000000000000001uL));
+        Assert.Equal(64u, JxlMath.CeilLog2Nonzero(0xFFFFFFFFFFFFFFFFuL));
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/ButteraugliTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/ButteraugliTests.cs
new file mode 100644
index 0000000000..8adabd83e7
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/ButteraugliTests.cs
@@ -0,0 +1,139 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using Microsoft.Diagnostics.Runtime.Interop;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Butteraugli;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing;
+
+/// <summary>
+/// Tests for Google Butteraugli (C# implementation), a tool
+/// used for comparing images in a more sophisticated way
+/// (the way humans may notice differences). For example,
+/// if every pixel was off by 1, PSNR, which operates on a
+/// pixel-by-pixel basis, would report a large difference,
+/// while Butteraugli would report barely any differences,
+/// as us humans wouldn't notice anything if every pixel
+/// was just off by one.
+/// </summary>
+public class ButteraugliTests
+{
+    private static JxlImage3F SinglePixelImage(float r, float g, float b)
+    {
+        JxlImage3F img = new(TestEnvironment.Configuration, 1, 1);
+        img.PlaneRow(0, 0)[0] = r;
+        img.PlaneRow(1, 0)[0] = r;
+        img.PlaneRow(2, 0)[0] = r;
+        return img;
+    }
+
+    private static void AddUniformNoise(JxlImage3F img, float d, ulong seed)
+    {
+        Rng generator = new(seed);
+
+        for (int y = 0; y < img.YSize; ++y)
+        {
+            for (int c = 0; c < 3; ++c)
+            {
+                Span<float> planeRow = img.PlaneRow(c, y);
+
+                for (int x = 0; x < img.XSize; ++x)
+                {
+                    planeRow[x] += generator.UniformF(-d, d);
+                }
+            }
+        }
+    }
+
+    private static void AddEdge(JxlImage3F image, float d, int x0, int y0)
+    {
+        int h = Math.Min(image.YSize - y0, 100);
+        int w = Math.Min(image.XSize - x0, 5);
+
+        for (int dy = 0; dy < h; ++dy)
+        {
+            Span<float> planeRow = image.PlaneRow(1, y0 + dy);
+
+            for (int dx = 0; dx < w; ++dx)
+            {
+                planeRow[x0 + dx] += d;
+            }
+        }
+    }
+
+    [Fact]
+    public void TestSinglePixel()
+    {
+        JxlImage3F rgb0 = SinglePixelImage(0.5f, 0.5f, 0.5f);
+        JxlImage3F rgb1 = SinglePixelImage(0.5f, 0.49f, 0.5f);
+
+        ButteraugliParameters butteraugliParameters = new();
+        JxlImageF diffmap = new();
+
+        Assert.True(
+            Butteraugli.ButteraugliInterface(TestEnvironment.Configuration, rgb0, rgb1, butteraugliParameters, diffmap, out double diffval),
+            "Butteraugli initialization failed");
+
+        Assert.True(new TolerantMath(0.5).AreEqual(diffval, 2.5), $"Diff value isn't even close to 2.5 (it's {diffval})");
+
+        JxlImageF diffmap2 = new();
+        Assert.True(Butteraugli.ButteraugliInterfaceInPlace(
+            TestEnvironment.Configuration,
+            rgb0,
+            rgb1,
+            butteraugliParameters,
+            diffmap2,
+            out double diffval2));
+
+        Assert.True(new TolerantMath(1e-10).AreEqual(diffval, diffval2), $"Diff value isn't even close to diffval2 (diffval={diffval}, diffval2={diffval2})");
+    }
+
+    // TODO: we need to port test image stuff from libjxl
+    [Fact]
+    public void TestLargeImage()
+    {
+        const int xSize = 1024;
+        const int ySize = 1024;
+
+        JxlTestImage img = new();
+        img.SetDimensions(xSize, ySize);
+
+        JxlTestFrame frame = img.AddFrame();
+        frame.RandomFill(777);
+
+        JxlImage3F rgb0 = GetColorImage(img.Ppf);
+        JxlImage3F rgb1 = new(TestEnvironment.Configuration, xSize, ySize);
+        JxlImageOperations.CopyImage(rgb0, rgb1);
+
+        AddUniformNoise(rgb1, 0.02f, 7777uL);
+        AddEdge(rgb1, 0.1f, xSize / 2, xSize / 2);
+
+        ButteraugliParameters butteraugliParameters = new();
+        JxlImageF diffmap = new();
+        Assert.True(
+            Butteraugli.ButteraugliInterface(TestEnvironment.Configuration,, rgb0, rgb1, butteraugliParameters, diffmap, out double diffval),
+            "Couldn't initialize Butteraugli");
+
+        double distp = Butteraugli.ComputeDistanceP(diffmap, butteraugliParameters, 3.0);
+        Assert.True(new TolerantMath(0.5).AreEqual(diffval, 4.0), $"Diff isn't even close to 4.0 (diffval={diffval})");
+        Assert.True(new TolerantMath(0.5).AreEqual(distp, 1.5), $"Distance isn't even close to 4.0 (distp={distp})");
+
+        JxlImageF diffmap2 = new();
+        Assert.True(
+            Butteraugli.ButteraugliInterfaceInPlace(
+                TestEnvironment.Configuration,
+                rgb0,
+                rgb1,
+                butteraugliParameters,
+                diffmap2,
+                out double diffval2),
+            "Butteraugli in-place interface initialization failed");
+
+        double distp2 = Butteraugli.ComputeDistanceP(diffmap2, butteraugliParameters, 3.0);
+
+        Assert.True(new TolerantMath(5e-7).AreEqual(diffval, diffval2), $"Diffval != diffval2 (diffval={diffval}, diffval2={diffval2})");
+        Assert.True(new TolerantMath(1e-7).AreEqual(distp, distp2), $"Distp != distp2 (distp={distp}, distp2={distp2})");
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/GammaCorrectionTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/GammaCorrectionTests.cs
new file mode 100644
index 0000000000..edb9751cae
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/GammaCorrectionTests.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing.Encoder;
+
+public class GammaCorrectionTests
+{
+    [Fact]
+    public void TestLinearToSRgbEdgeCases()
+    {
+        Assert.Equal(0, JxlGammaCorrect.LinearToSRgb8Direct(0.0));
+
+        Assert.True(new TolerantMath(2E-5).AreEqual(0, JxlGammaCorrect.LinearToSRgb8Direct(1E-6)));
+
+        Assert.Equal(0, JxlGammaCorrect.LinearToSRgb8Direct(-1E-6));
+        Assert.Equal(0, JxlGammaCorrect.LinearToSRgb8Direct(-1E6));
+
+        Assert.True(new TolerantMath(1E-5).AreEqual(1, JxlGammaCorrect.LinearToSRgb8Direct(1 - 1E-6)));
+
+        Assert.Equal(1, JxlGammaCorrect.LinearToSRgb8Direct(1 + 1E-6));
+        Assert.Equal(1, JxlGammaCorrect.LinearToSRgb8Direct(1E6));
+    }
+
+    [Fact]
+    public void TestRoundTrip()
+    {
+        for (double linear = 0.0; linear <= 1.0; linear += 1E-7)
+        {
+            double srgb = JxlGammaCorrect.LinearToSRgb8Direct(linear);
+            double linear2 = JxlGammaCorrect.SRgb8ToLinearDirect(srgb);
+
+            Assert.True(Math.Abs(linear - linear2) < 2E-13, $"Linear = {linear}, Linear2 = {linear2}");
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/LinearAlgebraTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/LinearAlgebraTests.cs
new file mode 100644
index 0000000000..e131952743
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/LinearAlgebraTests.cs
@@ -0,0 +1,169 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+using Matrix2x2 = System.Runtime.CompilerServices.InlineArray2<System.Runtime.CompilerServices.InlineArray2<double>>;
+using Vector2 = System.Runtime.CompilerServices.InlineArray2<double>;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing.Encoder;
+
+public class LinearAlgebraTests
+{
+    private static Vector2 CreateVector2(double a, double b)
+    {
+        Vector2 v2 = default;
+
+        v2[0] = a;
+        v2[1] = b;
+
+        return v2;
+    }
+
+    private static Matrix2x2 Diagonal(Vector2 d)
+    {
+        Matrix2x2 result = default;
+
+        result[0][0] = d[0];
+        result[0][1] = 0;
+        result[1][0] = 0;
+        result[1][1] = d[1];
+
+        return result;
+    }
+
+    private static Matrix2x2 Identity() => Diagonal(CreateVector2(1.0f, 1.0f));
+
+    private static Matrix2x2 MatrixMultiply(Matrix2x2 a, Matrix2x2 b)
+    {
+        Matrix2x2 result = default;
+
+        for (int y = 0; y < 2; y++)
+        {
+            for (int x = 0; x < 2; x++)
+            {
+                result[y][x] = (a[0][x] * b[y][0]) + (a[1][x] * b[y][1]);
+            }
+        }
+
+        return result;
+    }
+
+    private static Matrix2x2 Transpose(Matrix2x2 a)
+    {
+        Matrix2x2 result = default;
+
+        result[0] = CreateVector2(a[0][0], a[1][0]);
+        result[1] = CreateVector2(a[0][1], a[1][1]);
+
+        return result;
+    }
+
+    private static Matrix2x2 RandomSymmetricMatrix(
+        Rng rng,
+        float vmin,
+        float vmax)
+    {
+        Matrix2x2 result = default;
+
+        result[0][0] = rng.UniformF(vmin, vmax);
+        result[0][1] = rng.UniformF(vmin, vmax);
+        result[1][0] = result[0][1];
+        result[1][1] = rng.UniformF(vmin, vmax);
+
+        return result;
+    }
+
+    private static void VerifyMatrixEqual(Matrix2x2 a, Matrix2x2 b, float epsilon)
+    {
+        TolerantMath comparer = new(epsilon);
+
+        for (int y = 0; y < 2; y++)
+        {
+            for (int x = 0; x < 2; x++)
+            {
+                Assert.True(
+                    comparer.AreEqual(a[y][x], b[y][x]),
+                    $"Matrices differ at [{y}][{x}]: {a[y][x]} != {b[y][x]}");
+            }
+        }
+    }
+
+    private static void VerifyOrthogonal(Matrix2x2 a, float epsilon) => VerifyMatrixEqual(
+        Identity(),
+        MatrixMultiply(Transpose(a), a),
+        epsilon);
+
+    [Fact]
+    public void ConvertToDiagonal()
+    {
+        {
+            Matrix2x2 i = Identity();
+            Matrix2x2 u = default;
+            Vector2 d = default;
+
+            JxlLinearAlgebra.ConvertToDiagonal(i, ref d, ref u);
+
+            VerifyMatrixEqual(i, u, 1e-15f);
+
+            for (int k = 0; k < 2; k++)
+            {
+                Assert.True(
+                    Math.Abs(d[k] - 1.0f) <= 1e-15f,
+                    $"d[{k}] = {d[k]}");
+            }
+        }
+
+        {
+            Matrix2x2 a = Identity();
+            a[0][1] = 2.0f;
+            a[1][0] = 2.0f;
+
+            Matrix2x2 u = default;
+            Vector2 d = default;
+
+            JxlLinearAlgebra.ConvertToDiagonal(a, ref d, ref u);
+
+            VerifyOrthogonal(u, 1e-12f);
+            VerifyMatrixEqual(
+                a,
+                MatrixMultiply(u, MatrixMultiply(Diagonal(d), Transpose(u))),
+                1e-12f);
+        }
+
+        {
+            Matrix2x2 a = default;
+            a[0] = CreateVector2(0.000208649f, 1.13687e-12f);
+            a[1] = CreateVector2(1.13687e-12f, 0.000208649f);
+
+            Matrix2x2 u = default;
+            Vector2 d = default;
+
+            JxlLinearAlgebra.ConvertToDiagonal(a, ref d, ref u);
+
+            VerifyOrthogonal(u, 1e-12f);
+            VerifyMatrixEqual(
+                a,
+                MatrixMultiply(u, MatrixMultiply(Diagonal(d), Transpose(u))),
+                1e-11f);
+        }
+
+        {
+            Rng rng = new(0);
+
+            for (int i = 0; i < 1_000_000; i++)
+            {
+                Matrix2x2 a = RandomSymmetricMatrix(rng, -1.0f, 1.0f);
+                Matrix2x2 u = default;
+                Vector2 d = default;
+
+                JxlLinearAlgebra.ConvertToDiagonal(a, ref d, ref u);
+
+                VerifyOrthogonal(u, 1e-12f);
+                VerifyMatrixEqual(
+                    a,
+                    MatrixMultiply(u, MatrixMultiply(Diagonal(d), Transpose(u))),
+                    5e-10f);
+            }
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/Noise/PhotonNoiseTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/Noise/PhotonNoiseTests.cs
new file mode 100644
index 0000000000..4f1eb5e5a9
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Encoder/Noise/PhotonNoiseTests.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics.CodeAnalysis;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Noise;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing.Encoder.Noise;
+
+/// <summary>
+/// Tests for the simulation of photon noise in the JPEG XL encoder routines.
+/// </summary>
+public class PhotonNoiseTests
+{
+    [Fact]
+    public void TestPhotonNoiseEncoder()
+    {
+        ApproximateFloatComparer comparer = new(1e-6f);
+
+        Assert.Equal(
+            JxlPhotonNoise.SimulatePhotonNoise(xSize: 6000, ySize: 4000, iso: 100).Lookup,
+            [0.00259652f, 0.0139648f, 0.00681551f, 0.00632582f,
+             0.00694917f, 0.00803922f, 0.00934574f, 0.0107607f],
+            comparer);
+
+        Assert.Equal(
+            JxlPhotonNoise.SimulatePhotonNoise(xSize: 6000, ySize: 4000, iso: 800).Lookup,
+            [0.02077220f, 0.0420923f, 0.01820690f, 0.01439020f,
+             0.01293670f, 0.01254030f, 0.01277390f, 0.0134161f],
+            comparer);
+
+        Assert.Equal(
+            JxlPhotonNoise.SimulatePhotonNoise(xSize: 6000, ySize: 4000, iso: 6400).Lookup,
+            [0.1661770f, 0.1691120f, 0.05309080f, 0.03963960f,
+             0.03357410f, 0.03001650f, 0.02776740f, 0.0263478f],
+            comparer);
+
+        Assert.Equal(
+            JxlPhotonNoise.SimulatePhotonNoise(xSize: 4000, ySize: 3000, iso: 6400).Lookup,
+            [0.0830886f, 0.1008720f, 0.0367748f, 0.0280305f, 0.0240236f,
+             0.0218040f, 0.0205771f, 0.0200058f],
+            comparer);
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/EntropyCoderTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/EntropyCoderTests.cs
new file mode 100644
index 0000000000..d3dce2c713
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/EntropyCoderTests.cs
@@ -0,0 +1,105 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Decoder.Ans;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing;
+
+public class EntropyCoderTests
+{
+    [Fact]
+    public void PackUnpack()
+    {
+        for (int i = -31; i < 32; i++)
+        {
+            uint packed = JxlPackSigned.PackUnsigned(i);
+
+            Assert.True(packed < 63u);
+
+            int unpacked = JxlPackSigned.UnpackSigned(packed);
+
+            Assert.Equal(i, unpacked);
+        }
+    }
+
+    private sealed class MockBitReader : JxlBitReader
+    {
+        public ulong NBits { get; set; }
+
+        public ulong Bits { get; set; }
+
+        public MockBitReader(Stream stream)
+            : base(stream)
+        {
+        }
+
+        public override uint PeekBits32(uint n)
+        {
+            Assert.Equal(this.NBits, n);
+            return (uint)this.Bits;
+        }
+
+        public override uint ReadBits32(uint n)
+        {
+            Assert.Equal(this.NBits, n);
+            return (uint)this.Bits;
+        }
+    }
+
+    private static void HybridUintRoundtrip(
+        JxlAnsHybridUIntConfiguration config,
+        uint limit = 1u << 24)
+    {
+        Rng rng = new(0);
+
+        const int numIntegers = 1 << 20;
+
+        uint[] integers = new uint[numIntegers];
+        uint[] token = new uint[numIntegers];
+        uint[] nbits = new uint[numIntegers];
+        uint[] bits = new uint[numIntegers];
+
+        for (int i = 0; i < numIntegers; i++)
+        {
+            integers[i] = (uint)rng.UniformU(0, limit + 1);
+            config.Encode(
+                integers[i],
+                out token[i],
+                out nbits[i],
+                out bits[i]);
+        }
+
+        for (int i = 0; i < numIntegers; i++)
+        {
+            MockBitReader br = new(Stream.Null)
+            {
+                NBits = nbits[i],
+                Bits = bits[i]
+            };
+
+            Assert.Equal(
+                integers[i],
+                JxlAnsSymbolReader.ReadHybridUintConfig(
+                    config,
+                    token[i],
+                    ref br));
+        }
+    }
+
+    [Fact]
+    public void Test000() => HybridUintRoundtrip(new JxlAnsHybridUIntConfiguration(0, 0, 0));
+
+    [Fact]
+    public void Test411() => HybridUintRoundtrip(new JxlAnsHybridUIntConfiguration(4, 1, 1));
+
+    [Fact]
+    public void Test420() => HybridUintRoundtrip(new JxlAnsHybridUIntConfiguration(4, 2, 0));
+
+    [Fact]
+    public void Test421() => HybridUintRoundtrip(
+            new JxlAnsHybridUIntConfiguration(4, 2, 1),
+            256);
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/GaborishTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/GaborishTests.cs
new file mode 100644
index 0000000000..67461ddc89
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/GaborishTests.cs
@@ -0,0 +1,113 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Memory.ImageTypes;
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing;
+
+public class GaborishTests
+{
+    private static JxlWeightsSymmetric3 GaborishKernel(float weight1, float weight2)
+    {
+        const float weight0 = 1.0f;
+
+        // Normalize.
+        float mul = 1.0f / (weight0 + (4.0f * (weight1 + weight2)));
+        float w0 = weight0 * mul;
+        float w1 = weight1 * mul;
+        float w2 = weight2 * mul;
+
+        JxlWeightsSymmetric3 wgt = new();
+        wgt.SetC(Vector128.Create(w0));
+        wgt.SetD(Vector128.Create(w1));
+        wgt.SetR(Vector128.Create(w2));
+
+        return wgt;
+    }
+
+    private static void ConvolveGaborish(
+        JxlPlane<float> input,
+        float weight1,
+        float weight2,
+        JxlPlane<float> output)
+    {
+        Assert.True(JxlImageOperations.SameSize(input, output));
+
+        // The test will fail if this throws.
+        JxlConvolve.SlowSymmetric3(
+            input,
+            input.GetRectangle(),
+            GaborishKernel(weight1, weight2),
+            output);
+    }
+
+    private static void TestRoundTrip(
+        JxlImage3F input,
+        float maxL1)
+    {
+        JxlImage3F fwd = new(TestEnvironment.Configuration, input.XSize, input.YSize);
+
+        ConvolveGaborish(
+            input.Plane(0),
+            0,
+            0,
+            fwd.Plane(0));
+
+        ConvolveGaborish(
+            input.Plane(1),
+            0,
+            0,
+            fwd.Plane(1));
+
+        ConvolveGaborish(
+            input.Plane(2),
+            0,
+            0,
+            fwd.Plane(2));
+
+        const float w = 0.92718927264540152f;
+
+        InlineArray3<float> weights = default;
+        weights[0] = w;
+        weights[1] = w;
+        weights[2] = w;
+
+        // The test will fail if this throws.
+        JxlGaborish.InverseGaborish(
+            TestEnvironment.Configuration,
+            fwd,
+            fwd.GetRectangle(),
+            weights);
+
+        // TODO: VerifyRelativeError
+        Assert.True(
+            VerifyRelativeError(
+                input,
+                fwd,
+                maxL1,
+                1e-4f));
+    }
+
+    [Fact]
+    public void TestZero()
+    {
+        JxlImage3F input = new(TestEnvironment.Configuration, 20, 20);
+        JxlImageOperations.ZeroFillImage(input);
+        TestRoundTrip(input, 0.0f);
+    }
+
+    [Fact]
+    public void TestFlat()
+    {
+        JxlImage3F input = new(TestEnvironment.Configuration, 20, 20);
+        JxlImageOperations.FillImage(1.0f, input);
+        TestRoundTrip(input, 1e-5f);
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/ImageOperationsTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/ImageOperationsTests.cs
new file mode 100644
index 0000000000..a7751b2c49
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/ImageOperationsTests.cs
@@ -0,0 +1,146 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Memory;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Image;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing;
+
+public class ImageOperationsTests
+{
+    private static void TestFillImpl<T>(JxlImage3<T> image, string layout)
+        where T : unmanaged
+    {
+        JxlImageOperations.FillImage((T)Convert.ChangeType(1, typeof(T), null), image);
+
+        for (int y = 0; y < image.YSize; y++)
+        {
+            for (int c = 0; c < 3; c++)
+            {
+                Span<T> row = image.PlaneRow(c, y);
+
+                for (int x = 0; x < image.XSize; x++)
+                {
+                    if (!EqualityComparer<T>.Default.Equals(
+                        row[x],
+                        (T)Convert.ChangeType(1, typeof(T), null)))
+                    {
+                        Assert.Fail(
+                            $"Not 1 at c={c} {x}, {y} " +
+                            $"({image.XSize} x {image.YSize}) ({layout})");
+                    }
+
+                    row[x] = (T)Convert.ChangeType(2, typeof(T), null);
+                }
+            }
+        }
+
+        JxlImageOperations.ZeroFillImage(image);
+
+        for (int c = 0; c < 3; c++)
+        {
+            for (int y = 0; y < image.YSize; y++)
+            {
+                Span<T> row = image.PlaneRow(c, y);
+
+                for (int x = 0; x < image.XSize; x++)
+                {
+                    if (!EqualityComparer<T>.Default.Equals(
+                        row[x],
+                        default))
+                    {
+                        Assert.Fail(
+                            $"Not 0 at c={c} {x}, {y} " +
+                            $"({image.XSize} x {image.YSize}) ({layout})");
+                    }
+
+                    row[x] = (T)Convert.ChangeType(3, typeof(T), null);
+                }
+            }
+        }
+    }
+
+    private static void TestFillT<T>()
+        where T : unmanaged
+    {
+        foreach (uint xSize in new uint[] { 0, 1, 15, 16, 31, 32 })
+        {
+            foreach (uint ySize in new uint[] { 0, 1, 15, 16, 31, 32 })
+            {
+                JxlImage3<T> image = JxlImage3<T>.Create(TestEnvironment.Configuration, (int)xSize, (int)ySize);
+
+                TestFillImpl(image, "size ctor");
+            }
+        }
+    }
+
+    [Fact]
+    public void TestFill()
+    {
+        TestFillT<byte>();
+        TestFillT<short>();
+        TestFillT<float>();
+    }
+
+    [Fact]
+    public void CopyImageToWithPaddingTest()
+    {
+        JxlPlane<uint> src = JxlPlane<uint>.Create(TestEnvironment.Configuration, 100, 61);
+
+        for (int y = 0; y < src.YSize; y++)
+        {
+            Span<uint> row = src.GetRow(y);
+
+            for (int x = 0; x < src.XSize; x++)
+            {
+                row[x] = (uint)((x * 1000) + y);
+            }
+        }
+
+        Rectangle srcRect = new(10, 20, 30, 40);
+        Assert.True(srcRect.IsInside(src.GetRectangle()));
+
+        JxlPlane<uint> dst = JxlPlane<uint>.Create(TestEnvironment.Configuration, 60, 50);
+
+        JxlImageOperations.FillImage(0u, dst);
+
+        Rectangle dstRect = new(20, 5, 30, 40);
+        Assert.True(dstRect.IsInside(dst.GetRectangle()));
+
+        Assert.True(
+            JxlImageOperations.CopyImageToWithPadding(
+                srcRect,
+                src,
+                padding: 2,
+                dstRect,
+                dst));
+
+        Rectangle paddedDstRect = new(
+            20 - 2,
+            5 - 2,
+            30 + 4,
+            40 + 3);
+
+        for (int y = 0; y < dst.YSize; y++)
+        {
+            Span<uint> row = dst.GetRow(y);
+
+            for (int x = 0; x < dst.XSize; x++)
+            {
+                if (new Rectangle(x, y, 1, 1).IsInside(paddedDstRect))
+                {
+                    Assert.Equal(
+                        (uint)(
+                            ((x - dstRect.X0() + srcRect.X0()) * 1000) +
+                            (y - dstRect.Y0() + srcRect.Y0())),
+                        row[x]);
+                }
+                else
+                {
+                    Assert.Equal(0u, row[x]);
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/Primitives/LehmerCodeTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Primitives/LehmerCodeTests.cs
new file mode 100644
index 0000000000..66bd1f4a53
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Primitives/LehmerCodeTests.cs
@@ -0,0 +1,88 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Processing;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing.Primitives;
+
+public class LehmerCodeTests
+{
+    private sealed class WorkingSet(int maxN)
+    {
+        public int PaddedN { get; } = maxN << JxlMath.CeilLog2Nonzero(maxN + 1);
+
+        public uint[] Permutation { get; } = new uint[maxN];
+
+        public uint[] Temporary { get; } = new uint[maxN];
+
+        public uint[] LehmerCodes { get; } = new uint[maxN];
+
+        public uint[] Decoded { get; } = new uint[maxN];
+    }
+
+    private static void RoundTrip(int n, WorkingSet ws)
+    {
+        Assert.NotEqual(0, n);
+        int paddedN = 1 << JxlMath.CeilLog2Nonzero(n);
+
+        Rng rng = new(((ulong)n * 65537) + 13);
+        Assert.True(n < 1 << (sizeof(uint) * 8));
+
+        Span<uint> permutationsSpan = ws.Permutation.AsSpan();
+        JxlSimdUtils.Iota(permutationsSpan[..n], 0u);
+
+        for (int rep = 0; rep < 3; rep++)
+        {
+            rng.Shuffle(permutationsSpan[..n]);
+
+            Assert.True(
+                JxlLehmerCode.ComputeLehmerCode(permutationsSpan, ws.Temporary, n, ws.LehmerCodes),
+                "Could not compute Lehmer code");
+
+            ws.Temporary.AsSpan()[..(paddedN * 4)].Clear();
+
+            Assert.True(
+                JxlLehmerCode.DecodeLehmerCode(ws.LehmerCodes.AsSpan(), ws.Temporary.AsSpan(), n, ws.Decoded.AsSpan()),
+                "Could not decode Lehmer code");
+
+            for (int i = 0; i < n; ++i)
+            {
+                Assert.Equal(permutationsSpan[i], ws.Decoded[i]);
+            }
+        }
+    }
+
+    private static void RoundTripSizeRange(int begin, int end)
+    {
+        Assert.NotEqual(0, begin);
+        List<WorkingSet> workingSets = [];
+
+        int numThreads = Environment.ProcessorCount;
+
+        // initialization
+        for (int i = 0; i < numThreads; i++)
+        {
+            workingSets.Add(new WorkingSet(end - 1));
+        }
+
+        // loop
+        Parallel.For(
+            begin,
+            end,
+            () => new WorkingSet(end - 1),
+            (n, _, workingSet) =>
+            {
+                RoundTrip(n, workingSet);
+                return workingSet;
+            },
+            _ => { });
+    }
+
+    [Fact]
+    public void TestLehmerCodes()
+    {
+        RoundTripSizeRange(1, 1026);
+        RoundTripSizeRange(65536, 65540);
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Processing/Primitives/XorShiftTests.cs b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Primitives/XorShiftTests.cs
new file mode 100644
index 0000000000..756ed5668e
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Processing/Primitives/XorShiftTests.cs
@@ -0,0 +1,396 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives;
+using static SixLabors.ImageSharp.Tests.TestImages;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.Processing.Primitives;
+
+public class XorShiftTests
+{
+    private const int Vectors = 64;
+
+    private static readonly ulong[][] ExpectedVectors =
+    [
+        [0x6E901576D477CBB1uL, 0xE9E53789195DA2A2uL, 0xB681F6DDA5E0AE99uL,
+     0x8EFD18CE21FD6896uL, 0xA898A80DF75CF532uL, 0x50CEB2C9E2DE7E32uL,
+     0x3CA7C2FEB25C0DD0uL, 0xA4D0866B80B4D836uL],
+    [0x8CD6A1E6233D3A26uL, 0x3D4603ADE98B112DuL, 0xDC427AF674019E36uL,
+     0xE28B4D230705AC53uL, 0x7297E9BBA88783DDuL, 0x34D3D23CFCD9B41AuL,
+     0x5A223615ADBE96B8uL, 0xE5EB529027CFBD01uL],
+    [
+    0xC1894CF00DFAC6A2uL, 0x18EDF8AE9085E404uL, 0x8E936625296B4CCDuL,
+     0x31971EF3A14A899BuL, 0xBE87535FCE0BF26AuL, 0x576F7A752BC6649FuL,
+     0xA44CBADCE0C6B937uL, 0x3DBA819BB17A353AuL],
+    [
+    0x27CE38DFCC1C5EB6uL, 0x920BEB5606340256uL, 0x3986CBC40C9AFC2CuL,
+     0xE22BCB3EEB1E191EuL, 0x6E1FCDD3602A8FBAuL, 0x052CB044E5415A29uL,
+     0x46266646EFB9ECD7uL, 0x8F44914618D29335uL],
+    [
+    0xDD30AEDF72A362C5uL, 0xBC1D824E16BB98F4uL, 0x9EA6009C2AA3D2F1uL,
+     0xF65C0FBBE17AF081uL, 0x22424D06A8738991uL, 0x8A62763F2B7611D2uL,
+     0x2F3E89F722637939uL, 0x84D338BEF50AFD50uL],
+    [
+    0x00F46494898E2B0BuL, 0x81239DC4FB8E8003uL, 0x414AD93EC5773FE7uL,
+     0x791473C450E4110FuL, 0x87F127BF68C959ACuL, 0x6429282D695EF67BuL,
+     0x661082E11546CBA8uL, 0x5815D53FA5436BFDuL],
+    [
+    0xB3DEADAB9BE6E0F9uL, 0xAA1B7B8F7CED0202uL, 0x4C5ED437699D279EuL,
+     0xA4471727F1CB39D3uL, 0xE439DA193F802F70uL, 0xF89401BB04FA6493uL,
+     0x3B08045A4FE898BAuL, 0x32137BFE98227950uL],
+    [
+    0xFBAE4A092897FEF3uL, 0x0639F6CE56E71C8EuL, 0xF0AD6465C07F0C1EuL,
+     0xFF8E28563361DCE5uL, 0xC2013DB7F86BC6B9uL, 0x8EFCC0503330102FuL,
+     0x3F6B767EA5C4DA40uL, 0xB9864B950B2232E1uL],
+    [
+    0x76EB58DE8E5EC22AuL, 0x9BBBF49A18B32F4FuL, 0xC8405F02B2B2FAB9uL,
+     0xC3E122A5F146BC34uL, 0xC90BB046660F5765uL, 0xB933981310DBECCFuL,
+     0x5A2A7BFC9126FD1CuL, 0x8BB388C94DF87901uL],
+    [
+    0x753EB89AD63EF3C3uL, 0xF24AAF40C89D65ADuL, 0x23F68931C1A6AA6DuL,
+     0xF47E79BF702C6DD0uL, 0xA3AD113244EE7EAEuL, 0xD42CBEA28F793DC3uL,
+     0xD896FCF1820F497CuL, 0x042B86D2818948C1uL],
+    [
+    0x8F2A4FC5A4265763uL, 0xEC499E6F95EAA10CuL, 0xE3786D4ECCD0DEB5uL,
+     0xC725C53D3AC4CC43uL, 0x065A4ACBBF83610EuL, 0x35C61C9FEF167129uL,
+     0x7B720AEAA7D70048uL, 0x14206B841377D039uL],
+    [
+    0xAD27D78BF96055F6uL, 0x5F43B20FF47ADCD4uL, 0xE184C2401E2BF71EuL,
+     0x30B263D78990045DuL, 0xC22F00EBFF9BA201uL, 0xAE7F86522B53A562uL,
+     0x2853312BC039F0A4uL, 0x868D619E6549C3C8uL],
+    [
+    0xFD5493D8AE9A8371uL, 0x773D5E224DF61B3BuL, 0x5377C54FBB1A8280uL,
+     0xCAD4DE3B8265CAFAuL, 0xCDF3F19C91EBD5F6uL, 0xC8EA0F182D73BD78uL,
+     0x220502D593433FF1uL, 0xB81205E612DC31B1uL],
+    [
+    0x8F32A39EAEDA4C70uL, 0x1D4B0914AA4DAC7FuL, 0x56EF1570F3A8B405uL,
+     0x29812CB17404A592uL, 0x97A2AAF69CAE90F2uL, 0x12BF5E02778BBFE5uL,
+     0x9D4B55AD42A05FD2uL, 0x06C2BAB5E6086620uL],
+    [
+    0x8DB4B9648302B253uL, 0xD756AD9E3AEA12C7uL, 0x68709B7F11D4B188uL,
+     0x7CC299DDCD707A4BuL, 0x97B860C370A7661DuL, 0xCECD314FC20E64F5uL,
+     0x55F412CDFB4C7EC3uL, 0x55EE97591193B525uL],
+    [
+    0xCF70F3ACA96E6254uL, 0x022FEDECA2E09F46uL, 0x686823DB60AE1ECFuL,
+     0xFD36190D3739830EuL, 0x74E1C09027F68120uL, 0xB5883A835C093842uL,
+     0x93E1EFB927E9E4E3uL, 0xB2721E249D7E5EBEuL],
+    [
+    0x69B6E21C44188CB8uL, 0x5D6CFB853655A7AAuL, 0x3E001A0B425A66DCuL,
+     0x8C57451103A5138FuL, 0x7BF8B4BE18EAB402uL, 0x494102EB8761A365uL,
+     0xB33796A9F6A81F0EuL, 0x10005AB3BCCFD960uL],
+    [
+    0xB2CF25740AE965DCuL, 0x6F7C1DF7EF53D670uL, 0x648DD6087AC2251EuL,
+     0x040955D9851D487DuL, 0xBD550FC7E21A7F66uL, 0x57408F484DEB3AB5uL,
+     0x481E24C150B506C1uL, 0x72C0C3EAF91A40D6uL],
+    [
+    0x1997A481858A5D39uL, 0x539718F4BEF50DC1uL, 0x2EC4DC4787E7E368uL,
+     0xFF1CE78879419845uL, 0xE219A93DD6F6DD30uL, 0x85328618D02FEC1AuL,
+     0xC86E02D969181B20uL, 0xEBEC8CD8BBA34E6EuL],
+    [
+    0x28B55088A16CE947uL, 0xDD25AC11E6350195uL, 0xBD1F176694257B1CuL,
+     0x09459CCF9FCC9402uL, 0xF8047341E386C4E4uL, 0x7E8E9A9AD984C6C0uL,
+     0xA4661E95062AA092uL, 0x70A9947005ED1152uL],
+    [
+    0x4C01CF75DBE98CCDuL, 0x0BA076CDFC7373B9uL, 0x6C5E7A004B57FB59uL,
+     0x336B82297FD3BC56uL, 0x7990C0BE74E8D60FuL, 0xF0275CC00EC5C8C8uL,
+     0x6CF29E682DFAD2E9uL, 0xFA4361524BD95D72uL],
+    [
+    0x631D2A19FF62F018uL, 0x41C43863B985B3FAuL, 0xE052B2267038EFD9uL,
+     0xE2A535FAC575F430uL, 0xE004EEA90B1FF5B8uL, 0x42DFE2CA692A1F26uL,
+     0x90FB0BFC9A189ECCuL, 0x4484102BD3536BD0uL],
+    [
+    0xD027134E9ACCA5A5uL, 0xBBAB4F966D476A9BuL, 0x713794A96E03D693uL,
+     0x9F6335E6B94CD44AuL, 0xC5090C80E7471617uL, 0x6D9C1B0C87B58E33uL,
+     0x1969CE82E31185A5uL, 0x2099B97E87754EBEuL],
+    [
+    0x60EBAF4ED934350FuL, 0xC26FBF0BA5E6ECFFuL, 0x9E54150F0312EC57uL,
+     0x0973B48364ED0041uL, 0x800A523241426CFCuL, 0x03AB5EC055F75989uL,
+     0x8CF315935DEEB40AuL, 0x83D3FC0190BD1409uL],
+    [
+    0x26D35394CF720A51uL, 0xCE9EAA15243CBAFEuL, 0xE2B45FBAF21B29E0uL,
+     0xDB92E98EDE73F9E0uL, 0x79B16F5101C26387uL, 0x1AC15959DE88C86FuL,
+     0x387633AEC6D6A580uL, 0xA6FC05807BFC5EB8uL],
+    [
+    0x2D26C8E47C6BADA9uL, 0x820E6EC832D52D73uL, 0xB8432C3E0ED0EE5BuL,
+     0x0F84B3C4063AAA87uL, 0xF393E4366854F651uL, 0x749E1B4D2366A567uL,
+     0x805EACA43480D004uL, 0x244EBF3AA54400A5uL],
+    [
+    0xBFDC3763AA79F75AuL, 0x9E3A74CC751F41DBuL, 0xF401302A149DBC55uL,
+     0x6B25F7973D7BF7BCuL, 0x13371D34FDBC3DAEuL, 0xC5E1998C8F484DCDuL,
+     0x7031B8AE5C364464uL, 0x3847F0C4F3DA2C25uL],
+    [
+    0x24C6387D2C0F1225uL, 0x77CCE960255C67A4uL, 0x21A0947E497B10EBuL,
+     0xBB5DB73A825A9D7EuL, 0x26294A41999E553DuL, 0x3953E0089F87D925uL,
+     0x3DAE6E5D4E5EAAFEuL, 0x74B545460341A7AAuL],
+    [
+    0x710E5EB08A7DB820uL, 0x7E43C4E77CAEA025uL, 0xD4C91529C8B060C1uL,
+     0x09AE26D8A7B0CA29uL, 0xAB9F356BB360A772uL, 0xB68834A25F19F6E9uL,
+     0x79B8D9894C5734E2uL, 0xC6847E7C8FFD265FuL],
+    [
+    0x10C4BCB06A5111E6uL, 0x57CB50955B6A2516uL, 0xEF53C87798B6995FuL,
+     0xAB38E15BBD8D0197uL, 0xA51C6106EFF73C93uL, 0x83D7F0E2270A7134uL,
+     0x0923FD330397FCE5uL, 0xF9DE54EDFE58FB45uL],
+    [
+    0x07D44833ACCD1A94uL, 0xAAD3C9E945E2F9F3uL, 0xABF4C879B876AA37uL,
+     0xF29C69A21B301619uL, 0x2DDCE959111C788BuL, 0x7CEDB48F8AC1729BuL,
+     0x93F3BA9A02B659BEuL, 0xF20A87FF17933CBEuL],
+    [
+    0x8E96EBE93180CFE6uL, 0x94CAA12873937079uL, 0x05F613D9380D4189uL,
+     0xBCAB40C1DC79F38AuL, 0x0AD8907B7C61D19EuL, 0x88534E189D103910uL,
+     0x2DB2FAABA160AB8FuL, 0xA070E7506B06F15CuL],
+    [
+    0x6FB1FCDAFFEF87A9uL, 0xE735CF25337A090DuL, 0x172C6EDCEFEF1825uL,
+     0x76957EA49EF0542DuL, 0x819BF4CD250F7C49uL, 0xD6FF23E4AD00C4D4uL,
+     0xE79673C1EC358FF0uL, 0xAC9C048144337938uL],
+    [
+    0x4C5387FF258B3AF4uL, 0xEDB68FAEC2CB1AA3uL, 0x02A624E67B4E1DA4uL,
+     0x5C44797A38E08AF2uL, 0x36546A70E9411B4BuL, 0x47C17B24D2FD9675uL,
+     0x101957AAA020CA26uL, 0x47A1619D4779F122uL],
+    [
+    0xF84B8BCDC92D9A3CuL, 0x951D7D2C74B3066BuL, 0x7AC287C06EDDD9B2uL,
+     0x4C38FC476608D38FuL, 0x224D793B19CB4BCDuL, 0x835A255899BF1A41uL,
+     0x4AD250E9F62DB4ABuL, 0xD9B44F4B58781096uL],
+    [
+    0xABBAF99A8EB5C6B8uL, 0xFB568E900D3A9F56uL, 0x11EDF63D23C5DF11uL,
+     0xA9C3011D3FA7C5A8uL, 0xAEDD3CF11AFFF725uL, 0xABCA472B5F1EDD6BuL,
+     0x0600B6BB5D879804uL, 0xDB4DE007F22191A0uL],
+    [
+    0xD76CC9EFF0CE9392uL, 0xF5E0A772B59BA49AuL, 0x7D1AE1ED0C1261B5uL,
+     0x79224A33B5EA4F4AuL, 0x6DD825D80C40EA60uL, 0x47FC8E747E51C953uL,
+     0x695C05F72888BF98uL, 0x1A012428440B9015uL],
+    [
+    0xD754DD61F9B772BFuL, 0xC4A2FCF4C0F9D4EBuL, 0x461167CDF67A24A2uL,
+     0x434748490EBCB9D4uL, 0x274DD9CDCA5781DEuL, 0x36BAC63BA9A85209uL,
+     0x30324DAFDA36B70FuL, 0x337570DB4FE6DAB3uL],
+    [
+    0xF46CBDD57C551546uL, 0x8E02507E676DA3E3uL, 0xD826245A8C15406DuL,
+     0xDFB38A5B71113B72uL, 0x5EA38454C95B16B5uL, 0x28C054FB87ABF3E1uL,
+     0xAA2724C0BA1A8096uL, 0xECA83EC980304F2FuL],
+    [
+    0x6AA76EC294EB3303uL, 0x42D4CDB2A8032E3BuL, 0x7999EDF75DCD8735uL,
+     0xB422BFFE696CCDCCuL, 0x8F721461FD7CCDFEuL, 0x148E1A5814FDE253uL,
+     0x4DC941F4375EF8FFuL, 0x27B2A9E0EB5B49CFuL],
+    [
+    0xCEA592EF9343EBE1uL, 0xF7D38B5FA7698903uL, 0x6CCBF352203FEAB6uL,
+     0x830F3095FCCDA9C5uL, 0xDBEEF4B81B81C8F4uL, 0x6D7EB9BCEECA5CF9uL,
+     0xC58ABB0FBE436C69uL, 0xE4B97E6DB2041A4BuL],
+    [
+    0x7E40FC772978AF14uL, 0xCDDA4BBAE28354A1uL, 0xE4F993B832C32613uL,
+     0xD3608093C68A4B35uL, 0x9A3B60E01BEE3699uL, 0x03BEF248F3288713uL,
+     0x70B9294318F3E9B4uL, 0x8D2ABB913B8610DEuL],
+    [
+    0x37F209128E7D8B2CuL, 0x81D2AB375BD874BCuL, 0xA716A1B7373F7408uL,
+     0x0CEE97BEC4706540uL, 0xA40C5FD9CDBC1512uL, 0x73CAF6C8918409E7uL,
+     0x45E11BCEDF0BBAA1uL, 0x612C612BFF6E6605uL],
+    [
+    0xF8ECB14A12D0F649uL, 0xDA683CD7C01BA1ACuL, 0xA2203F7510E124C1uL,
+     0x7F83E52E162F3C78uL, 0x77D2BB73456ACADBuL, 0x37FC34FC840BBA6FuL,
+     0x3076BC7D4C6EBC1FuL, 0x4F514123632B5FA9uL],
+    [
+    0x44D789DED935E884uL, 0xF8291591E09FEC9FuL, 0xD9CED2CF32A2E4B7uL,
+     0x95F70E1EB604904AuL, 0xDE438FE43C14F6ABuL, 0x4C8D23E4FAFCF8D8uL,
+     0xC716910A3067EB86uL, 0x3D6B7915315095D3uL],
+    [
+    0x3170FDBADAB92095uL, 0x8F1963933FC5650BuL, 0x72F94F00ABECFEABuL,
+     0x6E3AE826C6AAB4CEuL, 0xA677A2BF31068258uL, 0x9660CDC4F363AF10uL,
+     0xD81A15A152379EF1uL, 0x5D7D285E1080A3F9uL],
+    [
+    0xDAD5DDFF9A2249B3uL, 0x6F9721D926103FAEuL, 0x1418CBB83FFA349AuL,
+     0xE71A30AD48C012B2uL, 0xBE76376C63751132uL, 0x3496467ACA713AE6uL,
+     0x8D7EC01369F991A3uL, 0xD8C73A88B96B154EuL],
+    [
+    0x8B5D9C74AEB4833AuL, 0xF914FB3F867B912FuL, 0xB894EA034936B1DCuL,
+     0x8A16D21BE51C4F5BuL, 0x31FF048ED582D98EuL, 0xB95AB2F4DC65B820uL,
+     0x04082B9170561AF7uL, 0xA215610A5DC836FAuL],
+    [
+    0xB2ADE592C092FAACuL, 0x7A1E683BCBF13294uL, 0xC7A4DBF86858C096uL,
+     0x3A49940F97BFF316uL, 0xCAE5C06B82C46703uL, 0xC7F413A0F951E2BDuL,
+     0x6665E7BB10EB5916uL, 0x86F84A5A94EDE319uL],
+    [
+    0x4EA199D8FAA79CA3uL, 0xDFA26E5BF1981704uL, 0x0F5E081D37FA4E01uL,
+     0x9CB632F89CD675CDuL, 0x4A09DB89D48C0304uL, 0x88142742EA3C7672uL,
+     0xAC4F149E6D2E9BDBuL, 0x6D9E1C23F8B1C6C6uL],
+    [
+    0xD58BE47B92DEC0E9uL, 0x8E57573645E34328uL, 0x4CC094CCB5FB5126uL,
+     0x5F1D66AF6FB40E3CuL, 0x2BA15509132D3B00uL, 0x0D6545646120E567uL,
+     0x3CF680C45C223666uL, 0x96B28E32930179DAuL],
+    [
+    0x5900C45853AC7990uL, 0x61881E3E8B7FF169uL, 0x4DE5F835DF2230FFuL,
+     0x4427A9E7932F73FFuL, 0x9B641BAD379A8C8DuL, 0xDF271E5BF98F4E5CuL,
+     0xDFDA16DB830FF5EEuL, 0x371C7E7CFB89C0E9uL],
+    [
+    0x4410A8576247A250uL, 0x6AD2DA12B45AC0D9uL, 0x18DFC72AAC85EECCuL,
+     0x06FC8BB2A0EF25C8uL, 0xEB287619C85E6118uL, 0x19553ECA67F25A2CuL,
+     0x3B9557F1DCEC5BAAuL, 0x7BAD9E8B710D1079uL],
+    [
+    0x34F365D66BD22B28uL, 0xE6E124B9F10F835DuL, 0x0573C38ABF2B24DCuL,
+     0xD32E6AF10A0125AEuL, 0x383590ACEA979519uL, 0x8376ED7A39E28205uL,
+     0xF0B7F184DCBDA435uL, 0x062A203390E31794uL],
+    [
+    0xA2AFFD7E41918760uL, 0x7F90FC1BD0819C86uL, 0x5033C08E5A969533uL,
+     0x2707AF5C6D039590uL, 0x57BBD5980F17DF9CuL, 0xD3FE6E61D763268AuL,
+     0x9E0A0AE40F335A3BuL, 0x43CF4EB0A99613C5uL],
+    [
+    0xD4D2A397CE1A7C2EuL, 0x3DF7CE7CC3212DADuL, 0x0880F0D5D356C75AuL,
+     0xA8AFC44DD03B1346uL, 0x79263B46C13A29E0uL, 0x11071B3C0ED58E7AuL,
+     0xED46DC9F538406BFuL, 0x2C94974F2B94843DuL],
+    [
+    0xE246E13C39AB5D5EuL, 0xAC1018489D955B20uL, 0x8601B558771852B8uL,
+     0x110BD4C06DB40173uL, 0x738FC8A18CCA0EBBuL, 0x6673E09BE0EA76E5uL,
+     0x024BC7A0C7527877uL, 0x45E6B4652E2EC34EuL],
+    [
+    0xD1ED26A1A375CDC8uL, 0xAABC4E896A617CB8uL, 0x0A9C9E8E57D753C6uL,
+     0xA3774A75FEB4C30EuL, 0x30B816C01C93E49EuL, 0xF405BABC06D2408CuL,
+     0xCC0CE6B4CE788ABCuL, 0x75E7922D0447956CuL],
+    [
+    0xD07C1676A698BC95uL, 0x5F9AEA4840E2D860uL, 0xD5FC10D58BDF6F02uL,
+     0xF190A2AD4BC2EEA7uL, 0x0C24D11F51726931uL, 0xDB646899A16B6512uL,
+     0x7BC10670047B1DD8uL, 0x2413A5ABCD45F092uL],
+    [
+    0x4E66892190CFD923uL, 0xF10162440365EC8EuL, 0x158ACA5A6A2280AEuL,
+     0x0D60ED11C0224166uL, 0x7CD2E9A71B9D7488uL, 0x450D7289706AB2A3uL,
+     0x88FAE34EC9A0D7DCuL, 0x96FF9103575A97DAuL],
+    [
+    0x77990FAC6046C446uL, 0xB174B5FB30C76676uL, 0xE352CE3EB56CF82AuL,
+     0xC6039B6873A9A082uL, 0xE3F80F3AE333148AuL, 0xB853BA24BA3539B9uL,
+     0xE8863E52ECCB0C74uL, 0x309B4CC1092CC245uL],
+    [
+    0xBC2B70BEE8388D9FuL, 0xE48D92AE22216DCEuL, 0xF15F3BF3E2C15D8FuL,
+     0x1DD964D4812D8B24uL, 0xD56AF02FB4665E4CuL, 0x98002200595BD9A3uL,
+     0x049246D50BB8FA12uL, 0x1B542DF485B579B9uL],
+    [
+    0x2347409ADFA8E497uL, 0x36015C2211D62498uL, 0xE9F141F32EB82690uL,
+     0x1F839912D0449FB9uL, 0x4E4DCFFF2D02D97CuL, 0xF8A03AB4C0F625C9uL,
+     0x0605F575795DAC5CuL, 0x4746C9BEA0DDA6B1uL],
+    [
+    0xCA5BB519ECE7481BuL, 0xFD496155E55CA945uL, 0xF753B9DBB1515F81uL,
+     0x50549E8BAC0F70E7uL, 0x8614FB0271E21C60uL, 0x60C72947EB0F0070uL,
+     0xA6511C10AEE742B6uL, 0x48FB48F2CACCB43EuL]
+    ];
+
+    [Fact]
+    public void TestGolden()
+    {
+        JxlXorShift rng = new(12345);
+        Span<ulong> lanes = stackalloc ulong[JxlXorShift.Generators];
+
+        for (ulong vector = 0; vector < Vectors; vector++)
+        {
+            rng.Fill(lanes);
+
+            for (int i = 0; i < JxlXorShift.Generators; i++)
+            {
+                Assert.Equal(ExpectedVectors[(int)vector][i], lanes[i]);
+            }
+        }
+    }
+
+    [Fact]
+    public void TestSeedChanges()
+    {
+        Span<ulong> lanes = stackalloc ulong[JxlXorShift.Generators];
+        const int numberOfSeeds = 16384;
+
+        List<ulong> first = new(numberOfSeeds);
+        for (int seed = 0; seed < numberOfSeeds; seed++)
+        {
+            JxlXorShift xs128Plus = new((ulong)seed);
+            xs128Plus.Fill(lanes);
+            first.Add(lanes[0]);
+        }
+
+        Assert.Equal(numberOfSeeds, first.Count);
+        first.Sort();
+        first = [.. first.Distinct()];
+        Assert.Equal(numberOfSeeds, first.Count);
+    }
+
+    [Fact]
+    public void TestFloat()
+    {
+#if ALLOW_JPEGXL_SLOW_TESTS
+        const int seedMax = 4096;
+#else
+        const int seedMax = 256;
+#endif
+
+        Parallel.For(0, seedMax, seed =>
+        {
+            const int VecCap = 16;
+
+            JxlXorShift rng = new((ulong)seed);
+
+            Span<ulong> batch64 = stackalloc ulong[JxlXorShift.Generators];
+            Span<uint> batch32 = stackalloc uint[2 * JxlXorShift.Generators];
+
+            Span<float> lanes = stackalloc float[Vector<float>.Count];
+
+            int count = 0;
+            const int reps = 32000;
+            double sum = 0.0;
+            while (count < reps)
+            {
+                rng.Fill(batch64);
+
+                MemoryMarshal.Cast<ulong, uint>(batch64).CopyTo(batch32);
+
+                for (int i = 0; i < VecCap; i += Vector<float>.Count)
+                {
+                    Vector<uint> bits = new(batch32.Slice(i, Vector<uint>.Count));
+
+                    // (bits >> 9) | 0x3F800000
+                    Vector<uint> shifted = bits >> 9;
+                    Vector<uint> mantissa = shifted | new Vector<uint>(0x3F800000);
+
+                    Vector<float> rand12 = Vector.AsVectorSingle(mantissa);
+
+                    rand12.CopyTo(lanes);
+
+                    for (int j = 0; j < Vector<float>.Count; j++)
+                    {
+                        float lane = lanes[j];
+                        sum += lane;
+                        count++;
+
+                        Assert.True(lane < 2.0f);
+                        Assert.True(lane >= 1.0f);
+                    }
+                }
+            }
+        });
+    }
+
+    [Fact]
+    public void TestNotZero()
+    {
+#if ALLOW_JPEGXL_SLOW_TESTS
+        const int seedMax = 2000;
+#else
+        const int seedMax = 500;
+#endif
+
+        Parallel.For(0, seedMax, task =>
+        {
+            Span<ulong> lanes = stackalloc ulong[JxlXorShift.Generators];
+            JxlXorShift rng = new((ulong)task);
+            int numZero = 0;
+
+            for (int vectors = 0; vectors < 10000; vectors++)
+            {
+                rng.Fill(lanes);
+                for (int i = 0; i < lanes.Length; i++)
+                {
+                    if (lanes[i] == 0)
+                    {
+                        numZero++;
+                    }
+                }
+            }
+
+            Assert.True(numZero < 1, "There should not be any 0 values produced by the RNG");
+        });
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/README.md b/tests/ImageSharp.Tests/Formats/Jxl/README.md
new file mode 100644
index 0000000000..80fa3f63ab
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/README.md
@@ -0,0 +1,5 @@
+# JPEG XL Tests
+
+### Preprocessor directives
+Enable a `ALLOW_JPEGXL_SLOW_TESTS` preprocessor directive to allow
+slower tests that test the library more extensively.
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/Rng.cs b/tests/ImageSharp.Tests/Formats/Jxl/Rng.cs
new file mode 100644
index 0000000000..b862171520
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/Rng.cs
@@ -0,0 +1,87 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl;
+
+/// <summary>
+/// Deterministic random number generator used for compatibility
+/// with JPEG XL tests.
+/// </summary>
+internal struct Rng
+{
+    private ulong s0;
+    private ulong s1;
+
+    public Rng(ulong seed)
+    {
+        this.s0 = 0x94D049BB133111EBUL;
+        this.s1 = 0xBF58476D1CE4E5B9UL + seed;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ulong Next()
+    {
+        ulong s1 = this.s0;
+        ulong s0 = this.s1;
+        ulong bits = s1 + s0;
+        this.s0 = s0;
+
+        s1 ^= s1 << 23;
+        s1 ^= s0 ^ (s1 >> 18) ^ (s0 >> 5);
+
+        this.s1 = s1;
+
+        return bits;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public long UniformI(long begin, long end) => (long)(this.Next() % (ulong)(end - begin)) + begin;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ulong UniformU(ulong begin, ulong end) => (this.Next() % (end - begin)) + begin;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float UniformF(float begin, float end)
+    {
+        uint u = (uint)(this.Next() >> (64 - 23)) | 0x3F800000u;
+        float f = BitConverter.UInt32BitsToSingle(u);
+
+        return ((end - begin) * (f - 1.0f)) + begin;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Bernoulli(float p) => this.UniformF(0, 1) < p;
+
+    internal readonly struct GeometricDistribution
+    {
+        public readonly float Value { get; }
+
+        public GeometricDistribution(float value) => this.Value = value;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static GeometricDistribution Make(float p) => new(1.0f / MathF.Log(1.0f - p));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public uint Geometric(in GeometricDistribution dist)
+    {
+        float f = this.UniformF(0, 1);
+        float invLog1mp = dist.Value;
+
+        float log = MathF.Log(1.0f - f) * invLog1mp;
+
+        return (uint)log;
+    }
+
+    public void Shuffle<T>(Span<T> span)
+    {
+        for (nuint i = 0; i + 1 < (nuint)span.Length; i++)
+        {
+            nuint a = (nuint)this.UniformU(i, (nuint)span.Length);
+            RuntimeUtility.Swap(ref span[(int)a], ref span[(int)i]);
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/TestUtils/ColorEncodingDescriptor.cs b/tests/ImageSharp.Tests/Formats/Jxl/TestUtils/ColorEncodingDescriptor.cs
new file mode 100644
index 0000000000..581faf1a2b
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/TestUtils/ColorEncodingDescriptor.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.Cms;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.TestUtils;
+
+internal struct ColorEncodingDescriptor
+{
+    public JxlColorSpace ColorSpace { get; set; }
+
+    public JxlWhitePoint WhitePoint { get; set; }
+
+    public JxlPrimaries Primaries { get; set; }
+
+    public JxlTransferFunction TransferFunction { get; set; }
+
+    public JxlRenderingIntent RenderingIntent { get; set; }
+}
diff --git a/tests/ImageSharp.Tests/Formats/Jxl/TestUtils/TestDCT.cs b/tests/ImageSharp.Tests/Formats/Jxl/TestUtils/TestDCT.cs
new file mode 100644
index 0000000000..244b4c9076
--- /dev/null
+++ b/tests/ImageSharp.Tests/Formats/Jxl/TestUtils/TestDCT.cs
@@ -0,0 +1,108 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jxl.TestUtils;
+
+/// <summary>
+/// This is a naive Discrete Cosine Transform, without any optimization.
+/// It is a reference to test against the optimized DCT.
+/// </summary>
+internal static class TestDCT
+{
+    private static double Alpha(int u) => u == 0 ? 0.7071067811865475 : 1.0;
+
+    public static void Dct1D(ReadOnlySpan<double> block, Span<double> output, int n, int m)
+    {
+        Span<double> matrix = stackalloc double[n * n];
+        double scale = Math.Sqrt(2.0) / n;
+
+        for (int y = 0; y < n; y++)
+        {
+            for (int u = 0; u < n; u++)
+            {
+                matrix[(n * u) + y] =
+                    Alpha(u) *
+                    Math.Cos((y + 0.5) * u * Math.PI / n) *
+                    scale;
+            }
+        }
+
+        for (int x = 0; x < m; x++)
+        {
+            for (int u = 0; u < n; u++)
+            {
+                output[(m * u) + x] = 0;
+
+                for (int y = 0; y < n; y++)
+                {
+                    output[(m * u) + x] += matrix[(n * u) + y] * block[(m * y) + x];
+                }
+            }
+        }
+    }
+
+    public static void Idct1D(ReadOnlySpan<double> block, Span<double> output, int n, int m)
+    {
+        Span<double> matrix = stackalloc double[n * n];
+        double scale = Math.Sqrt(2.0);
+
+        for (int y = 0; y < n; y++)
+        {
+            for (int u = 0; u < n; u++)
+            {
+                matrix[(n * y) + u] =
+                    Alpha(u) *
+                    Math.Cos((y + 0.5) * u * Math.PI / n) *
+                    scale;
+            }
+        }
+
+        for (int x = 0; x < m; x++)
+        {
+            for (int u = 0; u < n; u++)
+            {
+                output[(m * u) + x] = 0;
+
+                for (int y = 0; y < n; y++)
+                {
+                    output[(m * u) + x] += matrix[(n * u) + y] * block[(m * y) + x];
+                }
+            }
+        }
+    }
+
+    public static void TransposeBlock(ReadOnlySpan<double> input, Span<double> output, int n, int m)
+    {
+        for (int x = 0; x < n; x++)
+        {
+            for (int y = 0; y < m; y++)
+            {
+                output[(y * n) + x] = input[(x * m) + y];
+            }
+        }
+    }
+
+    public static void DctSlow(Span<double> block, int n)
+    {
+        int blockSize = n * n;
+        Span<double> g = stackalloc double[blockSize];
+
+        Dct1D(block, g, n, n);
+        TransposeBlock(g, block, n, n);
+
+        Dct1D(block, g, n, n);
+        TransposeBlock(g, block, n, n);
+    }
+
+    public static void IdctSlow(Span<double> block, int n)
+    {
+        int blockSize = n * n;
+        Span<double> g = stackalloc double[blockSize];
+
+        Idct1D(block, g, n, n);
+        TransposeBlock(g, block, n, n);
+
+        Idct1D(block, g, n, n);
+        TransposeBlock(g, block, n, n);
+    }
+}