Support for JPEG XL (JXL) images

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

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

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

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

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

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

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

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

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

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