using Chronos.Core.Codecs.Icc; using Chronos.Core.Codecs.Tiff; using Chronos.Core.Conversion; using Chronos.Core.Imaging; using Chronos.Core.Mathematics; using Chronos.Core.Tests.Conversion; using Chronos.Testing; namespace Chronos.Core.Tests.Codecs; /// ICC profiles (owner review 2, R7): parsed, synthesized for the spaces a marker names, and read from each container. public sealed class IccProfileTests(TestContext context) { [Test] public void TheSynthesizedProfilesAreMatrixShapersOfTheirSpace() { var adobe = IccProfile.AdobeRgb; Assert.True(adobe.IsMatrixShaper && adobe.IsRgb && !adobe.IsSrgb); Assert.Equal("Compatible with Adobe RGB (1998)", adobe.Description); // Colorants add up to the D50 PCS white. var white = adobe.Colorants!.Value * new Vector3D(1, 1, 1); Assert.Approximately(0.9642, white.X, 2e-4); Assert.Approximately(1.0, white.Y, 2e-4); Assert.Approximately(0.8249, white.Z, 2e-4); // Adobe RGB → linear sRGB: red reaches 1.398 with green −0.398, blue stays put but borrows from green. var m = adobe.ToLinearRec709(); Assert.Approximately(1.3982, m.M11, 2e-3); Assert.Approximately(-0.3982, m.M12, 2e-3); Assert.Approximately(1.0, m.M22, 2e-3); Assert.Approximately(-0.0429, m.M32, 2e-3); Assert.Approximately(1.0429, m.M33, 2e-3); var neutral = m * new Vector3D(1, 1, 1); Assert.Approximately(1, neutral.X, 1e-9); Assert.Approximately(1, neutral.Y, 1e-9); Assert.Approximately(1, neutral.Z, 1e-9); // Its gamma 563/256, written as a u8Fixed8 curve. Assert.Approximately(Math.Pow(0.5, 563 / 256.0), adobe.Curves![0].Evaluate(0.5), 1e-12); var p3 = IccProfile.DisplayP3; Assert.True(p3.IsMatrixShaper); // The sRGB curve, tabulated in 1024 entries. for (var v = 0.0; v <= 1; v += 0.05) Assert.Approximately(ColorSpace.SrgbToLinear(v), p3.Curves![1].Evaluate(v), 2e-5); // P3's own green is outside sRGB: negative red and blue in Rec.709. var green = p3.ToLinearRec709() * new Vector3D(0, 1, 0); Assert.Approximately(-0.2246, green.X, 3e-3); Assert.Approximately(1.0421, green.Y, 3e-3); Assert.Approximately(-0.0786, green.Z, 3e-3); Assert.Null(IccProfile.Parse(new byte[200])); Assert.Null(IccProfile.Parse(adobe.Data[..131])); } [Test] public void ParametricCurvesFollowTheirFunctions() { // para function 3 with the sRGB parameters (as Apple's Display P3 profile writes it). byte[] tag = [.. "para"u8, 0, 0, 0, 0, 0, 3, 0, 0, .. Fixed(2.4), .. Fixed(1 / 1.055), .. Fixed(0.055 / 1.055), .. Fixed(1 / 12.92), .. Fixed(0.04045)]; var curve = IccCurve.Parse(tag)!; foreach (var v in new[] { 0.0, 0.02, 0.04045, 0.3, 0.75, 1.0 }) Assert.Approximately(ColorSpace.SrgbToLinear(v), curve.Evaluate(v), 2e-5); Assert.Approximately(Math.Pow(0.5, 1.8), IccCurve.Parse([.. "para"u8, 0, 0, 0, 0, 0, 0, 0, 0, .. Fixed(1.8)])!.Evaluate(0.5), 1e-4); Assert.Approximately(0.25, IccCurve.Parse([.. "curv"u8, 0, 0, 0, 0, 0, 0, 0, 0])!.Evaluate(0.25), 1e-12); Assert.Approximately(0.5, IccCurve.Parse([.. "curv"u8, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0x80, 0, 0xFF, 0xFF])!.Evaluate(0.5), 1e-4); Assert.Null(IccCurve.Parse([.. "para"u8, 0, 0, 0, 0, 0, 9, 0, 0])); static byte[] Fixed(double v) { var b = new byte[4]; System.Buffers.Binary.BinaryPrimitives.WriteInt32BigEndian(b, (int)Math.Round(v * 65536)); return b; } } /// /// Colorants that convert nothing (their white has a cone response that is not positive, as a damaged profile's may) are /// dropped when the profile is parsed: it stays an RGB profile to carry, never one to convert through, and asking its /// matrix fails as for any profile without one, not inside the chromatic adaptation. /// [Test] public void ColorantsThatConvertNothingAreDroppedWhenParsed() { var degenerate = IccProfile.Parse(ColorFixtures.Degenerate())!; Assert.True(degenerate.IsRgb); Assert.Null(degenerate.Colorants); Assert.False(degenerate.IsMatrixShaper); Assert.False(degenerate.IsSrgb); Assert.Throws(() => degenerate.ToLinearRec709()); // The same colorants inside a white with positive cone responses convert. Assert.NotNull(IccProfile.AdobeRgb.Colorants); } /// /// A damaged profile never fails a conversion's colour work midway (owner review 2, R7): bytes flipped in matrix/TRC /// profiles, as in a damaged file, give a profile that does not parse, one only to carry, or one whose matrix is finite /// and invertible; wherever the treatment asks for a profile made for the codes written (a float TIFF's linear values /// into a JPEG or TIFF), that profile is made and parses, its matrix finite and invertible; a DNG takes the values as /// they are or refuses them. Anything else the treatment refuses before any pixel is decoded. /// [Test] public void DamagedProfilesConvertOrAreRefusedNeverFailMidway() { var random = new Random(27); using var pixels = new ImageBuffer(4, 2); float[] values = [0, 0.18f, 0.5f, 1, 3, -0.2f, 0.02f, 0.9f]; var data = pixels.Data; for (var i = 0; i < data.Length; i++) data[i] = values[i % values.Length]; int parsed = 0, described = 0; foreach (var original in (byte[][])[IccProfile.AdobeRgb.Data, IccProfile.DisplayP3.Data, ColorFixtures.Profile("Wide gamma 1.8", IccCurve.Gamma(1.8), wide: true).Data]) { for (var n = 0; n < 1000; n++) { var damaged = (byte[])original.Clone(); // The tag table and the tags: colorants, curves, description. for (var k = random.Next(1, 4); k > 0; k--) damaged[random.Next(128, damaged.Length)] ^= (byte)random.Next(1, 256); if (IccProfile.Parse(damaged) is not { } profile) continue; parsed++; if (profile.IsMatrixShaper) { var m = profile.ToLinearRec709(); Assert.True(Finite(m) && m.TryInvert(out var inverse) && Finite(inverse), "a matrix to convert through is finite and invertible"); } SourceColor[] carriers = [ SourceColor.Read(new MemoryStream(JpegCarrying(damaged)), ImageFileFormat.Jpeg), SourceColor.Read(new MemoryStream(ColorFixtures.FloatTiff(pixels, damaged)), ImageFileFormat.Tiff), ]; foreach (var color in carriers) { foreach (var target in Enum.GetValues()) { var treatment = FrameConverter.Treatment(color, target); if (target == ConvertTarget.LinearDng) Assert.True(treatment is ColorTreatment.None or ColorTreatment.Refuse, $"a DNG of {treatment}"); if (treatment != ColorTreatment.Describe) continue; var made = IccProfile.Parse(FrameConverter.Described(color.Profile!).Data); Assert.True(made is { IsMatrixShaper: true }, "the profile made for the codes parses as a matrix/TRC one"); var m = made!.ToLinearRec709(); Assert.True(Finite(m) && m.TryInvert(out var inverse) && Finite(inverse), "and converts with finite numbers"); described++; } } } } context.Log($"{parsed} damaged profiles parsed, {described} described"); Assert.Greater(parsed, 1000); Assert.Greater(described, 1000); static bool Finite(Matrix3 m) => new[] { m.M11, m.M12, m.M13, m.M21, m.M22, m.M23, m.M31, m.M32, m.M33 }.All(double.IsFinite); // The markers of a JPEG carrying the profile in one APP2 chunk, no image: all its colour is read from. static byte[] JpegCarrying(byte[] icc) { var length = 2 + 14 + icc.Length; return [0xFF, 0xD8, 0xFF, 0xE2, (byte)(length >> 8), (byte)length, .. "ICC_PROFILE\0"u8, 1, 1, .. icc, 0xFF, 0xD9]; } } /// /// A matrix/TRC profile is sRGB when its numbers are sRGB's, whatever its name says; one without colorant tags at all (a /// lookup-table profile) by its name. One whose colorants convert nothing, or whose curves are missing, is not, whatever /// its name (owner review 2, R7). /// [Test] public void SrgbIsWhatTheNumbersSay() { Assert.True(ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Srgb).IsSrgb); Assert.True(ColorFixtures.Profile("Camera RGB", IccCurve.Srgb).IsSrgb); // sRGB's primaries with a linear curve, or a gamma 2.2 one, named sRGB. Assert.False(ColorFixtures.Profile("sRGB-elle-V4-g10", IccCurve.Gamma(1)).IsSrgb); Assert.False(ColorFixtures.Profile("sRGB gamma 2.2", IccCurve.Gamma(2.2)).IsSrgb); Assert.False(ColorFixtures.Profile("sRGB wide", IccCurve.Srgb, wide: true).IsSrgb); Assert.False(IccProfile.DisplayP3.IsSrgb); // Without colorant tags, the name decides; with colorants that convert nothing, or no curves, nothing says sRGB. Assert.True(IccProfile.Parse(ColorFixtures.WithoutColorants(ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Gamma(1)).Data))!.IsSrgb); Assert.False(IccProfile.Parse(ColorFixtures.WithoutColorants(IccProfile.AdobeRgb.Data))!.IsSrgb); var degenerate = IccProfile.Parse(ColorFixtures.Degenerate(ColorFixtures.Profile("sRGB-elle-V4-g10", IccCurve.Srgb).Data))!; Assert.True(degenerate is { IsRgb: true, Colorants: null, IsSrgb: false }); var curveless = ColorFixtures.Renamed(ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Srgb).Data, "rTRC", "xTRC"); Assert.True(IccProfile.Parse(curveless) is { IsMatrixShaper: false, IsSrgb: false }); // The curves themselves. Assert.True(IccCurve.Srgb.IsSrgb && IccProfile.DisplayP3.Curves![0].IsSrgb); Assert.False(IccCurve.Gamma(2.2).IsSrgb || IccCurve.Gamma(1).IsSrgb); } /// /// Values are sRGB's as Chronos's decoders take them (owner review 2, R7) when they are in sRGB's primaries and, for code /// values, through sRGB's curve: a linear-curve profile in sRGB's primaries holds sRGB's linear values but not its code /// values; a gray profile's linear values are linear gray, its code values need the sRGB curve. /// [Test] public void ValuesAreSrgbsWhereThePrimariesAndTheCurveSaySo() { (IccProfile Profile, bool Linear, bool Codes)[] cases = [ (ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Srgb), true, true), (ColorFixtures.Profile("sRGB-elle-V4-g10", IccCurve.Gamma(1)), true, false), (ColorFixtures.Profile("sRGB gamma 2.2", IccCurve.Gamma(2.2)), true, false), (IccProfile.AdobeRgb, false, false), (IccProfile.DisplayP3, false, false), (ColorFixtures.ProPhoto(), false, false), (IccProfile.Parse(ColorFixtures.Gray("Gray Gamma 2.2", IccCurve.Gamma(2.2)))!, true, false), (IccProfile.Parse(ColorFixtures.Gray("sGray", IccCurve.Srgb))!, true, true), (IccProfile.Parse(ColorFixtures.Cmyk())!, false, false), (IccProfile.Parse(ColorFixtures.Degenerate())!, false, false), ]; foreach (var (profile, linear, codes) in cases) Assert.Equal((linear, codes), (profile.IsSrgbFor(linear: true), profile.IsSrgbFor(linear: false)), $"{profile.Description} ({profile.ColorSpace:X8})"); } /// /// The profiles a converted file carries for codes that are not the original's (owner review 2, R7): a matrix/TRC /// profile's colorants and media white with the sRGB curve, to the bit; a gray profile's curve on three channels whose /// equal values are neutral. /// [Test] public void ProfilesMadeForTheCodesKeepWhatTheyDescribe() { foreach (var source in (IccProfile[])[IccProfile.AdobeRgb, ColorFixtures.ProPhoto(), ColorFixtures.Profile("Wide gamma 1.0", IccCurve.Gamma(1), wide: true)]) { var made = IccProfile.Parse(source.WithSrgbCurve().Data)!; Assert.True(made.IsMatrixShaper && made.IsRgb, source.Description); Assert.Equal(source.Colorants, made.Colorants); Assert.Equal(source.MediaWhite, made.MediaWhite); Assert.True(made.Curves!.All(c => c.IsSrgb), source.Description); Assert.Equal($"{source.Description} (sRGB curve)", made.Description); } var gray = IccProfile.Parse(ColorFixtures.Gray("Gray Gamma 2.2", IccCurve.Gamma(2.2)))!; var rgb = IccProfile.Parse(gray.GrayAsRgb().Data)!; Assert.True(rgb is { IsMatrixShaper: true, IsRgb: true }); Assert.Equal("Gray Gamma 2.2 (RGB)", rgb.Description); for (var code = 0.0; code <= 1; code += 0.125) { var light = rgb.ToLinearRec709() * new Vector3D(rgb.Curves![0].Evaluate(code), rgb.Curves[1].Evaluate(code), rgb.Curves[2].Evaluate(code)); var expected = gray.Curves![0].Evaluate(code); Assert.Approximately(expected, light.X, 1e-3); Assert.Approximately(expected, light.Y, 1e-3); Assert.Approximately(expected, light.Z, 1e-3); } Assert.Throws(() => gray.WithSrgbCurve()); Assert.Throws(() => IccProfile.AdobeRgb.GrayAsRgb()); // A damaged profile's endless description is cut. var long1 = IccProfile.Synthesize(new string('x', 5000), new(0.64, 0.33), new(0.30, 0.60), new(0.15, 0.06), IccCurve.Srgb); Assert.Less(long1.Description!.Length, 300); } /// A TIFF of floating-point samples or linear RAW holds linear values; integer samples are code values. [Test] public void ATiffSaysWhetherItsSamplesAreLinear() { using var scene = ColorFixtures.Scene(); SourceColor Read(byte[] file) => SourceColor.Read(new MemoryStream(file), ImageFileFormat.Tiff); var adobe = IccProfile.AdobeRgb.Data; var linear = Read(ColorFixtures.FloatTiff(scene, adobe)); Assert.True(linear.IsLinear); Assert.BytesEqual(adobe, linear.Profile!.Data); Assert.True(Read(ColorFixtures.FloatTiff(scene)) is { IsLinear: true, Profile: null, IsUnknown: false }); Assert.True(Read(Chronos.Core.Codecs.Dng.LinearDngWriter.Write(scene)).IsLinear); Assert.False(Read(TiffWriter.Write(scene, new TiffWriteOptions { BitsPerSample = 16, IccProfile = adobe })).IsLinear); Assert.False(Read(TiffWriter.Write(scene)).IsLinear); } [Test] public void EachContainerSaysItsColourSpace() { using var scene = ColorFixtures.Scene(); var p3 = IccProfile.DisplayP3.Data; SourceColor Read(byte[] file, ImageFileFormat format) => SourceColor.Read(new MemoryStream(file), format); // Untagged and sRGB files are sRGB. Assert.Same(SourceColor.Untagged, Read(ColorFixtures.Jpeg(scene), ImageFileFormat.Jpeg)); Assert.Same(SourceColor.Untagged, Read(ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(1, "R98")), ImageFileFormat.Jpeg)); // An embedded profile, byte for byte: JPEG APP2 (one chunk, or several), PNG iCCP, TIFF tag 34675, HEIF prof. Assert.BytesEqual(p3, Read(ColorFixtures.Jpeg(scene, p3), ImageFileFormat.Jpeg).Profile!.Data); var large = ColorFixtures.Large(); Assert.BytesEqual(large, Read(ColorFixtures.Jpeg(scene, large), ImageFileFormat.Jpeg).Profile!.Data); Assert.BytesEqual(p3, Read(ColorFixtures.Png(scene, p3), ImageFileFormat.Png).Profile!.Data); Assert.BytesEqual(p3, Read(TiffWriter.Write(scene, new TiffWriteOptions { IccProfile = p3 }), ImageFileFormat.Tiff).Profile!.Data); Assert.BytesEqual(p3, Read(ColorFixtures.Heif(ColorFixtures.Nclx(1, 13), ColorFixtures.Prof(p3)), ImageFileFormat.Heif).Profile!.Data); // A grid whose tiles carry the profile, not the grid item. Assert.BytesEqual(p3, Read(ColorFixtures.Heif(2, ColorFixtures.Prof(p3)), ImageFileFormat.Heif).Profile!.Data); // A camera's Adobe RGB marker (uncalibrated, Interop R03) names Adobe RGB, in a JPEG and in a TIFF. Assert.Same(IccProfile.AdobeRgb, Read(ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(0xFFFF, "R03")), ImageFileFormat.Jpeg).Profile); // nclx: BT.709 is sRGB, P3 primaries Display P3, BT.2020 or PQ unknown. Assert.Same(SourceColor.Untagged, Read(ColorFixtures.Heif(ColorFixtures.Nclx(1, 13)), ImageFileFormat.Heif)); Assert.Same(IccProfile.DisplayP3, Read(ColorFixtures.Heif(ColorFixtures.Nclx(12, 13)), ImageFileFormat.Heif).Profile); Assert.True(Read(ColorFixtures.Heif(ColorFixtures.Nclx(9, 16)), ImageFileFormat.Heif).IsUnknown); // Uncalibrated without R03, or a profile that does not parse: a space nothing here describes. Assert.True(Read(ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(0xFFFF)), ImageFileFormat.Jpeg).IsUnknown); Assert.True(Read(ColorFixtures.Jpeg(scene, new byte[300]), ImageFileFormat.Jpeg).IsUnknown); // RAWs say nothing here: their decoders give Rec.709. Assert.Same(SourceColor.Untagged, Read([1, 2, 3], ImageFileFormat.Cr2)); } }