Support for JPEG XL (JXL) images

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);
+}

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;
+}

src/ImageSharp/Formats/Jxl/Fields/JxlBitsCoder.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Jxl.IO;
+
+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.
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    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;
+    }
+
+    // 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);
+}

src/ImageSharp/Formats/Jxl/Fields/JxlBundle.cs

@@ -0,0 +1,89 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jxl.IO;
+
+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;
+    }
+
+    /// <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;
+    }
+}

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(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;
+    }
+}

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++;
+    }
+}