Owner review 2, phase 4b, fix round 3 (codecs). Chronos's decoders never read an ICC profile: they take code values through the sRGB curve and float samples as they are. Round 2 wrote a float TIFF's values with its profile's own curves, so after a Replace the renders, thumbnails, analyses and deflicker of an Adobe RGB, ProPhoto or gamma-1.0 float TIFF saw other pixels (up to 2.7 EV darker, shadows lifted). Every converted file now holds the values the decoders read from the original, as they read them back, and says truthfully what they are: - A JPEG or TIFF-16 keeps the codes of code values and carries the original's profile. Float values are written as sRGB codes with a profile made for them: the original's colorants and media white with the sRGB curve. A gray profile's codes are kept, its curve carried as an RGB profile (they were converted to sRGB before, which changed them too). - A Linear DNG, whose matrices Chronos develops it with as well, takes only values that are sRGB's as the decoders read them; any other profile is refused as color_profile instead of converted to colours Chronos would then show differently. - A profile with colorant tags that convert nothing is never sRGB by its name. - A float file with NaN or infinite samples fails as damaged data instead of being written black (and spending a DNG's headroom). The plan and the decoders behind it: - TooLarge and WorstBytes answer any size, int.MaxValue sides included, without a product that wraps around; the worst case saturates. - A frame another host flagged unreadable (the server, for a CMYK or CIELab TIFF its reader refuses) is asked again with a small decode where the conversion has other decoders (WIC on a PC), so a PC still converts it. The too_large sentences say "or Chronos reads back" (en, it). - WIC's TIFF decoder decodes an unknown compression as zeros, does not undo the floating-point predictor of Photoshop's 32-bit files and reads 32-bit integers as floats, all without an error: such TIFFs are left to the managed reader, on the desktop as in conversions, never black or noise. - A conversion's WIC probe reads the headers (decoder, first frame's oriented size, pixel format), so the size bound applies to what only WIC reads; a read error stays a read error (inaccessible), never a verdict. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
170 lines
8.9 KiB
C#
170 lines
8.9 KiB
C#
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Codecs.Icc;
|
|
using Chronos.Core.Codecs.Jpeg;
|
|
using Chronos.Core.Codecs.Tiff;
|
|
using Chronos.Core.Conversion;
|
|
using Chronos.Core.Imaging;
|
|
using Chronos.Core.Imaging.Decoders;
|
|
using Chronos.Core.Windows.Wic;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Core.Windows.Tests.Wic;
|
|
|
|
/// <summary>
|
|
/// Conversions on the desktop (owner review 2, R7), read back through the desktop's own decoders, WIC first: what Chronos
|
|
/// shows of a photo there never changes with its conversion, whatever the photo's colour space and samples.
|
|
/// </summary>
|
|
[WindowsOnly]
|
|
public sealed class DesktopConversionTests(TestContext context)
|
|
{
|
|
private static readonly Lazy<ImageDecoder> Desktop = new(() => DecoderFactory.CreateClient(new WicDecoderProvider()));
|
|
|
|
/// <summary>
|
|
/// The desktop decodes the converted file (WIC for a JPEG or TIFF, the managed reader for a DNG) to the values it decodes
|
|
/// the original to, within what the target holds, for sRGB, Adobe RGB, ProPhoto and linear-curve sources of 8-bit,
|
|
/// 16-bit and float samples; the file carries a profile that says what its codes are. A DNG takes only values that are
|
|
/// sRGB's as the decoders read them, and refuses the others.
|
|
/// </summary>
|
|
[Test]
|
|
public void TheDesktopReadsTheConvertedFileAsItReadsTheOriginal()
|
|
{
|
|
var folder = context.CreateTempDirectory();
|
|
using var scene = WicDecoderProviderTests.Scene(48, 32);
|
|
using var grays = new ImageBuffer(48, 32, 1);
|
|
for (var i = 0; i < grays.PlaneLength; i++) grays.Plane(0)[i] = 0.002f + 0.95f * i / grays.PlaneLength;
|
|
var srgb = IccProfile.Synthesize("sRGB IEC61966-2.1", new(0.64, 0.33), new(0.30, 0.60), new(0.15, 0.06), IccCurve.Srgb);
|
|
var g10 = IccProfile.Synthesize("sRGB-elle-V4-g10", new(0.64, 0.33), new(0.30, 0.60), new(0.15, 0.06), IccCurve.Gamma(1));
|
|
var prophoto = IccProfile.Synthesize("ProPhoto RGB", new(0.7347, 0.2653), new(0.1596, 0.8404), new(0.0366, 0.0001), IccCurve.Gamma(1.8));
|
|
(string Name, byte[] File, bool DngKeeps)[] sources =
|
|
[
|
|
("untagged.jpg", Jpeg(scene, null), true),
|
|
("srgb.jpg", Jpeg(scene, srgb), true),
|
|
("gray22.jpg", JpegCarrying(grays, Gray(IccCurve.Gamma(2.2))), false),
|
|
("sgray.jpg", JpegCarrying(grays, Gray(IccCurve.Srgb)), true),
|
|
("adobe.jpg", Jpeg(scene, IccProfile.AdobeRgb), false),
|
|
("g10.jpg", Jpeg(scene, g10), false),
|
|
("prophoto16.tif", TiffWriter.Write(scene, new TiffWriteOptions { BitsPerSample = 16, IccProfile = prophoto.Data }), false),
|
|
("adobe16.tif", TiffWriter.Write(scene, new TiffWriteOptions { BitsPerSample = 16, IccProfile = IccProfile.AdobeRgb.Data }), false),
|
|
("float.tif", TestTiffs.FloatRgb(scene), true),
|
|
("float-adobe.tif", TestTiffs.FloatRgb(scene, IccProfile.AdobeRgb.Data), false),
|
|
("float-prophoto.tif", TestTiffs.FloatRgb(scene, prophoto.Data), false),
|
|
("float-g10.tif", TestTiffs.FloatRgb(scene, g10.Data), true),
|
|
("float-adobe-predicted.tif", TestTiffs.FloatRgb(scene, IccProfile.AdobeRgb.Data, predicted: true), false),
|
|
];
|
|
var desktop = Desktop.Value;
|
|
foreach (var (name, bytes, dngKeeps) in sources)
|
|
{
|
|
var path = Path.Combine(folder, name);
|
|
File.WriteAllBytes(path, bytes);
|
|
var format = name.EndsWith(".jpg", StringComparison.Ordinal) ? ImageFileFormat.Jpeg : ImageFileFormat.Tiff;
|
|
var color = SourceColor.Read(path, format);
|
|
var source = new ConvertSource(path, Frame(name, format, scene.Width, scene.Height));
|
|
using var original = Assert.NotNull(desktop.Decode(new DecodeRequest(path, AllowPreview: false)));
|
|
foreach (var target in (ConvertTarget[])[ConvertTarget.Jpeg, ConvertTarget.Tiff16])
|
|
{
|
|
var options = new ConvertOptions(target, 100);
|
|
var file = FrameConverter.Convert(source, options, desktop, Target(options), cancellationToken: context.Cancellation);
|
|
using var converted = Assert.NotNull(desktop.Decode(new DecodeRequest(file.Path, AllowPreview: false)));
|
|
Assert.Equal("wic", converted.Decoder, name);
|
|
var (max, mean) = CodeDifference(original.Pixels, converted.Pixels);
|
|
var what = $"{name} ({original.Decoder}) → {target}";
|
|
context.Log($"{what}: max {max * 255:0.00}/255, mean {mean * 255:0.000}/255");
|
|
Assert.LessOrEqual(max, target == ConvertTarget.Jpeg ? 4 / 255.0 : 2 / 65535.0, what);
|
|
Assert.Less(mean, target == ConvertTarget.Jpeg ? 1 / 255.0 : 1 / 65535.0, what);
|
|
// What the file says its codes are: the original's profile with the original's codes, else its colorants with the sRGB curve.
|
|
var carried = SourceColor.Read(file.Path, file.Format).Profile;
|
|
if (color.Profile is not { } profile)
|
|
{
|
|
Assert.Null(carried, what);
|
|
}
|
|
else if (profile.IsGray)
|
|
{
|
|
// A gray profile's codes, kept, with its curve on three channels.
|
|
Assert.True(Assert.NotNull(carried, what).IsMatrixShaper, what);
|
|
for (var code = 0.0; code <= 1; code += 0.125) Assert.Approximately(profile.Curves![0].Evaluate(code), carried.Curves![1].Evaluate(code), 1e-3, what);
|
|
}
|
|
else if (!color.IsLinear)
|
|
{
|
|
Assert.BytesEqual(profile.Data, Assert.NotNull(carried, what).Data);
|
|
}
|
|
else
|
|
{
|
|
Assert.Equal(profile.Colorants, Assert.NotNull(carried, what).Colorants);
|
|
Assert.True(carried.Curves!.All(c => c.IsSrgb), what);
|
|
}
|
|
}
|
|
|
|
var dng = new ConvertOptions(ConvertTarget.LinearDng);
|
|
var output = Target(dng);
|
|
if (!dngKeeps)
|
|
{
|
|
Assert.Equal(ConversionFailure.ColorProfile,
|
|
Assert.Throws<ConversionException>(() => FrameConverter.Convert(source, dng, desktop, output, cancellationToken: context.Cancellation)).Reason, name);
|
|
Assert.FileMissing(output);
|
|
continue;
|
|
}
|
|
FrameConverter.Convert(source, dng, desktop, output, cancellationToken: context.Cancellation);
|
|
using var developed = Assert.NotNull(desktop.Decode(new DecodeRequest(output, AllowPreview: false)));
|
|
for (var c = 0; c < 3; c++)
|
|
{
|
|
for (var i = 0; i < scene.PlaneLength; i++) Assert.Approximately(original.Pixels.Plane(c)[i], developed.Pixels.Plane(c)[i], 3e-4, $"{name} → DNG");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static byte[] Jpeg(ImageBuffer scene, IccProfile? profile) => JpegCarrying(scene, profile?.Data);
|
|
|
|
private static byte[] JpegCarrying(ImageBuffer scene, byte[]? icc) => JpegEncoder.Encode(scene, new JpegEncodeOptions
|
|
{
|
|
Quality = 98,
|
|
Subsampling = JpegSubsampling.Yuv444,
|
|
IccProfile = icc,
|
|
});
|
|
|
|
/// <summary>A gray profile (GRAY, a kTRC of <paramref name="curve"/>): a synthesized RGB one, its red curve renamed.</summary>
|
|
private static byte[] Gray(IccCurve curve)
|
|
{
|
|
var data = (byte[])IccProfile.Synthesize("Gray", new(0.64, 0.33), new(0.30, 0.60), new(0.15, 0.06), curve).Data.Clone();
|
|
"GRAY"u8.CopyTo(data.AsSpan(16));
|
|
var count = System.Buffers.Binary.BinaryPrimitives.ReadInt32BigEndian(data.AsSpan(128));
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
var entry = data.AsSpan(132 + 12 * i, 4);
|
|
if (entry.SequenceEqual("rTRC"u8)) "kTRC"u8.CopyTo(entry);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private static SidecarFrame Frame(string file, ImageFileFormat format, int width, int height) => new()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
File = "originals/" + file,
|
|
Sha256 = new string('a', 64),
|
|
CapturedAt = new DateTime(2026, 9, 28, 18, 0, 5),
|
|
W = width,
|
|
H = height,
|
|
Format = format,
|
|
};
|
|
|
|
private string Target(ConvertOptions options) => Path.Combine(context.CreateTempDirectory(), "converted" + options.Extension);
|
|
|
|
/// <summary>The largest and the mean difference between two decodes, in sRGB code values (what the files hold).</summary>
|
|
private static (double Max, double Mean) CodeDifference(ImageBuffer a, ImageBuffer b)
|
|
{
|
|
Assert.Equal((a.Width, a.Height), (b.Width, b.Height));
|
|
double max = 0, sum = 0;
|
|
for (var c = 0; c < 3; c++)
|
|
{
|
|
var pa = a.Plane(c);
|
|
var pb = b.Plane(c);
|
|
for (var i = 0; i < pa.Length; i++)
|
|
{
|
|
var d = Math.Abs(ColorSpace.LinearToSrgb(pa[i]) - ColorSpace.LinearToSrgb(pb[i]));
|
|
max = Math.Max(max, d);
|
|
sum += d;
|
|
}
|
|
}
|
|
return (max, sum / (3.0 * a.PlaneLength));
|
|
}
|
|
}
|