using System.Globalization; using Chronos.Core.Archiving; using Chronos.Core.Codecs.Dng; using Chronos.Core.Codecs.Icc; using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Codecs.Png; using Chronos.Core.Codecs.Tiff; using Chronos.Core.Conversion; using Chronos.Core.Imaging; using Chronos.Core.Imaging.Decoders; using Chronos.Core.Localization; using Chronos.Core.Mathematics; 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); var preview = Assert.Throws(() => FrameConverter.Convert(new ConvertSource(path, frame), options, new ImageDecoder([new PreviewOnlyProvider()]), target, cancellationToken: context.Cancellation)); Assert.Equal(ConversionFailure.PreviewOnly, preview.Reason); Assert.FileMissing(target); var none = Assert.Throws(() => FrameConverter.Convert(new ConvertSource(path, frame), options, new ImageDecoder([]), target, cancellationToken: context.Cancellation)); Assert.Equal(ConversionFailure.NoDecoder, none.Reason); } [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.Equal(ConversionFailure.NotVerified, Assert.Throws(() => FrameConverter.Verify(file, written)).Reason); // 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); } /// /// The managed decoder develops a RAW wherever it reads it natively, ahead of WIC (owner review 2, R7): a 16-bit file is /// never filled from WIC's 8-bit RAW development, which a JPEG may still use. /// [Test] public void ASixteenBitFileNeverComesFromAnEightBitRawDevelopment() { 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 wic = new EightBitRaw(); foreach (var target in (ConvertTarget[])[ConvertTarget.Tiff16, ConvertTarget.LinearDng, ConvertTarget.Jpeg]) { var options = new ConvertOptions(target); FrameConverter.Convert(new ConvertSource(path, frame), options, new ImageDecoder([wic, new ManagedDecoderProvider()]), Target(options), cancellationToken: context.Cancellation); } Assert.Equal(0, wic.Calls); // Where only the 8-bit development reads it: refused for 16 bits, converted to JPEG. foreach (var target in (ConvertTarget[])[ConvertTarget.Tiff16, ConvertTarget.LinearDng]) { var options = new ConvertOptions(target); var refused = Assert.Throws(() => FrameConverter.Convert(new ConvertSource(path, frame), options, new ImageDecoder([wic]), Target(options), cancellationToken: context.Cancellation)); Assert.Equal(ConversionFailure.EightBit, refused.Reason); } var jpeg = new ConvertOptions(ConvertTarget.Jpeg); FrameConverter.Convert(new ConvertSource(path, frame), jpeg, new ImageDecoder([wic]), Target(jpeg), cancellationToken: context.Cancellation); Assert.Equal(1, wic.Calls); } /// A RAW developed above white and outside sRGB converts to a linear DNG that reads back the same. [Test] public void ALinearDngKeepsWhatTheRawHasAboveWhiteAndOutsideSrgb() { var path = Path.Combine(context.CreateTempDirectory("source"), "IMG_0001.CR2"); using (var image = Scene(40, 30)) File.WriteAllBytes(path, JpegEncoder.Encode(image)); var developed = Scene(40, 30); (developed[0, 1, 1], developed[1, 1, 1], developed[2, 1, 1]) = (2.4f, 1.9f, 1.2f); (developed[0, 2, 1], developed[1, 2, 1], developed[2, 2, 1]) = (-0.2f, 1.0f, -0.07f); var options = new ConvertOptions(ConvertTarget.LinearDng); var file = FrameConverter.Convert(new ConvertSource(path, Frame("IMG_0001.CR2", ImageFileFormat.Cr2, 40, 30)), options, new ImageDecoder([new Developed(developed)]), Target(options), cancellationToken: context.Cancellation); using var back = Assert.NotNull(DecoderFactory.CreateServer().Decode(new DecodeRequest(file.Path, AllowPreview: false))); for (var c = 0; c < 3; c++) { for (var i = 0; i < developed.PlaneLength; i++) Assert.Approximately(developed.Plane(c)[i], back.Pixels.Plane(c)[i], 3e-4); } developed.Dispose(); } /// /// The colour space the original's values are in is kept: a JPEG or TIFF carries its ICC profile (or the Adobe RGB one /// its Exif names) with the values unchanged; a linear DNG gets the values converted through the profile. /// [Test] public void TheOriginalsColourSpaceIsKept() { var folder = context.CreateTempDirectory("source"); var p3 = IccProfile.DisplayP3; using var scene = ColorFixtures.Scene(); var jpegPath = Path.Combine(folder, "p3.jpg"); File.WriteAllBytes(jpegPath, ColorFixtures.Jpeg(scene, p3.Data, ExifWriter.BuildTiff(Camera))); var source = new ConvertSource(jpegPath, Frame("p3.jpg", ImageFileFormat.Jpeg, 48, 32)); var server = DecoderFactory.CreateServer(); using var original = server.Decode(new DecodeRequest(jpegPath, AllowPreview: false))!; foreach (var target in (ConvertTarget[])[ConvertTarget.Jpeg, ConvertTarget.Tiff16]) { var options = new ConvertOptions(target); var file = FrameConverter.Convert(source, options, server, Target(options), cancellationToken: context.Cancellation); Assert.BytesEqual(p3.Data, SourceColor.Read(file.Path, file.Format).Profile!.Data); using var converted = server.Decode(new DecodeRequest(file.Path, AllowPreview: false))!; var error = 0.0; for (var c = 0; c < 3; c++) { for (var i = 0; i < scene.PlaneLength; i++) error += Math.Abs(original.Pixels.Plane(c)[i] - converted.Pixels.Plane(c)[i]); } Assert.Less(error / (3.0 * scene.PlaneLength), target == ConvertTarget.Jpeg ? 0.02 : 1e-3, $"the values of {target} pass unchanged"); } var dng = new ConvertOptions(ConvertTarget.LinearDng); var linear = FrameConverter.Convert(source, dng, server, Target(dng), cancellationToken: context.Cancellation); using var developed = server.Decode(new DecodeRequest(linear.Path, AllowPreview: false))!; var matrix = p3.ToLinearRec709(); for (var i = 0; i < scene.PlaneLength; i += 7) { var code = new Vector3D( p3.Curves![0].Evaluate(ColorSpace.LinearToSrgb(original.Pixels.Plane(0)[i])), p3.Curves[1].Evaluate(ColorSpace.LinearToSrgb(original.Pixels.Plane(1)[i])), p3.Curves[2].Evaluate(ColorSpace.LinearToSrgb(original.Pixels.Plane(2)[i]))); var expected = matrix * code; Assert.Approximately(expected.X, developed.Pixels.Plane(0)[i], 5e-4); Assert.Approximately(expected.Y, developed.Pixels.Plane(1)[i], 5e-4); Assert.Approximately(expected.Z, developed.Pixels.Plane(2)[i], 5e-4); } // The P3 green patch is outside sRGB: its red is negative in the DNG, not clipped to 0. Assert.Less(developed.Pixels[0, 2, 2], -0.05); // A camera JPEG in Adobe RGB (Exif uncalibrated, Interop R03) carries the Adobe RGB profile; a PNG its iCCP. var adobePath = Path.Combine(folder, "adobe.jpg"); File.WriteAllBytes(adobePath, ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(0xFFFF, "R03"))); var jpeg = new ConvertOptions(ConvertTarget.Jpeg); var adobe = FrameConverter.Convert(new ConvertSource(adobePath, Frame("adobe.jpg", ImageFileFormat.Jpeg, 48, 32)), jpeg, server, Target(jpeg), cancellationToken: context.Cancellation); Assert.Equal("Compatible with Adobe RGB (1998)", SourceColor.Read(adobe.Path, adobe.Format).Profile!.Description); var pngPath = Path.Combine(folder, "p3.png"); File.WriteAllBytes(pngPath, ColorFixtures.Png(scene, p3.Data)); var tiff = new ConvertOptions(ConvertTarget.Tiff16); var fromPng = FrameConverter.Convert(new ConvertSource(pngPath, Frame("p3.png", ImageFileFormat.Png, 48, 32)), tiff, server, Target(tiff), cancellationToken: context.Cancellation); Assert.BytesEqual(p3.Data, SourceColor.Read(fromPng.Path, fromPng.Format).Profile!.Data); } /// A colour space nothing here can keep (uncalibrated without R03, a CMYK profile) refuses the photo, whatever the target. [Test] public void APhotoWhoseColourSpaceCannotBeKeptIsRefused() { var folder = context.CreateTempDirectory("source"); using var scene = ColorFixtures.Scene(); var unknown = Path.Combine(folder, "unknown.jpg"); File.WriteAllBytes(unknown, ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(0xFFFF))); var cmyk = Path.Combine(folder, "cmyk.jpg"); File.WriteAllBytes(cmyk, ColorFixtures.Jpeg(scene, ColorFixtures.Cmyk())); foreach (var target in Enum.GetValues()) { var options = new ConvertOptions(target); foreach (var path in (string[])[unknown, cmyk]) { var output = Target(options); var refused = Assert.Throws(() => FrameConverter.Convert(new ConvertSource(path, Frame(Path.GetFileName(path), ImageFileFormat.Jpeg, 48, 32)), options, DecoderFactory.CreateServer(), output, cancellationToken: context.Cancellation)); Assert.Equal(ConversionFailure.ColorProfile, refused.Reason); Assert.FileMissing(output); } } } /// A photo larger than the target or one buffer holds fails as too large, not with the encoder's own exception. [Test] public void APhotoTooLargeForTheTargetFailsAsTooLarge() { var path = Path.Combine(context.CreateTempDirectory("source"), "panorama.png"); using (var image = Scene(8, 8)) File.WriteAllBytes(path, PngEncoder.Encode(image)); var frame = Frame("panorama.png", ImageFileFormat.Png, 70_000, 1); var jpeg = new ConvertOptions(ConvertTarget.Jpeg); using var wide = new ImageBuffer(65_536, 1); var refused = Assert.Throws(() => FrameConverter.Convert(new ConvertSource(path, frame), jpeg, new ImageDecoder([new Developed(wide, ImageFileFormat.Png)]), Target(jpeg), cancellationToken: context.Cancellation)); Assert.Equal(ConversionFailure.TooLarge, refused.Reason); var overflow = Assert.Throws(() => FrameConverter.Convert(new ConvertSource(path, frame), new ConvertOptions(ConvertTarget.Tiff16), new ImageDecoder([new Overflowing()]), Target(jpeg), cancellationToken: context.Cancellation)); Assert.Equal(ConversionFailure.TooLarge, overflow.Reason); } /// Why a photo failed reads as one sentence by cause in the job log, never the exception's English text. [Test] public void FailuresReadAsOneSentenceByCause() { foreach (var reason in Enum.GetValues()) { var text = FrameConverter.FailureText(new ConversionException(reason, "technical detail")); Assert.Equal(Loc.L("Archive.Convert.Failed." + reason), text); Assert.NotNull(Loc.Get("Archive.Convert.Failed." + reason, CultureInfo.GetCultureInfo("it"))); Assert.False(text.Contains("technical", StringComparison.Ordinal), text); } Assert.Equal(Loc.L("Archive.Convert.Failed.Full"), FrameConverter.FailureText(new IOException("full", unchecked((int)0x80070070)))); Assert.Equal(Loc.L("Archive.Failed.Access"), FrameConverter.FailureText(new UnauthorizedAccessException("denied"))); Assert.Equal(Loc.L("Archive.Convert.Failed.Unreadable"), FrameConverter.FailureText(new InvalidDataException("JPEG: bad Huffman"))); Assert.Equal(Loc.L("Archive.Failed.Files"), FrameConverter.FailureText(new IOException("network"))); Assert.Equal(Loc.L("Archive.Convert.Failed.Other"), FrameConverter.FailureText(new ArgumentOutOfRangeException("width"))); } /// WIC with the Raw Image Extension, as a conversion sees it: every RAW native, developed at 8 bits (counted). private sealed class EightBitRaw : IImageDecoderProvider { private readonly ManagedDecoderProvider _managed = new(); public int Calls { get; private set; } public string Name => "wic"; public bool DevelopsRawAt8Bits => true; public DecodeTier? TierFor(ImageFileFormat format) => ImageFormatInfo.Of(format).IsRaw ? DecodeTier.Native : null; public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) { Calls++; var decoded = _managed.Decode(request, cancellationToken)!; foreach (ref var v in decoded.Pixels.Data) v = ColorSpace.Linear8(ColorSpace.Encode8(v)); return new DecodedImage(decoded.Pixels, DecodeTier.Native, Name, decoded.SourceWidth, decoded.SourceHeight); } } /// A RAW decoder that develops every file of into a copy of . private sealed class Developed(ImageBuffer image, ImageFileFormat format = ImageFileFormat.Cr2) : IImageDecoderProvider { public string Name => "developed"; public DecodeTier? TierFor(ImageFileFormat f) => f == format ? DecodeTier.Native : null; public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) => new(image.Clone(), DecodeTier.Native, Name, image.Width, image.Height); } /// A decoder whose image is too large for one buffer. private sealed class Overflowing : IImageDecoderProvider { public string Name => "overflowing"; public DecodeTier? TierFor(ImageFileFormat format) => DecodeTier.Native; public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) => throw new OverflowException(); } /// 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); } } }