feat: owner review 2 phase 4b: mass conversion after import (#13)
CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s

Convert photos already in the archive to JPEG, TIFF-16 or Linear DNG, from the panel's Library and the desktop's Archive and Library. Each run asks Replace (same frames, originals to the trash, recoverable) or New sequence. A dry run lists what converts, what is skipped and why, size before and after, and free space; the job converts exactly the confirmed photos, resumes, and commits all or nothing per sequence. A conversion never changes what Chronos reads from a photo. Replaced originals are erased only on the archive's own word that their conversion is gone. Desktop TIFFs that WIC showed black or as noise now go to the managed reader; the Edit picker no longer spins a core.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
This commit was merged in pull request #13.
This commit is contained in:
Alby96andClaude Opus 5.5 authored and Alby96 committed 2026-11-03 10:41:50 +01:00
1 parent 7e4a3b481d
commit efa87f68ce
354 files changed
+24530 -843

No files matched your search

@@ -21,6 +21,242 @@ public sealed class WicDecoderProviderTests(TestContext context)
Assert.Null(Provider.TierFor(ImageFileFormat.Unknown));
}
/// <summary>
/// A conversion on the desktop (owner review 2, R7) reads every format the managed decoders read natively through them,
/// WIC after them, and a RAW for a 16-bit target never through WIC's Raw Image Extension (8 bits).
/// </summary>
[Test]
public void AConversionReadsWithTheManagedDecodersFirstAndRawsAtSixteenBitsWithoutWic()
{
Assert.True(((IImageDecoderProvider)Provider).DevelopsRawAt8Bits);
var desktop = Chronos.Core.Imaging.Decoders.DecoderFactory.CreateClient(Provider);
Assert.Equal("wic", desktop.Providers[0].Name);
var jpeg = Chronos.Core.Conversion.FrameConverter.Decoders(desktop, new Chronos.Core.Conversion.ConvertOptions(Chronos.Core.Conversion.ConvertTarget.Jpeg), ImageFileFormat.Cr2);
Assert.SequenceEqual(["managed", "wic"], jpeg.Providers.Select(p => p.Name));
var tiff = Chronos.Core.Conversion.FrameConverter.Decoders(desktop, new Chronos.Core.Conversion.ConvertOptions(Chronos.Core.Conversion.ConvertTarget.Tiff16), ImageFileFormat.Cr2);
Assert.SequenceEqual(["managed"], tiff.Providers.Select(p => p.Name));
var heif = Chronos.Core.Conversion.FrameConverter.Decoders(desktop, new Chronos.Core.Conversion.ConvertOptions(Chronos.Core.Conversion.ConvertTarget.Tiff16), ImageFileFormat.Heif);
Assert.SequenceEqual(["managed", "wic"], heif.Providers.Select(p => p.Name));
}
/// <summary>
/// An untagged CMYK TIFF, which the managed reader refuses rather than read as the gray of its first ink, is planned and
/// converted through WIC on the desktop (owner review 2, R7): its red stays red in the converted file.
/// </summary>
[Test]
public void ACmykTiffConvertsThroughWicInItsColours()
{
var path = Path.Combine(context.CreateTempDirectory(), "cmyk.tif");
File.WriteAllBytes(path, CmykTiff(6, 4, [0, 255, 255, 0]));
var desktop = Chronos.Core.Imaging.Decoders.DecoderFactory.CreateClient(Provider);
var jpeg = new Chronos.Core.Conversion.ConvertOptions(Chronos.Core.Conversion.ConvertTarget.Jpeg);
var probe = Chronos.Core.Conversion.FrameConverter.Decoders(desktop, jpeg, ImageFileFormat.Tiff).Probe(path, ImageFileFormat.Tiff);
Assert.Equal((DecodeTier.Native, "wic"), (probe.Tier, probe.Decoder));
var frame = new Chronos.Core.Archiving.SidecarFrame
{
Id = Guid.NewGuid(),
File = "originals/cmyk.tif",
Sha256 = new string('a', 64),
W = 6,
H = 4,
Format = ImageFileFormat.Tiff,
};
var target = Path.Combine(context.CreateTempDirectory(), "converted.jpg");
var file = Chronos.Core.Conversion.FrameConverter.Convert(new Chronos.Core.Conversion.ConvertSource(path, frame), jpeg, desktop, target,
cancellationToken: context.Cancellation);
using var converted = Assert.NotNull(Chronos.Core.Conversion.FrameConverter.Verifier.Decode(new DecodeRequest(file.Path, AllowPreview: false)));
Assert.Greater(converted.Pixels[0, 3, 2], 0.5);
Assert.Less(converted.Pixels[1, 3, 2], 0.1);
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)
{
var strip = new byte[width * height * 4];
for (var i = 0; i < width * height; i++) inks.CopyTo(strip, i * 4);
const int ifd = 8;
(ushort Tag, ushort Type, uint Count, uint Value)[] entries =
[
(256, 4, 1, (uint)width),
(257, 4, 1, (uint)height),
(258, 3, 4, 0), // four 8-bit samples, stored after the directory
(259, 3, 1, 1),
(262, 3, 1, 5), // separated: CMYK
(273, 4, 1, 0), // the strip, after the samples' bits
(277, 3, 1, 4),
(278, 4, 1, (uint)height),
(279, 4, 1, (uint)strip.Length),
];
var bits = ifd + 2 + entries.Length * 12 + 4;
var data = bits + 8;
using var stream = new MemoryStream();
using var writer = new BinaryWriter(stream);
writer.Write("II*\0"u8);
writer.Write((uint)ifd);
writer.Write((ushort)entries.Length);
foreach (var (tag, type, count, value) in entries)
{
writer.Write(tag);
writer.Write(type);
writer.Write(count);
writer.Write(tag switch { 258 => (uint)bits, 273 => (uint)data, _ => value });
}
writer.Write(0u);
for (var i = 0; i < 4; i++) writer.Write((ushort)8);
writer.Write(strip);
return stream.ToArray();
}
[Test]
public void PngMidGreyDecodesToLinearLight()
{