Round-2 fixes for the codecs part of owner review 2, phase 4b (mass conversion), so the dry run never promises a conversion that then fails or writes wrong pixels. - The managed TIFF reader refuses samples it does not render (CMYK, CIELab, palette, LogL, RGB of fewer than three samples, float min-is-white) before reading pixels, instead of decoding them as the gray of their first plane. The conversion chain then asks WIC on a PC; the server leaves them to a PC. Impossible strip/tile counts are refused as data, not as an OverflowException that escaped the chain. - A conversion's managed provider reads JPEG, PNG and TIFF headers in its probe (ReadsHeaders): what its decoders refuse there (compression, sample format, photometric, MaxSamples, MaxPixels, arithmetic coding) is not planned as convertible on the server, and is asked of WIC on a PC. The probe gives the real size, so TooLarge sees it. - Float TIFFs are linear light (SourceColor.IsLinear): a JPEG or TIFF carrying their profile gets codes from the profile's own curves, a DNG gets them through the matrix only (no curve, no clip, highlights kept). IsSrgb is decided by the numbers for matrix/TRC profiles, so a linear profile named sRGB is converted, not taken as sRGB. The TIFF profile is read from the image the decoders read. - TooLarge is a bound: the target's limits and what the server's decoders read back, which every converted file must (JPEG 2^28 pixels, TIFF-16 and DNG 2^29 samples), and the incompressible worst case against the 2 GB array. A MemoryStream overflow is TooLarge, never a generic file failure. - Colorants that convert nothing (a white without positive cone responses, a non-finite or singular matrix) are dropped when a profile is parsed: the photo is carried into a JPEG or TIFF and planned out of a DNG as colour_profile, instead of throwing in BradfordAdaptation at every retry. Tests: header probes, refused photometrics, the size bound against the verifier's header reads, float TIFF colour, a fuzz of damaged profiles, and a Windows test converting a CMYK TIFF through WIC. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 18cf9133087aada2db06c8310d2c69ff804c0115)
241 lines
14 KiB
C#
241 lines
14 KiB
C#
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;
|
||
|
||
/// <summary>ICC profiles (owner review 2, R7): parsed, synthesized for the spaces a marker names, and read from each container.</summary>
|
||
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;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[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<InvalidOperationException>(() => degenerate.ToLinearRec709());
|
||
// The same colorants inside a white with positive cone responses convert.
|
||
Assert.NotNull(IccProfile.AdobeRgb.Colorants);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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, and whose conversion of a JPEG's code values or a float TIFF's linear values, wherever the treatment
|
||
/// asks for one, runs to finite values; anything else the treatment refuses before any pixel is decoded.
|
||
/// </summary>
|
||
[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, worked = 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<ConvertTarget>())
|
||
{
|
||
using var image = pixels.Clone();
|
||
var treatment = FrameConverter.Treatment(color, target);
|
||
if (treatment == ColorTreatment.Convert) FrameConverter.ToLinearRec709(image, color.Profile!, color.IsLinear, 1, CancellationToken.None);
|
||
else if (treatment == ColorTreatment.Encode) FrameConverter.EncodeWithCurves(image, color.Profile!, 1, CancellationToken.None);
|
||
else continue;
|
||
worked++;
|
||
// Code values convert within the matrix's reach; linear ones as large as the file holds may overflow.
|
||
if (treatment == ColorTreatment.Encode || !color.IsLinear)
|
||
{
|
||
foreach (var v in image.Data) Assert.True(float.IsFinite(v), $"{treatment} of {target} gives finite values");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
context.Log($"{parsed} damaged profiles parsed, {worked} conversions run");
|
||
Assert.Greater(parsed, 1000);
|
||
Assert.Greater(worked, 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];
|
||
}
|
||
}
|
||
|
||
/// <summary>A matrix/TRC profile is sRGB when its numbers are sRGB's, whatever its name says; one without them by its name.</summary>
|
||
[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);
|
||
}
|
||
|
||
/// <summary>Curves invert: exactly for a power law and a table, within a 16-bit step for a parametric function.</summary>
|
||
[Test]
|
||
public void CurvesInvert()
|
||
{
|
||
var gamma = IccCurve.Gamma(2.2);
|
||
var table = ColorFixtures.Profile("Gamma 1.8", IccCurve.Gamma(1.8)).Curves![0];
|
||
var srgb = IccCurve.Srgb;
|
||
foreach (var curve in (IccCurve[])[gamma, table, srgb]) Assert.True(curve.IsInvertible);
|
||
for (var code = 0.0; code <= 1; code += 1 / 128.0)
|
||
{
|
||
Assert.Approximately(code, gamma.Invert(gamma.Evaluate(code)), 1e-9);
|
||
Assert.Approximately(code, table.Invert(table.Evaluate(code)), 1e-6);
|
||
Assert.Approximately(code, srgb.Invert(ColorSpace.SrgbToLinear(code)), 1 / 65536.0);
|
||
}
|
||
// Linear values beyond the curve's range take its ends.
|
||
Assert.Equal((0.0, 1.0), (gamma.Invert(-0.5), gamma.Invert(3)));
|
||
Assert.Equal((0.0, 1.0), (table.Invert(-0.5), table.Invert(3)));
|
||
// A curve that falls somewhere maps two codes to one value: no encoding undoes it.
|
||
Assert.False(IccCurve.Parse([.. "curv"u8, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0xFF, 0xFF, 0x80, 0])!.IsInvertible);
|
||
Assert.False(IccCurve.Parse([.. "curv"u8, 0, 0, 0, 0, 0, 0, 0, 2, 0x80, 0, 0x80, 0])!.IsInvertible);
|
||
}
|
||
|
||
/// <summary>A TIFF of floating-point samples or linear RAW holds linear values; integer samples are code values.</summary>
|
||
[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));
|
||
}
|
||
}
|