Merge branch 'main' into js/resolution

src/ImageSharp/Formats/Png/PngChunkType.cs

@@ -140,6 +140,12 @@ internal enum PngChunkType : uint
     /// <remarks>cHRM (Single)</remarks>
     Chroma = 0x6348524d,
 
+    /// <summary>
+    /// If this chunk is present, it specifies the color space, transfer function, matrix coefficients of the image
+    /// using the code points specified in [ITU-T-H.273]
+    /// </summary>
+    Cicp = 0x63494350,
+
     /// <summary>
     /// This chunk is an ancillary chunk as defined in the PNG Specification.
     /// It must appear before the first IDAT chunk within a valid PNG stream.

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -17,6 +17,7 @@ using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Memory.Internals;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
@@ -191,6 +192,9 @@ internal sealed class PngDecoderCore : IImageDecoderInternals
                         case PngChunkType.Gamma:
                             ReadGammaChunk(pngMetadata, chunk.Data.GetSpan());
                             break;
+                        case PngChunkType.Cicp:
+                            ReadCicpChunk(metadata, chunk.Data.GetSpan());
+                            break;
                         case PngChunkType.FrameControl:
                             frameCount++;
                             if (frameCount == this.maxFrames)
@@ -360,6 +364,15 @@ internal sealed class PngDecoderCore : IImageDecoderInternals
 
                             ReadGammaChunk(pngMetadata, chunk.Data.GetSpan());
                             break;
+                        case PngChunkType.Cicp:
+                            if (this.colorMetadataOnly)
+                            {
+                                this.SkipChunkDataAndCrc(chunk);
+                                break;
+                            }
+
+                            ReadCicpChunk(metadata, chunk.Data.GetSpan());
+                            break;
                         case PngChunkType.FrameControl:
                             ++frameCount;
                             if (frameCount == this.maxFrames)
@@ -1426,6 +1439,26 @@ internal sealed class PngDecoderCore : IImageDecoderInternals
         return false;
     }
 
+    /// <summary>
+    /// Reads the CICP color profile chunk.
+    /// </summary>
+    /// <param name="metadata">The metadata.</param>
+    /// <param name="data">The bytes containing the profile.</param>
+    private static void ReadCicpChunk(ImageMetadata metadata, ReadOnlySpan<byte> data)
+    {
+        if (data.Length < 4)
+        {
+            // Ignore invalid cICP chunks.
+            return;
+        }
+
+        byte colorPrimaries = data[0];
+        byte transferFunction = data[1];
+        byte matrixCoefficients = data[2];
+        bool? fullRange = data[3] == 1 ? true : data[3] == 0 ? false : null;
+        metadata.CicpProfile = new CicpProfile(colorPrimaries, transferFunction, matrixCoefficients, fullRange);
+    }
+
     /// <summary>
     /// Reads exif data encoded into a text chunk with the name "raw profile type exif".
     /// This method was used by ImageMagick, exiftool, exiv2, digiKam, etc, before the

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -177,6 +177,7 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
 
         this.WriteHeaderChunk(stream);
         this.WriteGammaChunk(stream);
+        this.WriteCicpChunk(stream, metadata);
         this.WriteColorProfileChunk(stream, metadata);
         this.WritePaletteChunk(stream, quantized);
         this.WriteTransparencyChunk(stream, pngMetadata);
@@ -852,6 +853,32 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
         this.WriteChunk(stream, PngChunkType.InternationalText, payload);
     }
 
