fix(convert): a conversion never changes what Chronos reads from a photo
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>
This commit is contained in:
1 parent
4dd3050334
commit
b471a33bfc
16 files changed
+1341
-330
No files matched your search
@@ -71,6 +71,154 @@ public sealed class WicDecoderProviderTests(TestContext context)
|
||||
Assert.Less(converted.Pixels[2, 3, 2], 0.1);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A TIFF WIC would decode as black or as noise without an error (owner review 2, R7) is left to the other decoders: a
|
||||
/// compression it does not know (ZSTD, an unknown code), whose data it decodes as zeros; Photoshop's floating-point
|
||||
/// predictor, which it does not undo; 32-bit integer samples, which it takes for floats. On the desktop the managed
|
||||
/// reader decodes the predicted float TIFF to its values, and the others are unavailable, never black; a conversion's
|
||||
/// plan leaves those out and converts the float one.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void ATiffWicWouldDecodeBlackOrAsNoiseIsLeftToTheOtherDecoders()
|
||||
{
|
||||
var folder = context.CreateTempDirectory();
|
||||
using var scene = Scene(12, 8);
|
||||
(string Name, byte[] File, string Why)[] refused =
|
||||
[
|
||||
("zstd.tif", TestTiffs.Rgb8(scene, compression: 50000), "compression 50000"),
|
||||
("unknown.tif", TestTiffs.Rgb8(scene, compression: 12345), "compression 12345"),
|
||||
("jpeg2000.tif", TestTiffs.Rgb8(scene, compression: 34712), "compression 34712"),
|
||||
("predicted.tif", TestTiffs.FloatRgb(scene, predicted: true), "predictor 3"),
|
||||
("int32.tif", TestTiffs.Uint32Rgb(scene), "32-bit integer"),
|
||||
];
|
||||
var reading = Provider.WithHeaderProbes();
|
||||
foreach (var (name, bytes, why) in refused)
|
||||
{
|
||||
var path = Path.Combine(folder, name);
|
||||
File.WriteAllBytes(path, bytes);
|
||||
Assert.Null(Provider.Decode(new DecodeRequest(path)));
|
||||
var probe = reading.Probe(path, ImageFileFormat.Tiff);
|
||||
Assert.Equal(DecodeTier.Unavailable, probe.Tier, name);
|
||||
Assert.Contains(why, probe.Reason);
|
||||
}
|
||||
// What WIC decodes of the same kind it still does: the float TIFF unpredicted, the codes uncompressed.
|
||||
File.WriteAllBytes(Path.Combine(folder, "float.tif"), TestTiffs.FloatRgb(scene));
|
||||
File.WriteAllBytes(Path.Combine(folder, "plain.tif"), TestTiffs.Rgb8(scene));
|
||||
foreach (var name in (string[])["float.tif", "plain.tif"])
|
||||
{
|
||||
using var decoded = Assert.NotNull(Provider.Decode(new DecodeRequest(Path.Combine(folder, name))));
|
||||
AssertClose(scene, decoded.Pixels, name == "float.tif" ? 1e-6 : 5e-3, name);
|
||||
}
|
||||
|
||||
var desktop = Chronos.Core.Imaging.Decoders.DecoderFactory.CreateClient(Provider);
|
||||
using (var floats = Assert.NotNull(desktop.Decode(new DecodeRequest(Path.Combine(folder, "predicted.tif")))))
|
||||
{
|
||||
Assert.Equal("managed-tiff", floats.Decoder);
|
||||
AssertClose(scene, floats.Pixels, 1e-6, "the predicted float TIFF");
|
||||
}
|
||||
foreach (var name in (string[])["zstd.tif", "unknown.tif", "jpeg2000.tif", "int32.tif"]) Assert.Null(desktop.Decode(new DecodeRequest(Path.Combine(folder, name))));
|
||||
|
||||
var frames = refused.Select((f, i) => new Chronos.Core.Archiving.SidecarFrame
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
I = i,
|
||||
File = f.Name,
|
||||
Sha256 = new string('a', 64),
|
||||
W = 12,
|
||||
H = 8,
|
||||
Format = ImageFileFormat.Tiff,
|
||||
}).ToArray();
|
||||
var archive = new Chronos.Core.Archiving.ArchivePaths(context.CreateTempDirectory()).Sequence("roof");
|
||||
Directory.CreateDirectory(archive.Folder);
|
||||
foreach (var (name, bytes, _) in refused) File.WriteAllBytes(archive.File(name), bytes);
|
||||
var manifest = new Chronos.Core.Archiving.SequenceManifest { Id = Guid.NewGuid(), Frames = frames };
|
||||
var plan = Chronos.Core.Conversion.ConvertPlanner.Plan(manifest, archive, [.. frames.Select(f => f.File)],
|
||||
new Chronos.Core.Conversion.ConvertOptions(Chronos.Core.Conversion.ConvertTarget.Jpeg), desktop, "Roof");
|
||||
Assert.SequenceEqual([3], plan.Frames.Select(f => f.Index));
|
||||
Assert.SequenceEqual([(Chronos.Core.Conversion.ConvertSkip.NoNativeDecoder, 4)], plan.Skipped.Select(s => (s.Reason, s.Frames)));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A conversion's WIC probe reads what WIC makes of the file's headers (owner review 2, R7): native at the first frame's
|
||||
/// oriented size, so the plan's size bound applies to what only WIC reads; unavailable, with why, for what it does not
|
||||
/// decode. Other probes trust the format and open nothing. A file another program holds, or one gone, is a read error,
|
||||
/// never a verdict on its content.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void HeaderProbesSayWhatWicDecodesAtItsSize()
|
||||
{
|
||||
var folder = context.CreateTempDirectory();
|
||||
var reading = Provider.WithHeaderProbes();
|
||||
Assert.True(((WicDecoderProvider)reading).ReadsHeaders);
|
||||
Assert.Same(reading, reading.WithHeaderProbes());
|
||||
Assert.False(Provider.ReadsHeaders);
|
||||
|
||||
var rotated = Path.Combine(folder, "rotated.jpg");
|
||||
WicTestImages.WriteGrayJpeg(rotated, 64, 32, (x, _) => (byte)x, exifOrientation: 6);
|
||||
var png = Path.Combine(folder, "frame.png");
|
||||
WicTestImages.WriteRgbPng(png, 40, 30, (_, _) => (128, 128, 128));
|
||||
var tiff = Path.Combine(folder, "frame.tif");
|
||||
using (var scene = Scene(12, 8)) File.WriteAllBytes(tiff, Chronos.Core.Codecs.Tiff.TiffWriter.Write(scene));
|
||||
foreach (var (path, format, width, height) in ((string, ImageFileFormat, int, int)[])
|
||||
[(rotated, ImageFileFormat.Jpeg, 32, 64), (png, ImageFileFormat.Png, 40, 30), (tiff, ImageFileFormat.Tiff, 12, 8)])
|
||||
{
|
||||
var probe = reading.Probe(path, format);
|
||||
Assert.Equal((DecodeTier.Native, "wic", width, height), (probe.Tier, probe.Decoder, probe.Width, probe.Height), Path.GetFileName(path));
|
||||
}
|
||||
// Without header reads: the format's tier, nothing opened.
|
||||
var trusted = Provider.Probe(Path.Combine(folder, "none.jpg"), ImageFileFormat.Jpeg);
|
||||
Assert.Equal((DecodeTier.Native, 0, 0), (trusted.Tier, trusted.Width, trusted.Height));
|
||||
|
||||
var noise = Path.Combine(folder, "noise.png");
|
||||
File.WriteAllBytes(noise, [.. Enumerable.Range(0, 4096).Select(i => (byte)(i * 37))]);
|
||||
Assert.Equal(DecodeTier.Unavailable, reading.Probe(noise, ImageFileFormat.Png).Tier);
|
||||
Assert.Throws<FileNotFoundException>(() => reading.Probe(Path.Combine(folder, "gone.png"), ImageFileFormat.Png));
|
||||
using (new FileStream(png, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
|
||||
Assert.Throws<IOException>(() => reading.Probe(png, ImageFileFormat.Png));
|
||||
|
||||
// A CMYK strip only WIC reads, 70000 pixels wide, whose sidecar records no size: too large for a JPEG, said by the plan
|
||||
// rather than by a conversion failing at every retry.
|
||||
var archive = new Chronos.Core.Archiving.ArchivePaths(context.CreateTempDirectory()).Sequence("roof");
|
||||
Directory.CreateDirectory(archive.Folder);
|
||||
File.WriteAllBytes(archive.File("wide.tif"), CmykTiff(70_000, 1, [0, 255, 255, 0]));
|
||||
var sized = reading.Probe(archive.File("wide.tif"), ImageFileFormat.Tiff);
|
||||
Assert.Equal((DecodeTier.Native, 70_000, 1), (sized.Tier, sized.Width, sized.Height));
|
||||
var frame = new Chronos.Core.Archiving.SidecarFrame { Id = Guid.NewGuid(), File = "wide.tif", Sha256 = new string('a', 64), Format = ImageFileFormat.Tiff };
|
||||
var desktop = Chronos.Core.Imaging.Decoders.DecoderFactory.CreateClient(Provider);
|
||||
Assert.Equal(Chronos.Core.Conversion.ConvertSkip.TooLarge, Chronos.Core.Conversion.ConvertPlanner.Skip(frame, archive, new HashSet<string>(["wide.tif"]),
|
||||
new Chronos.Core.Conversion.ConvertOptions(Chronos.Core.Conversion.ConvertTarget.Jpeg), desktop));
|
||||
Assert.Null(Chronos.Core.Conversion.ConvertPlanner.Skip(frame, archive, new HashSet<string>(["wide.tif"]),
|
||||
new Chronos.Core.Conversion.ConvertOptions(Chronos.Core.Conversion.ConvertTarget.LinearDng), desktop));
|
||||
}
|
||||
|
||||
/// <summary>A gradient with saturated patches, linear light, every value between 0 and 1.</summary>
|
||||
internal static ImageBuffer Scene(int width, int height)
|
||||
{
|
||||
var image = new ImageBuffer(width, height);
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
image[0, x, y] = 0.02f + 0.7f * x / width;
|
||||
image[1, x, y] = 0.05f + 0.5f * y / height;
|
||||
image[2, x, y] = 0.1f + 0.3f * ((x / 4 + y / 4) % 2);
|
||||
}
|
||||
}
|
||||
(image[0, 0, 0], image[1, 0, 0], image[2, 0, 0]) = (0.02f, 0.9f, 0.02f);
|
||||
(image[0, 1, 0], image[1, 1, 0], image[2, 1, 0]) = (0.9f, 0.02f, 0.02f);
|
||||
(image[0, 2, 0], image[1, 2, 0], image[2, 2, 0]) = (0.001f, 0.004f, 0.0005f);
|
||||
return image;
|
||||
}
|
||||
|
||||
private static void AssertClose(ImageBuffer expected, ImageBuffer actual, double tolerance, string what)
|
||||
{
|
||||
Assert.Equal((expected.Width, expected.Height), (actual.Width, actual.Height), what);
|
||||
for (var c = 0; c < 3; c++)
|
||||
{
|
||||
for (var i = 0; i < expected.PlaneLength; i++) Assert.Approximately(expected.Plane(c)[i], actual.Plane(c)[i], tolerance, what);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>An uncompressed little-endian TIFF of <paramref name="width"/> × <paramref name="height"/> CMYK pixels, each <paramref name="inks"/>, without a profile.</summary>
|
||||
private static byte[] CmykTiff(int width, int height, byte[] inks)
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user