using Chronos.Core.Archiving;
using Chronos.Core.Codecs.Dng;
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.Metadata;
using Chronos.Core.Model;
using Chronos.Core.Naming;
using Chronos.Testing;
namespace Chronos.Core.Tests.Conversion;
///
/// One photo converted (owner review 2, R7): to JPEG, TIFF-16 and linear DNG, decoded at full resolution only, with the
/// sidecar's capture facts to the tick and the original's camera, lens, modes and GPS, verified (read back, metadata, the
/// server's decoders) before it counts.
///
[Category("conversion")]
public sealed class FrameConverterTests(TestContext context)
{
private static readonly DateTime Captured = new DateTime(2026, 9, 28, 18, 0, 5).AddTicks(1_234_567);
/// The camera's file says one second earlier, without sub-seconds: the sidecar wins.
private static readonly FrameMetadata Camera = new()
{
Make = "Canon",
Model = "Canon EOS R5",
BodySerial = "032021001234",
LensModel = "RF15-35mm F2.8 L IS USM",
CapturedAt = new DateTime(2026, 9, 28, 18, 0, 4),
UtcOffsetMinutes = 60,
ExposureTime = 1 / 250.0,
FNumber = 8,
Iso = 100,
FocalLength = 15,
FocalLength35 = 15,
ExposureBias = -2 / 3.0,
ExposureProgram = 3,
MeteringMode = 5,
Flash = 16,
WhiteBalanceMode = 1,
Artist = "Alberto",
Gps = new GpsPosition(45.4642035, 9.1899817, 122.5, null),
};
private static SidecarFrame Frame(string file, ImageFileFormat format, int width, int height) => new()
{
Id = Guid.NewGuid(),
File = "originals/" + file,
Original = file,
Sha256 = new string('a', 64),
CapturedAt = Captured,
UtcOffset = 120,
TimeSource = TimestampSource.ExifOriginal,
Exposure = 1 / 125.0,
FNumber = 5.6,
Iso = 200,
Focal = 24,
Bias = -1,
W = width,
H = height,
Format = format,
Flags = FrameFlags.Intervalometer,
};
/// A gradient with some texture, so every encoder has real work and errors show.
private 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.05f + 0.6f * x / width;
image[1, x, y] = 0.1f + 0.5f * y / height;
image[2, x, y] = 0.2f + 0.2f * ((x / 8 + y / 8) % 2);
}
}
return image;
}
private string Source(int width = 96, int height = 64, int orientation = 1)
{
var path = Path.Combine(context.CreateTempDirectory("source"), "IMG_0001.JPG");
using var image = Scene(width, height);
var exif = ExifWriter.BuildJpegApp1(Camera with { Orientation = orientation });
File.WriteAllBytes(path, JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 97, Subsampling = JpegSubsampling.Yuv444, App1Segments = [exif[4..]] }));
return path;
}
private string Target(ConvertOptions options) => Path.Combine(context.CreateTempDirectory("staged"), "converted" + options.Extension);
[Theory]
[Case(ConvertTarget.Jpeg)]
[Case(ConvertTarget.Tiff16)]
[Case(ConvertTarget.LinearDng)]
public void TheSidecarsCaptureFactsAndTheCamerasMetadataRoundTrip(ConvertTarget target)
{
var options = new ConvertOptions(target);
var source = Source();
var frame = Frame("IMG_0001.JPG", ImageFileFormat.Jpeg, 96, 64);
var file = FrameConverter.Convert(new ConvertSource(source, frame), options, DecoderFactory.CreateServer(), Target(options), cancellationToken: context.Cancellation);
Assert.Equal((options.Format, 96, 64), (file.Format, file.Width, file.Height));
Assert.Equal(new FileInfo(file.Path).Length, file.Size);
Assert.Equal(file.Sha256, ContentHash.Sha256Async(file.Path).GetAwaiter().GetResult());
var read = MetadataReader.Read(file.Path);
Assert.Equal(options.Format, read.Format);
// The sidecar wins: the capture time to the tick, its offset, exposure, aperture, ISO, focal length and bias.
Assert.Equal(Captured, read.CapturedAt);
Assert.Equal(120, read.UtcOffsetMinutes);
Assert.Equal(TimestampSource.ExifOriginal, read.TimestampSource);
Assert.Approximately(1 / 125.0, read.ExposureTime!.Value, 1e-12);
Assert.Approximately(5.6, read.FNumber!.Value, 1e-9);
Assert.Equal(200, read.Iso);
Assert.Approximately(24, read.FocalLength!.Value, 1e-9);
Assert.Approximately(-1, read.ExposureBias!.Value, 1e-4);
// The original's own: camera, serial, lens, 35 mm focal length, modes, GPS, artist.
Assert.Equal(("Canon", "Canon EOS R5", "032021001234", "RF15-35mm F2.8 L IS USM"), (read.Make, read.Model, read.BodySerial, read.LensModel));
Assert.Approximately(15, read.FocalLength35!.Value, 1e-9);
Assert.Equal((3, 5, 16, 1), (read.ExposureProgram, read.MeteringMode, read.Flash, read.WhiteBalanceMode));
var gps = Assert.NotNull(read.Gps);
Assert.Approximately(45.4642035, gps.Latitude, 1e-6);
Assert.Approximately(9.1899817, gps.Longitude, 1e-6);
Assert.Equal(1, read.Orientation);
Assert.Equal((96, 64), read.OrientedSize);
}
[Theory]
[Case(ConvertTarget.Jpeg)]
[Case(ConvertTarget.Tiff16)]
[Case(ConvertTarget.LinearDng)]
public void TheConvertedFileDecodesAtFullResolutionWithTheServersDecoders(ConvertTarget target)
{
var options = new ConvertOptions(target);
var source = Source();
var frame = Frame("IMG_0001.JPG", ImageFileFormat.Jpeg, 96, 64);
var file = FrameConverter.Convert(new ConvertSource(source, frame), options, DecoderFactory.CreateServer(), Target(options), cancellationToken: context.Cancellation);
var server = DecoderFactory.CreateServer();
Assert.Equal(DecodeTier.Native, server.Probe(file.Path, file.Format).Tier);
using var original = server.Decode(new DecodeRequest(source, AllowPreview: false))!;
using var converted = Assert.NotNull(server.Decode(new DecodeRequest(file.Path, AllowPreview: false)));
Assert.Equal(DecodeTier.Native, converted.Tier);
Assert.Equal((96, 64), (converted.Pixels.Width, converted.Pixels.Height));
// The same picture: TIFF-16 and DNG keep it to 16 bits, the JPEG within its quantisation.
var tolerance = target == ConvertTarget.Jpeg ? 0.03 : 0.01;
var error = 0.0;
for (var c = 0; c < 3; c++)
{
var a = original.Pixels.Plane(c);
var b = converted.Pixels.Plane(c);
for (var i = 0; i < a.Length; i++) error += Math.Abs(a[i] - b[i]);
}
Assert.Less(error / (3.0 * 96 * 64), tolerance, $"mean error of {target}");
}
[Test]
public void TheJpegQualityAndFullChromaAreTheOnesAsked()
{
var source = Source(160, 120);
var frame = Frame("IMG_0001.JPG", ImageFileFormat.Jpeg, 160, 120);
var decoder = DecoderFactory.CreateServer();
var high = FrameConverter.Convert(new ConvertSource(source, frame), new ConvertOptions(ConvertTarget.Jpeg, 95), decoder,
Target(new ConvertOptions(ConvertTarget.Jpeg)), cancellationToken: context.Cancellation);
var low = FrameConverter.Convert(new ConvertSource(source, frame), new ConvertOptions(ConvertTarget.Jpeg, 20), decoder,
Target(new ConvertOptions(ConvertTarget.Jpeg)), cancellationToken: context.Cancellation);
Assert.Less(low.Size, high.Size);
var info = JpegDecoder.ReadInfo(File.ReadAllBytes(high.Path));
Assert.Equal("4:4:4", info.SamplingNotation);
Assert.Equal(ConvertOptions.DefaultQuality, new ConvertOptions(ConvertTarget.Jpeg).Quality);
}
[Test]
public void TiffAndLinearDngAreSixteenBitsAndReadByTheInHouseReaders()
{
var source = Source();
var frame = Frame("IMG_0001.JPG", ImageFileFormat.Jpeg, 96, 64);
var decoder = DecoderFactory.CreateServer();
var tiff = FrameConverter.Convert(new ConvertSource(source, frame), new ConvertOptions(ConvertTarget.Tiff16), decoder,
Target(new ConvertOptions(ConvertTarget.Tiff16)), cancellationToken: context.Cancellation);
var dng = FrameConverter.Convert(new ConvertSource(source, frame), new ConvertOptions(ConvertTarget.LinearDng), decoder,
Target(new ConvertOptions(ConvertTarget.LinearDng)), cancellationToken: context.Cancellation);
Assert.Equal(16, MetadataReader.Read(tiff.Path).BitsPerSample);
using (var back = TiffImageReader.Decode(File.ReadAllBytes(tiff.Path)))
Assert.Equal((96, 64, 3), (back.Width, back.Height, back.Channels));
Assert.Equal(ImageFileFormat.Dng, MetadataReader.Read(dng.Path).Format);
using (var back = TiffImageReader.Decode(File.ReadAllBytes(dng.Path)))
Assert.Equal((96, 64, 3), (back.Width, back.Height, back.Channels));
}
[Test]
public void APortraitOriginalIsConvertedUpright()
{
var source = Source(96, 64, orientation: 6);
var frame = Frame("IMG_0001.JPG", ImageFileFormat.Jpeg, 96, 64) with { Orientation = 6 };
var options = new ConvertOptions(ConvertTarget.Jpeg);
var file = FrameConverter.Convert(new ConvertSource(source, frame), options, DecoderFactory.CreateServer(), Target(options), cancellationToken: context.Cancellation);
Assert.Equal((64, 96), (file.Width, file.Height));
var read = MetadataReader.Read(file.Path);
Assert.Equal((1, 64, 96), (read.Orientation, read.Width, read.Height));
}
[Test]
public void ACameraAndLensTheFileLacksComeFromTheSequence()
{
var path = Path.Combine(context.CreateTempDirectory("source"), "frame.png");
using (var image = Scene(32, 24)) File.WriteAllBytes(path, Chronos.Core.Codecs.Png.PngEncoder.Encode(image));
var frame = Frame("frame.png", ImageFileFormat.Png, 32, 24);
var options = new ConvertOptions(ConvertTarget.Tiff16);
var file = FrameConverter.Convert(new ConvertSource(path, frame, new SidecarCamera { Make = "Sony", Model = "ILCE-7RM5", Serial = "77" }, "FE 24mm F1.4 GM"),
options, DecoderFactory.CreateServer(), Target(options), cancellationToken: context.Cancellation);
var read = MetadataReader.Read(file.Path);
Assert.Equal(("Sony", "ILCE-7RM5", "77", "FE 24mm F1.4 GM"), (read.Make, read.Model, read.BodySerial, read.LensModel));
Assert.Equal(Captured, read.CapturedAt);
}
[Test]
public void APhotoReadOnlyFromItsPreviewIsNotConverted()
{
// A DNG the managed decoder reads natively, behind a chain that offers only a preview.
var path = Path.Combine(context.CreateTempDirectory("source"), "frame.dng");
using (var image = Scene(32, 24)) File.WriteAllBytes(path, LinearDngWriter.Write(image));
var frame = Frame("frame.dng", ImageFileFormat.Dng, 32, 24);
var options = new ConvertOptions(ConvertTarget.Jpeg);
var target = Target(options);
Assert.Throws(() =>
FrameConverter.Convert(new ConvertSource(path, frame), options, new ImageDecoder([new PreviewOnlyProvider()]), target, cancellationToken: context.Cancellation));
Assert.FileMissing(target);
Assert.Throws(() =>
FrameConverter.Convert(new ConvertSource(path, frame), options, new ImageDecoder([]), target, cancellationToken: context.Cancellation));
}
[Test]
public void AFileThatDoesNotReadBackIsRefused()
{
var source = Source();
var frame = Frame("IMG_0001.JPG", ImageFileFormat.Jpeg, 96, 64);
var options = new ConvertOptions(ConvertTarget.Jpeg);
var file = FrameConverter.Convert(new ConvertSource(source, frame), options, DecoderFactory.CreateServer(), Target(options), cancellationToken: context.Cancellation);
var written = FrameConverter.Metadata(MetadataReader.Read(source), new ConvertSource(source, frame));
Assert.DoesNotThrow(() => FrameConverter.Verify(file, written));
// A bit flipped on the way to the disk.
var bytes = File.ReadAllBytes(file.Path);
bytes[^10] ^= 0x40;
File.WriteAllBytes(file.Path, bytes);
Assert.Throws(() => FrameConverter.Verify(file, written));
// A capture time that is not the one written.
File.WriteAllBytes(file.Path, File.ReadAllBytes(source));
Assert.Throws(() => FrameConverter.Verify(file with { Sha256 = ContentHash.Sha256Async(file.Path).GetAwaiter().GetResult(), Size = new FileInfo(file.Path).Length }, written));
}
[Test]
public void ConvertedNamesAreTheNamesFilingGives()
{
var dng = new ConvertOptions(ConvertTarget.LinearDng);
Assert.Equal("originals/IMG_0001.dng", dng.WithExtension("originals/IMG_0001.CR2"));
Assert.Equal("frame.jpg", new ConvertOptions(ConvertTarget.Jpeg).WithExtension("frame"));
// The second frame of a sequence filed by a Canon, named with the sequence's camera, its number, the title and the
// name it had on the card, as an upload or a Reorganize names it; {ext} is the target's.
var first = Frame("2026-09-28_0001.CR3", ImageFileFormat.Cr3, 96, 64) with { I = 0, Original = "IMG_0001.CR3" };
var second = Frame("2026-09-28_0002.CR3", ImageFileFormat.Cr3, 96, 64) with { I = 1, Original = "IMG_0002.CR3", CapturedAt = Captured.AddSeconds(10) };
var sequence = new SequenceManifest
{
Id = Guid.NewGuid(),
Title = "Harbour",
Camera = new SidecarCamera { Make = "Canon", Model = "Canon EOS R5" },
Frames = [first, second],
};
Assert.Equal("originals/Harbour_Canon EOS R5_0002_IMG_0002.dng",
dng.FileName(PathTemplate.Parse("{title}_{camera}_{n}_{name}.{ext}"), second, sequence));
Assert.Equal("originals/2026-09-28_0002.tif",
new ConvertOptions(ConvertTarget.Tiff16).FileName(PathTemplate.Parse("{date}_{n}"), second, sequence));
Assert.Equal(PathTemplate.Parse("{date}_{n}").ExpandFile(FrameNaming.Context(second with { File = "originals/x.dng" }, sequence, "Harbour")),
Path.GetFileName(dng.FileName(PathTemplate.Parse("{date}_{n}"), second, sequence)));
// A frame adopted in place stays in its folder; a long name keeps the target's extension whole.
var adopted = second with { File = "IMG_0002.CR3", Original = new string('x', 300) + ".CR3" };
var named = dng.FileName(PathTemplate.Parse("{name}.{ext}"), adopted, sequence);
Assert.False(named.Contains('/'));
Assert.True(named.EndsWith(".dng", StringComparison.Ordinal) && named.Length <= PathTemplate.MaxSegmentLength, named);
Assert.Equal(ConvertTarget.LinearDng, ConvertOptions.ArchivalTarget);
Assert.False(new ConvertOptions(ConvertTarget.Jpeg, 0).IsValid);
Assert.False(new ConvertOptions(ConvertTarget.Jpeg, 101).IsValid);
Assert.Equal(new ConvertOptions(ConvertTarget.LinearDng, 10).Key, new ConvertOptions(ConvertTarget.LinearDng, 90).Key);
}
/// A provider that claims DNG natively but only ever gives the embedded-preview tier.
private sealed class PreviewOnlyProvider : IImageDecoderProvider
{
private readonly ManagedDecoderProvider _managed = new();
public string Name => "preview-only";
public DecodeTier? TierFor(ImageFileFormat format) => format == ImageFileFormat.Dng ? DecodeTier.Native : null;
public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default)
{
var decoded = _managed.Decode(request with { AllowPreview = true }, cancellationToken);
if (decoded is null) return null;
var copy = decoded.Pixels.Clone();
decoded.Dispose();
return new DecodedImage(copy, DecodeTier.EmbeddedPreview, Name, copy.Width, copy.Height);
}
}
}