+    /// <summary>
+    /// Writes the CICP profile chunk
+    /// </summary>
+    /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+    /// <param name="metaData">The image meta data.</param>
+    private void WriteCicpChunk(Stream stream, ImageMetadata metaData)
+    {
+        if (metaData.CicpProfile is null)
+        {
+            return;
+        }
+
+        // by spec, the matrix coefficients must be set to Identity
+        if (metaData.CicpProfile.MatrixCoefficients != Metadata.Profiles.Cicp.CicpMatrixCoefficients.Identity)
+        {
+            throw new NotSupportedException("CICP matrix coefficients other than Identity are not supported in PNG");
+        }
+
+        Span<byte> outputBytes = this.chunkDataBuffer.Span[..4];
+        outputBytes[0] = (byte)metaData.CicpProfile.ColorPrimaries;
+        outputBytes[1] = (byte)metaData.CicpProfile.TransferCharacteristics;
+        outputBytes[2] = (byte)metaData.CicpProfile.MatrixCoefficients;
+        outputBytes[3] = (byte)(metaData.CicpProfile.FullRange ? 1 : 0);
+        this.WriteChunk(stream, PngChunkType.Cicp, outputBytes);
+    }
+
     /// <summary>
     /// Writes the color profile chunk.
     /// </summary>

src/ImageSharp/Metadata/ImageFrameMetadata.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Iptc;
@@ -43,6 +44,7 @@ public sealed class ImageFrameMetadata : IDeepCloneable<ImageFrameMetadata>
         this.IccProfile = other.IccProfile?.DeepClone();
         this.IptcProfile = other.IptcProfile?.DeepClone();
         this.XmpProfile = other.XmpProfile?.DeepClone();
+        this.CicpProfile = other.CicpProfile?.DeepClone();
     }
 
     /// <summary>
@@ -65,6 +67,11 @@ public sealed class ImageFrameMetadata : IDeepCloneable<ImageFrameMetadata>
     /// </summary>
     public IptcProfile? IptcProfile { get; set; }
 
+    /// <summary>
+    /// Gets or sets the CICP profile
+    /// </summary>
+    public CicpProfile? CicpProfile { get; set; }
+
     /// <inheritdoc/>
     public ImageFrameMetadata DeepClone() => new(this);
 

src/ImageSharp/Metadata/ImageMetadata.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Iptc;
@@ -68,6 +69,7 @@ public sealed class ImageMetadata : IDeepCloneable<ImageMetadata>
         this.IccProfile = other.IccProfile?.DeepClone();
         this.IptcProfile = other.IptcProfile?.DeepClone();
         this.XmpProfile = other.XmpProfile?.DeepClone();
+        this.CicpProfile = other.CicpProfile?.DeepClone();
 
         // NOTE: This clone is actually shallow but we share the same format
         // instances for all images in the configuration.
@@ -157,6 +159,11 @@ public sealed class ImageMetadata : IDeepCloneable<ImageMetadata>
     /// </summary>
     public IptcProfile? IptcProfile { get; set; }
 
+    /// <summary>
+    /// Gets or sets the CICP profile.
+    /// </summary>
+    public CicpProfile? CicpProfile { get; set; }
+
     /// <summary>
     /// Gets the original format, if any, the image was decode from.
     /// </summary>

src/ImageSharp/Metadata/Profiles/CICP/CicpProfile.cs

