Phase 4b review, codec findings. A Replace makes the converted file the photo, so a conversion must not lose what the original held, and the dry run must promise only what the job will do. - Linear DNG from a conversion is scene-referred: the pixels are stored in linear ProPhoto primaries (colours outside sRGB stay positive) and divided by the power of two that brings their peak under the white level (at most 4 stops), with BaselineExposure giving it back and ColorMatrix1/ForwardMatrix1 describing that space. Highlights a RAW develops above 1 and its wide-gamut colours now read back as written. Exports keep the clipped linear-sRGB DNG. - A conversion reads with the managed decoders first for every format they read natively (RAWs developed at float precision, as on the server) and with WIC only for what they cannot. A RAW only WIC's Raw Image Extension develops (8 bits) is refused for TIFF-16 and linear DNG and planned out as "eight_bit"; JPEG still converts it. Providers say so through IImageDecoderProvider.DevelopsRawAt8Bits. - The original's colour space is kept: a JPEG (APP2) or TIFF (tag 34675) carries its ICC profile, with the values unchanged; a linear DNG gets the values converted through a matrix/TRC profile; a gray profile converts to sRGB. Exif Adobe RGB (uncalibrated + R03) and HEIF nclx P3 get an in-house profile. A space nothing here can keep (CMYK, a lookup-table profile into a DNG, uncalibrated without R03, HDR nclx) is planned out as "color_profile". New in-house ICC parser/writer and header reader for JPEG, PNG, TIFF, HEIF/AVIF and WebP. - The planner asks every file, whatever tier was recorded (unknown before the light analysis, or by another host), with the conversion's decoders, headers only and eight at a time; a RAW the server cannot develop is "convert_on_pc" in the plan instead of failing its sequence. Photos a target cannot hold (a JPEG side above 65535, more samples than one buffer) are planned out as "too_large", and an overflow fails its photo rather than the job. - A photo that fails reads in the job log as one catalog sentence by cause (Archive.Convert.Failed.*), the file named once; the exception's English text goes to the diagnostics log only. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 0ca1e91ea09946d7a55f45695ee58e1a0ff5f779)
247 lines
15 KiB
C#
247 lines
15 KiB
C#
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Codecs.Icc;
|
|
using Chronos.Core.Codecs.Raw;
|
|
using Chronos.Core.Conversion;
|
|
using Chronos.Core.Export;
|
|
using Chronos.Core.Imaging;
|
|
using Chronos.Core.Imaging.Decoders;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Core.Tests.Raw;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Core.Tests.Conversion;
|
|
|
|
/// <summary>The dry run of a conversion (owner review 2, R7): which frames convert, which stay and why, the sizes, the space and the fingerprint.</summary>
|
|
[Category("conversion")]
|
|
public sealed class ConvertPlannerTests(TestContext context)
|
|
{
|
|
private static SidecarFrame Frame(int i, string file, ImageFileFormat format, string? sha = "s", FrameFlags flags = FrameFlags.None,
|
|
DecodeTier tier = default) => new()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
I = i,
|
|
File = "originals/" + file,
|
|
Size = 1000 + i,
|
|
Sha256 = sha is null ? null : sha + i,
|
|
Format = format,
|
|
W = 6000,
|
|
H = 4000,
|
|
Flags = flags,
|
|
Tier = tier,
|
|
};
|
|
|
|
[Test]
|
|
public void EachFrameThatCannotConvertSaysWhy()
|
|
{
|
|
var folder = new ArchivePaths(context.CreateTempDirectory("archive")).Sequence("2026/roof");
|
|
SidecarFrame[] frames =
|
|
[
|
|
Frame(0, "IMG_0001.CR2", ImageFileFormat.Cr2),
|
|
Frame(1, "IMG_0002.DNG", ImageFileFormat.Dng),
|
|
Frame(2, "IMG_0003.CR2", ImageFileFormat.Cr2),
|
|
Frame(3, "IMG_0004.CR2", ImageFileFormat.Cr2, sha: null),
|
|
Frame(4, "IMG_0005.CR2", ImageFileFormat.Cr2, flags: FrameFlags.Undecodable),
|
|
Frame(5, "IMG_0006.CR3", ImageFileFormat.Cr3),
|
|
Frame(6, "IMG_0007.HEIC", ImageFileFormat.Heif),
|
|
Frame(7, "IMG_0008.JPG", ImageFileFormat.Jpeg, flags: FrameFlags.Missing),
|
|
Frame(8, "IMG_0009.CR2", ImageFileFormat.Cr2, flags: FrameFlags.PreviewOnly | FrameFlags.Excluded, tier: DecodeTier.EmbeddedPreview),
|
|
];
|
|
var manifest = new SequenceManifest { Id = Guid.NewGuid(), Frames = frames, Versions = new ManifestVersions { Frames = 7 } };
|
|
// The third photo's file is gone; the preview-only one probes as preview here, the first one native.
|
|
var present = frames.Where(f => f.I != 2).Select(f => f.File).ToList();
|
|
var decoder = new ImageDecoder([new ProbeAs(DecodeTier.EmbeddedPreview, path => path.EndsWith("IMG_0009.CR2", StringComparison.Ordinal))]);
|
|
var plan = ConvertPlanner.Plan(manifest, folder, present, new ConvertOptions(ConvertTarget.LinearDng), decoder, "Roof");
|
|
|
|
Assert.Equal((manifest.Id, "Roof", "2026/roof", 7), (plan.SequenceId, plan.Title, plan.Folder, plan.FramesVersion));
|
|
Assert.SequenceEqual([0], plan.Frames.Select(f => f.Index));
|
|
Assert.SequenceEqual(
|
|
[(ConvertSkip.SameFormat, 1), (ConvertSkip.NoNativeDecoder, 2), (ConvertSkip.PreviewOnly, 1), (ConvertSkip.Undecodable, 1), (ConvertSkip.Missing, 2),
|
|
(ConvertSkip.Unhashed, 1)],
|
|
plan.Skipped.Select(s => (s.Reason, s.Frames)));
|
|
Assert.True(plan.Converts);
|
|
Assert.Equal(1000, plan.BytesBefore);
|
|
Assert.Equal(ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.LinearDng), 6000, 4000), plan.BytesAfter);
|
|
Assert.Equal(8, plan.SkippedFrames);
|
|
}
|
|
|
|
[Test]
|
|
public void APhotoRecordedAsPreviewOnlyElsewhereConvertsWhereItDecodes()
|
|
{
|
|
var folder = new ArchivePaths(context.CreateTempDirectory("archive")).Sequence("roof");
|
|
var frame = Frame(0, "IMG_0001.CR2", ImageFileFormat.Cr2, flags: FrameFlags.PreviewOnly, tier: DecodeTier.EmbeddedPreview);
|
|
var manifest = new SequenceManifest { Id = Guid.NewGuid(), Frames = [frame] };
|
|
var plan = ConvertPlanner.Plan(manifest, folder, [frame.File], new ConvertOptions(ConvertTarget.Tiff16), new ImageDecoder([new ProbeAs(DecodeTier.Native)]), "Roof");
|
|
Assert.Count(1, plan.Frames);
|
|
Assert.Empty(plan.Skipped);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A frame whose tier is not known yet (imported, not analysed) or was recorded native by another host with other
|
|
/// decoders is asked again: the dry run promises only what the file says here now.
|
|
/// </summary>
|
|
[Test]
|
|
public void AFrameIsAskedWhateverTierWasRecorded()
|
|
{
|
|
var folder = new ArchivePaths(context.CreateTempDirectory("archive")).Sequence("roof");
|
|
SidecarFrame[] frames = [Frame(0, "IMG_0001.CR2", ImageFileFormat.Cr2), Frame(1, "IMG_0002.CR2", ImageFileFormat.Cr2, tier: DecodeTier.Native)];
|
|
var manifest = new SequenceManifest { Id = Guid.NewGuid(), Frames = frames };
|
|
var present = frames.Select(f => f.File).ToList();
|
|
var dng = new ConvertOptions(ConvertTarget.LinearDng);
|
|
|
|
var preview = ConvertPlanner.Plan(manifest, folder, present, dng, new ImageDecoder([new ProbeAs(DecodeTier.EmbeddedPreview)]), "Roof");
|
|
Assert.Empty(preview.Frames);
|
|
Assert.SequenceEqual([(ConvertSkip.PreviewOnly, 2)], preview.Skipped.Select(s => (s.Reason, s.Frames)));
|
|
var unreadable = ConvertPlanner.Plan(manifest, folder, present, dng, new ImageDecoder([new ProbeAs(DecodeTier.Unavailable)]), "Roof");
|
|
Assert.SequenceEqual([(ConvertSkip.Undecodable, 2)], unreadable.Skipped.Select(s => (s.Reason, s.Frames)));
|
|
var native = ConvertPlanner.Plan(manifest, folder, present, dng, new ImageDecoder([new ProbeAs(DecodeTier.Native)]), "Roof");
|
|
Assert.SequenceEqual([0, 1], native.Frames.Select(f => f.Index));
|
|
}
|
|
|
|
/// <summary>
|
|
/// The managed decoder develops every RAW it reads natively (at float precision) even where WIC could; a RAW only WIC's
|
|
/// Raw Image Extension develops, at 8 bits, converts to JPEG but not to TIFF-16 or linear DNG.
|
|
/// </summary>
|
|
[Test]
|
|
public void ARawDevelopedAtEightBitsOnlyConvertsToJpegOnly()
|
|
{
|
|
var folder = new ArchivePaths(context.CreateTempDirectory("archive")).Sequence("roof");
|
|
System.IO.Directory.CreateDirectory(Path.GetDirectoryName(folder.File("originals/x"))!);
|
|
using var scene = SyntheticRaw.Smooth(96, 64);
|
|
var active = new RawRect(24, 4, 24 + 96, 4 + 64);
|
|
var sensor = NativeRawWriters.Sensor(scene, "Canon EOS 5D Mark III", CfaPattern.Bayer("RGGB"), 128, 72, active.Left, active.Top, 2048, 16383);
|
|
SidecarFrame[] frames =
|
|
[
|
|
Frame(0, "IMG_0001.CR2", ImageFileFormat.Cr2, tier: DecodeTier.Native),
|
|
Frame(1, "IMG_0002.CR2", ImageFileFormat.Cr2, tier: DecodeTier.Native),
|
|
Frame(2, "IMG_0003.CR3", ImageFileFormat.Cr3, tier: DecodeTier.Native),
|
|
];
|
|
File.WriteAllBytes(folder.File(frames[0].File), NativeRawWriters.Cr2(sensor, active));
|
|
// A body the managed decoder has no matrix for: only the 8-bit development reads it.
|
|
File.WriteAllBytes(folder.File(frames[1].File), NativeRawWriters.Cr2(sensor, active, model: "Canon EOS R99"));
|
|
File.WriteAllBytes(folder.File(frames[2].File), [0]);
|
|
var manifest = new SequenceManifest { Id = Guid.NewGuid(), Frames = frames };
|
|
var present = frames.Select(f => f.File).ToList();
|
|
var desktop = new ImageDecoder([new EightBitRaw(), new ManagedDecoderProvider()]);
|
|
|
|
foreach (var target in (ConvertTarget[])[ConvertTarget.Tiff16, ConvertTarget.LinearDng])
|
|
{
|
|
var plan = ConvertPlanner.Plan(manifest, folder, present, new ConvertOptions(target), desktop, "Roof");
|
|
Assert.SequenceEqual([0], plan.Frames.Select(f => f.Index));
|
|
Assert.SequenceEqual([(ConvertSkip.EightBit, 2)], plan.Skipped.Select(s => (s.Reason, s.Frames)));
|
|
}
|
|
var jpeg = ConvertPlanner.Plan(manifest, folder, present, new ConvertOptions(ConvertTarget.Jpeg), desktop, "Roof");
|
|
Assert.SequenceEqual([0, 1, 2], jpeg.Frames.Select(f => f.Index));
|
|
// The server, without WIC: the unsupported body and the CR3 are to convert on a PC.
|
|
var server = ConvertPlanner.Plan(manifest, folder, present, new ConvertOptions(ConvertTarget.Tiff16), DecoderFactory.CreateServer(), "Roof");
|
|
Assert.SequenceEqual([0], server.Frames.Select(f => f.Index));
|
|
Assert.SequenceEqual([(ConvertSkip.NoNativeDecoder, 1), (ConvertSkip.PreviewOnly, 1)], server.Skipped.Select(s => (s.Reason, s.Frames)));
|
|
}
|
|
|
|
/// <summary>A photo whose colour space no target can keep, or which a target cannot hold, is planned out with why.</summary>
|
|
[Test]
|
|
public void ColourAndSizeTheTargetCannotHoldArePlannedOut()
|
|
{
|
|
var folder = new ArchivePaths(context.CreateTempDirectory("archive")).Sequence("roof");
|
|
System.IO.Directory.CreateDirectory(Path.GetDirectoryName(folder.File("originals/x"))!);
|
|
using var scene = ColorFixtures.Scene();
|
|
SidecarFrame[] frames =
|
|
[
|
|
Frame(0, "plain.jpg", ImageFileFormat.Jpeg),
|
|
Frame(1, "p3.jpg", ImageFileFormat.Jpeg),
|
|
Frame(2, "unknown.jpg", ImageFileFormat.Jpeg),
|
|
Frame(3, "cmyk.jpg", ImageFileFormat.Jpeg),
|
|
Frame(4, "panorama.png", ImageFileFormat.Png) with { W = 70_000, H = 3_800 },
|
|
Frame(5, "huge.png", ImageFileFormat.Png) with { W = 70_000, H = 12_000 },
|
|
];
|
|
File.WriteAllBytes(folder.File(frames[0].File), ColorFixtures.Jpeg(scene));
|
|
File.WriteAllBytes(folder.File(frames[1].File), ColorFixtures.Jpeg(scene, IccProfile.DisplayP3.Data));
|
|
File.WriteAllBytes(folder.File(frames[2].File), ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(0xFFFF)));
|
|
File.WriteAllBytes(folder.File(frames[3].File), ColorFixtures.Jpeg(scene, ColorFixtures.Cmyk()));
|
|
File.WriteAllBytes(folder.File(frames[4].File), [0]);
|
|
File.WriteAllBytes(folder.File(frames[5].File), [0]);
|
|
var manifest = new SequenceManifest { Id = Guid.NewGuid(), Frames = frames };
|
|
var present = frames.Select(f => f.File).ToList();
|
|
var decoder = DecoderFactory.CreateServer();
|
|
|
|
// A TIFF and a DNG keep the P3 photo (carried, or converted), not the unknown and CMYK ones, nor 2.5 G samples.
|
|
foreach (var target in (ConvertTarget[])[ConvertTarget.Tiff16, ConvertTarget.LinearDng])
|
|
{
|
|
var plan = ConvertPlanner.Plan(manifest, folder, present, new ConvertOptions(target), decoder, "Roof");
|
|
Assert.SequenceEqual([0, 1, 4], plan.Frames.Select(f => f.Index));
|
|
Assert.SequenceEqual([(ConvertSkip.ColorProfile, 2), (ConvertSkip.TooLarge, 1)], plan.Skipped.Select(s => (s.Reason, s.Frames)));
|
|
}
|
|
// A JPEG side holds 65535 pixels.
|
|
var jpeg = ConvertPlanner.Plan(manifest, folder, present, new ConvertOptions(ConvertTarget.Jpeg), decoder, "Roof");
|
|
Assert.SequenceEqual([(ConvertSkip.SameFormat, 4), (ConvertSkip.TooLarge, 2)], jpeg.Skipped.Select(s => (s.Reason, s.Frames)));
|
|
Assert.True(ConvertPlanner.TooLarge(new ConvertOptions(ConvertTarget.Jpeg), 65_536, 10));
|
|
Assert.False(ConvertPlanner.TooLarge(new ConvertOptions(ConvertTarget.Jpeg), 65_535, 10));
|
|
Assert.False(ConvertPlanner.TooLarge(new ConvertOptions(ConvertTarget.Tiff16), 0, 0));
|
|
}
|
|
|
|
[Test]
|
|
public void SizesAreEstimatedFromThePixels()
|
|
{
|
|
const long pixels = 6000L * 4000;
|
|
Assert.Equal((long)Math.Ceiling(pixels * 30 / 8.0), ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.Tiff16), 6000, 4000));
|
|
Assert.Equal((long)Math.Ceiling(pixels * 26 / 8.0), ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.LinearDng), 6000, 4000));
|
|
Assert.Equal((long)Math.Ceiling(pixels * ExportEstimator.JpegBitsPerPixel(95) * 1.25 / 8),
|
|
ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.Jpeg), 6000, 4000));
|
|
Assert.Less(ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.Jpeg, 50), 6000, 4000),
|
|
ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.Jpeg, 95), 6000, 4000));
|
|
// Unknown size: a 24 MP frame.
|
|
Assert.Equal(ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.Tiff16), 6000, 4000), ConvertPlanner.EstimateBytes(new ConvertOptions(ConvertTarget.Tiff16), 0, 0));
|
|
Assert.Equal((long)Math.Ceiling(1_000_000_000 * 1.15) + (512L << 20), ConvertPlanner.Required(1_000_000_000));
|
|
Assert.True(new ConvertSpace(100, null).Enough);
|
|
Assert.True(new ConvertSpace(100, 100).Enough);
|
|
Assert.False(new ConvertSpace(100, 99).Enough);
|
|
}
|
|
|
|
[Test]
|
|
public void TheFingerprintFollowsWhatThePlanConverts()
|
|
{
|
|
var id = Guid.NewGuid();
|
|
ConvertSequencePlan Sequence(int version, int frames, params ConvertBlock[] blocked) =>
|
|
new(id, "Roof", "roof", version, [.. Enumerable.Range(0, frames).Select(i => new ConvertFramePlan(Guid.Empty, i, $"f{i}", ImageFileFormat.Cr2, 10, 20))],
|
|
[], blocked);
|
|
ConvertPlan Plan(ConvertOptions options, ConvertMode mode, ConvertSequencePlan sequence) => new(Guid.Empty, options, mode, [sequence], new ConvertSpace(0, null));
|
|
var dng = new ConvertOptions(ConvertTarget.LinearDng);
|
|
var reference = Plan(dng, ConvertMode.Replace, Sequence(3, 2)).Fingerprint();
|
|
Assert.Equal(64, reference.Length);
|
|
Assert.Equal(reference, Plan(dng with { Quality = 40 }, ConvertMode.Replace, Sequence(3, 2)).Fingerprint());
|
|
Assert.NotEqual(reference, Plan(dng, ConvertMode.NewSequence, Sequence(3, 2)).Fingerprint());
|
|
Assert.NotEqual(reference, Plan(new ConvertOptions(ConvertTarget.Jpeg), ConvertMode.Replace, Sequence(3, 2)).Fingerprint());
|
|
Assert.NotEqual(reference, Plan(dng, ConvertMode.Replace, Sequence(4, 2)).Fingerprint());
|
|
Assert.NotEqual(reference, Plan(dng, ConvertMode.Replace, Sequence(3, 1)).Fingerprint());
|
|
var busy = Plan(dng, ConvertMode.Replace, Sequence(3, 2, ConvertBlock.Busy));
|
|
Assert.NotEqual(reference, busy.Fingerprint());
|
|
Assert.Equal((0, 0L), (busy.Frames, busy.BytesAfter));
|
|
Assert.NotEqual(Plan(new ConvertOptions(ConvertTarget.Jpeg, 90), ConvertMode.Replace, Sequence(3, 2)).Fingerprint(),
|
|
Plan(new ConvertOptions(ConvertTarget.Jpeg, 80), ConvertMode.Replace, Sequence(3, 2)).Fingerprint());
|
|
}
|
|
|
|
/// <summary>A provider that reads CR2 natively by format, and probes the files <paramref name="applies"/> picks (all
|
|
/// by default) at a fixed tier, the others native.</summary>
|
|
private sealed class ProbeAs(DecodeTier tier, Func<string, bool>? applies = null) : IImageDecoderProvider
|
|
{
|
|
public string Name => "probe";
|
|
|
|
public DecodeTier? TierFor(ImageFileFormat format) => format == ImageFileFormat.Cr2 ? DecodeTier.Native : null;
|
|
|
|
public FileTier Probe(string path, ImageFileFormat format) => new(format, applies?.Invoke(path) == false ? DecodeTier.Native : tier, Name, null, 0, 0);
|
|
|
|
public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) => null;
|
|
}
|
|
|
|
/// <summary>WIC with the Raw Image Extension, as a conversion sees it: every camera RAW native, developed at 8 bits.</summary>
|
|
internal sealed class EightBitRaw : IImageDecoderProvider
|
|
{
|
|
public string Name => "wic";
|
|
|
|
public bool DevelopsRawAt8Bits => true;
|
|
|
|
public DecodeTier? TierFor(ImageFileFormat format) => ImageFormatInfo.Of(format).Family == ImageFamily.CameraRaw ? DecodeTier.Native : null;
|
|
|
|
public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) => null;
|
|
}
|
|
}
|