@@ -0,0 +1,72 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Cicp;
+
+/// <summary>
+/// Represents a Cicp profile as per ITU-T H.273 / ISO/IEC 23091-2_2019 providing access to color space information
+/// </summary>
+public sealed class CicpProfile : IDeepCloneable<CicpProfile>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CicpProfile"/> class.
+    /// </summary>
+    public CicpProfile()
+        : this(2, 2, 2, null)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CicpProfile"/> class.
+    /// </summary>
+    /// <param name="colorPrimaries">The color primaries as number according to ITU-T H.273 / ISO/IEC 23091-2_2019.</param>
+    /// <param name="transferCharacteristics">The transfer characteristics as number according to ITU-T H.273 / ISO/IEC 23091-2_2019.</param>
+    /// <param name="matrixCoefficients">The matrix coefficients as number according to ITU-T H.273 / ISO/IEC 23091-2_2019.</param>
+    /// <param name="fullRange">The full range flag, or null if unknown.</param>
+    public CicpProfile(byte colorPrimaries, byte transferCharacteristics, byte matrixCoefficients, bool? fullRange)
+    {
+        this.ColorPrimaries = Enum.IsDefined(typeof(CicpColorPrimaries), colorPrimaries) ? (CicpColorPrimaries)colorPrimaries : CicpColorPrimaries.Unspecified;
+        this.TransferCharacteristics = Enum.IsDefined(typeof(CicpTransferCharacteristics), transferCharacteristics) ? (CicpTransferCharacteristics)transferCharacteristics : CicpTransferCharacteristics.Unspecified;
+        this.MatrixCoefficients = Enum.IsDefined(typeof(CicpMatrixCoefficients), matrixCoefficients) ? (CicpMatrixCoefficients)matrixCoefficients : CicpMatrixCoefficients.Unspecified;
+        this.FullRange = fullRange ?? (this.MatrixCoefficients == CicpMatrixCoefficients.Identity);
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CicpProfile"/> class
+    /// by making a copy from another CICP profile.
+    /// </summary>
+    /// <param name="other">The other CICP profile, where the clone should be made from.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="other"/> is null.</exception>>
+    private CicpProfile(CicpProfile other)
+    {
+        Guard.NotNull(other, nameof(other));
+
+        this.ColorPrimaries = other.ColorPrimaries;
+        this.TransferCharacteristics = other.TransferCharacteristics;
+        this.MatrixCoefficients = other.MatrixCoefficients;
+        this.FullRange = other.FullRange;
+    }
+
+    /// <summary>
+    /// Gets or sets the color primaries
+    /// </summary>
+    public CicpColorPrimaries ColorPrimaries { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transfer characteristics
+    /// </summary>
+    public CicpTransferCharacteristics TransferCharacteristics { get; set; }
+
+    /// <summary>
+    /// Gets or sets the matrix coefficients
+    /// </summary>
+    public CicpMatrixCoefficients MatrixCoefficients { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the colors use the full numeric range
+    /// </summary>
+    public bool FullRange { get; set; }
+
+    /// <inheritdoc/>
+    public CicpProfile DeepClone() => new(this);
+}

src/ImageSharp/Metadata/Profiles/CICP/Enums/CicpColorPrimaries.cs

@@ -0,0 +1,86 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Cicp;
+
+#pragma warning disable CA1707 // Underscores in enum members
+
+/// <summary>
+/// Color primaries according to ITU-T H.273 / ISO/IEC 23091-2_2019 subclause 8.1
+/// </summary>
+public enum CicpColorPrimaries : byte
+{
+    /// <summary>
+    /// Rec. ITU-R BT.709-6
+    /// IEC 61966-2-1 sRGB or sYCC
+    /// IEC 61966-2-4
+    /// SMPTE RP 177 (1993) Annex B
+    /// </summary>
+    ItuRBt709_6 = 1,
+
+    /// <summary>
+    /// Image characteristics are unknown or are determined by the application.
+    /// </summary>
+    Unspecified = 2,
+
+    /// <summary>
+    /// Rec. ITU-R BT.470-6 System M (historical)
+    /// </summary>
+    ItuRBt470_6M = 4,
+
+    /// <summary>
+    /// Rec. ITU-R BT.601-7 625
+    /// Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM
+    /// </summary>
+    ItuRBt601_7_625 = 5,
+
+    /// <summary>
+    /// Rec. ITU-R BT.601-7 525
+    /// Rec. ITU-R BT.1700-0 NTSC
+    /// SMPTE ST 170 (2004)
+    /// (functionally the same as the value 7)
+    /// </summary>
+    ItuRBt601_7_525 = 6,
+
+    /// <summary>
+    /// SMPTE ST 240 (1999)
+    /// (functionally the same as the value 6)
+    /// </summary>
+    SmpteSt240 = 7,
+
+    /// <summary>
+    /// Generic film (colour filters using Illuminant C)
+    /// </summary>
+    GenericFilm = 8,
+
+    /// <summary>
+    /// Rec. ITU-R BT.2020-2
+    /// Rec. ITU-R BT.2100-2
+    /// </summary>
+    ItuRBt2020_2 = 9,
+
+    /// <summary>
+    /// SMPTE ST 428-1 (2019)
+    /// (CIE 1931 XYZ as in ISO 11664-1)
+    /// </summary>
+    SmpteSt428_1 = 10,
+
+    /// <summary>
+    /// SMPTE RP 431-2 (2011)
+    /// DCI P3
+    /// </summary>
+    SmpteRp431_2 = 11,
+
+    /// <summary>
+    /// SMPTE ST 432-1 (2010)
+    /// P3 D65 / Display P3
+    /// </summary>
+    SmpteEg432_1 = 12,
+
+    /// <summary>
+    /// EBU Tech.3213-E
+    /// </summary>
+    EbuTech3213E = 22,
+}
+
+#pragma warning restore CA1707 // Underscores in enum members

src/ImageSharp/Metadata/Profiles/CICP/Enums/CicpMatrixCoefficients.cs

@@ -0,0 +1,96 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Cicp;
+
+#pragma warning disable CA1707 // Underscores in enum members
+
+/// <summary>
+/// Matrix coefficients according to ITU-T H.273 / ISO/IEC 23091-2_2019 subclause 8.3
+/// </summary>
+public enum CicpMatrixCoefficients : byte
+{
+    /// <summary>
+    /// The identity matrix.
+    /// IEC 61966-2-1 sRGB
+    /// SMPTE ST 428-1 (2019)
+    /// </summary>
+    Identity = 0,
+
+    /// <summary>
+    /// Rec. ITU-R BT.709-6
+    /// IEC 61966-2-4 xvYCC709
+    /// SMPTE RP 177 (1993) Annex B
+    /// </summary>
+    ItuRBt709_6 = 1,
+
+    /// <summary>
+    /// Image characteristics are unknown or are determined by the application.
+    /// </summary>
+    Unspecified = 2,
+
+    /// <summary>
+    /// FCC Title 47 Code of Federal Regulations 73.682 (a) (20)
+    /// </summary>
+    Fcc47 = 4,
+
+    /// <summary>
+    /// Rec. ITU-R BT.601-7 625
+    /// Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM
+    /// IEC 61966-2-1 sYCC
+    /// IEC 61966-2-4 xvYCC601
+    /// (functionally the same as the value 6)
+    /// </summary>
+    ItuRBt601_7_625 = 5,
+
+    /// <summary>
+    /// Rec. ITU-R BT.601-7 525
+    /// Rec. ITU-R BT.1700-0 NTSC
+    /// SMPTE ST 170 (2004)
+    /// (functionally the same as the value 5)
+    /// </summary>
+    ItuRBt601_7_525 = 6,
+
+    /// <summary>
+    /// SMPTE ST 240 (1999)
+    /// </summary>
+    SmpteSt240 = 7,
+
+    /// <summary>
+    /// YCgCo
+    /// </summary>
+    YCgCo = 8,
+
+    /// <summary>
+    /// Rec. ITU-R BT.2020-2 (non-constant luminance)
+    /// Rec. ITU-R BT.2100-2 Y′CbCr
+    /// </summary>
+    ItuRBt2020_2_Ncl = 9,
+
+    /// <summary>
+    /// Rec. ITU-R BT.2020-2 (constant luminance)
+    /// </summary>
+    ItuRBt2020_2_Cl = 10,
+
+    /// <summary>
+    /// SMPTE ST 2085 (2015)
+    /// </summary>
+    SmpteSt2085 = 11,
+
+    /// <summary>
+    /// Chromaticity-derived non-constant luminance system
+    /// </summary>
+    ChromaDerivedNcl = 12,
+
+    /// <summary>
+    /// Chromaticity-derived constant luminance system
+    /// </summary>
+    ChromaDerivedCl = 13,
+
+    /// <summary>
+    /// Rec. ITU-R BT.2100-2 ICtCp
+    /// </summary>
+    ICtCp = 14,
+}
+
+#pragma warning restore CA1707 // Underscores in enum members

src/ImageSharp/Metadata/Profiles/CICP/Enums/CicpTransferCharacteristics.cs

@@ -0,0 +1,109 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Cicp;
+
+#pragma warning disable CA1707 // Underscores in enum values
+
+/// <summary>
+/// Transfer characteristics according to ITU-T H.273 / ISO/IEC 23091-2_2019 subclause 8.2
+/// /// </summary>
+public enum CicpTransferCharacteristics : byte
+{
+    /// <summary>
+    /// Rec. ITU-R BT.709-6
+    /// (functionally the same as the values 6, 14 and 15)
+    /// </summary>
+    ItuRBt709_6 = 1,
+
+    /// <summary>
+    /// Image characteristics are unknown or are determined by the application.
+    /// </summary>
+    Unspecified = 2,
+
+    /// <summary>
+    /// Assumed display gamma 2.2
+    /// Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM
+    /// </summary>
+    Gamma2_2 = 4,
+
+    /// <summary>
+    /// Assumed display gamma 2.8
+    /// Rec. ITU-R BT.470-6 System B, G (historical)
+    /// </summary>
+    Gamma2_8 = 5,
+
+    /// <summary>
+    /// Rec. ITU-R BT.601-7 525 or 625
+    /// Rec. ITU-R BT.1700-0 NTSC
+    /// SMPTE ST 170 (2004)
+    /// (functionally the same as the values 1, 14 and 15)
+    /// </summary>
+    ItuRBt601_7 = 6,
+
+    /// <summary>
+    /// SMPTE ST 240 (1999)
+    /// </summary>
+    SmpteSt240 = 7,
+
+    /// <summary>
+    /// Linear transfer characteristics
+    /// </summary>
+    Linear = 8,
+
+    /// <summary>
+    /// Logarithmic transfer characteristic (100:1 range)
+    /// </summary>
+    Log100 = 9,
+
+    /// <summary>
+    /// Logarithmic transfer characteristic (100 * Sqrt( 10 ) : 1 range)
+    /// </summary>
+    Log100Sqrt = 10,
+
+    /// <summary>
+    /// IEC 61966-2-4
+    /// </summary>
+    Iec61966_2_4 = 11,
+
+    /// <summary>
+    /// Rec. ITU-R BT.1361-0 extended colour gamut system (historical)
+    /// </summary>
+    ItuRBt1361_0 = 12,
+
+    /// <summary>
+    /// IEC 61966-2-1 sRGB or sYCC / Display P3
+    /// </summary>
+    Iec61966_2_1 = 13,
+
+    /// <summary>
+    /// Rec. ITU-R BT.2020-2 (10-bit system)
+    /// (functionally the same as the values 1, 6 and 15)
+    /// </summary>
+    ItuRBt2020_2_10bit = 14,
+
+    /// <summary>
+    /// Rec. ITU-R BT.2020-2 (12-bit system)
+    /// (functionally the same as the values 1, 6 and 14)
+    /// /// </summary>
+    ItuRBt2020_2_12bit = 15,
+
+    /// <summary>
+    /// SMPTE ST 2084 (2014) for 10-, 12-, 14- and 16-bit systems
+    /// Rec. ITU-R BT.2100-2 perceptual quantization (PQ) system
+    /// </summary>
+    SmpteSt2084 = 16,
+
+    /// <summary>
+    /// SMPTE ST 428-1 (2019)
+    /// </summary>
+    SmpteSt428_1 = 17,
+
+    /// <summary>
+    /// ARIB STD-B67 (2015)
+    /// Rec. ITU-R BT.2100-2 hybrid log-gamma (HLG) system
+    /// </summary>
+    AribStdB67 = 18,
+}
+
+#pragma warning restore CA1707 // Underscores in enum members

tests/ImageSharp.Tests/Formats/Png/PngChunkTypeTests.cs

@@ -29,6 +29,7 @@ public class PngChunkTypeTests
         Assert.Equal(PngChunkType.Background, GetType("bKGD"));
         Assert.Equal(PngChunkType.EmbeddedColorProfile, GetType("iCCP"));
         Assert.Equal(PngChunkType.StandardRgbColourSpace, GetType("sRGB"));
+        Assert.Equal(PngChunkType.Cicp, GetType("cICP"));
         Assert.Equal(PngChunkType.SignificantBits, GetType("sBIT"));
         Assert.Equal(PngChunkType.Histogram, GetType("hIST"));
         Assert.Equal(PngChunkType.SuggestedPalette, GetType("sPLT"));

tests/ImageSharp.Tests/Metadata/Profiles/CICP/CicpProfileTests.cs

@@ -0,0 +1,82 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.Formats.Png;
+using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Cicp;
+
+public class CicpProfileTests
+{
+    [Theory]
+    [WithFile(TestImages.Png.AdamHeadsHlg, PixelTypes.Rgba64)]
+    public async Task ReadCicpMetadata_FromPng_Works<TPixel>(TestImageProvider<TPixel> provider)
+       where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = await provider.GetImageAsync(PngDecoder.Instance);
+
+        CicpProfile actual = image.Metadata.CicpProfile ?? image.Frames.RootFrame.Metadata.CicpProfile;
+        CicpProfileContainsExpectedValues(actual);
+    }
+
+    [Fact]
+    public void WritingPng_PreservesCicpProfile()
+    {
+        // arrange
+        using var image = new Image<Rgba32>(1, 1);
+        var original = CreateCicpProfile();
+        image.Metadata.CicpProfile = original;
+        var encoder = new PngEncoder();
+
+        // act
+        using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
+
+        // assert
+        CicpProfile actual = reloadedImage.Metadata.CicpProfile ?? reloadedImage.Frames.RootFrame.Metadata.CicpProfile;
+        CicpProfileIsValidAndEqual(actual, original);
+    }
+
+    private static void CicpProfileContainsExpectedValues(CicpProfile cicp)
+    {
+        Assert.NotNull(cicp);
+        Assert.Equal(CicpColorPrimaries.ItuRBt2020_2, cicp.ColorPrimaries);
+        Assert.Equal(CicpTransferCharacteristics.AribStdB67, cicp.TransferCharacteristics);
+        Assert.Equal(CicpMatrixCoefficients.Identity, cicp.MatrixCoefficients);
+        Assert.True(cicp.FullRange);
+    }
+
+    private static CicpProfile CreateCicpProfile()
+    {
+        var profile = new CicpProfile()
+        {
+            ColorPrimaries = CicpColorPrimaries.ItuRBt2020_2,
+            TransferCharacteristics = CicpTransferCharacteristics.SmpteSt2084,
+            MatrixCoefficients = CicpMatrixCoefficients.Identity,
+            FullRange = true,
+        };
+        return profile;
+    }
+
+    private static void CicpProfileIsValidAndEqual(CicpProfile actual, CicpProfile original)
+    {
+        Assert.NotNull(actual);
+        Assert.Equal(actual.ColorPrimaries, original.ColorPrimaries);
+        Assert.Equal(actual.TransferCharacteristics, original.TransferCharacteristics);
+        Assert.Equal(actual.MatrixCoefficients, original.MatrixCoefficients);
+        Assert.Equal(actual.FullRange, original.FullRange);
+    }
+
+    private static Image<Rgba32> WriteAndRead(Image<Rgba32> image, IImageEncoder encoder)
+    {
+        using (var memStream = new MemoryStream())
+        {
+            image.Save(memStream, encoder);
+            image.Dispose();
+
+            memStream.Position = 0;
+            return Image.Load<Rgba32>(memStream);
+        }
+    }
+}

tests/ImageSharp.Tests/TestImages.cs

@@ -61,6 +61,7 @@ public static class TestImages
         public const string TestPattern31x31 = "Png/testpattern31x31.png";
         public const string TestPattern31x31HalfTransparent = "Png/testpattern31x31-halftransparent.png";
         public const string XmpColorPalette = "Png/xmp-colorpalette.png";
+        public const string AdamHeadsHlg = "Png/adamHeadsHLG.png";
 
         // Animated
         // https://philip.html5.org/tests/apng/tests.html

tests/Images/Input/Png/adamHeadsHLG.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c50691da3b3af21ff4f8fc30f1313bc412b84fb0a07a5bf3b8b14eae7581ade
+size 201440