using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Codecs.Png; using Chronos.Core.Codecs.Raw; using Chronos.Core.Codecs.Tiff; using Chronos.Core.Imaging; using Chronos.Core.Imaging.Decoders; using Chronos.Core.Metadata; using Chronos.Core.Metadata.Tiff; using Chronos.Core.Tests.Metadata.Builders; using Chronos.Core.Tests.Raw; using Chronos.Testing; using static Chronos.Core.Tests.Raw.NativeRawWriters; namespace Chronos.Core.Tests.Decoding; /// Tier selection (native → embedded preview → unavailable), decoder chains and fast paths. public sealed class ManagedDecoderProviderTests(TestContext context) { private const int W = 96, H = 64; private readonly string _dir = context.CreateTempDirectory(); private string Write(string name, byte[] data) { var path = Path.Combine(_dir, name); File.WriteAllBytes(path, data); return path; } private static byte[] Cr2File(string model, int orientation = 1) { using var scene = SyntheticRaw.Smooth(W, H); var active = new RawRect(24, 4, 24 + W, 4 + H); return Cr2(Sensor(scene, "Canon EOS 5D Mark III", CfaPattern.Bayer("RGGB"), 128, 72, active.Left, active.Top, 2048, 16383), active, orientation, model); } private static byte[] JpegFile(int width, int height, int orientation) { using var image = SyntheticRaw.Smooth(width, height); var exif = ExifWriter.BuildTiff(new FrameMetadata { Make = "TestCam", Model = "T1", Orientation = orientation }); return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [[.. "Exif\0\0"u8, .. exif]] }); } [Test] public void ServerFormatTableReportsTiers() { var rows = DecoderFactory.DescribeFormats(DecoderFactory.CreateServer()).ToDictionary(r => r.Format.Format); foreach (var f in new[] { ImageFileFormat.Jpeg, ImageFileFormat.Png, ImageFileFormat.Tiff, ImageFileFormat.Dng, ImageFileFormat.Cr2, ImageFileFormat.Nef, ImageFileFormat.Arw, ImageFileFormat.Pef, ImageFileFormat.Raf }) { Assert.Equal(DecodeTier.Native, rows[f].Tier); Assert.Equal("managed", rows[f].Provider); } foreach (var f in new[] { ImageFileFormat.Cr3, ImageFileFormat.Orf, ImageFileFormat.Rw2, ImageFileFormat.Heif }) Assert.Equal(DecodeTier.EmbeddedPreview, rows[f].Tier); foreach (var f in new[] { ImageFileFormat.WebP, ImageFileFormat.JpegXl, ImageFileFormat.Gif }) { Assert.Equal(DecodeTier.Unavailable, rows[f].Tier); Assert.Null(rows[f].Provider); } } [Test] public void ClientChainPrefersTheWindowsProvider() { var wic = new FakeProvider(); var decoder = DecoderFactory.CreateClient(wic); Assert.Equal(2, decoder.Providers.Count); var rows = DecoderFactory.DescribeFormats(decoder).ToDictionary(r => r.Format.Format); Assert.Equal("fake", rows[ImageFileFormat.Cr3].Provider); Assert.Equal(DecodeTier.Native, rows[ImageFileFormat.Cr3].Tier); Assert.Equal("fake", rows[ImageFileFormat.Jpeg].Provider); Assert.Equal("managed", rows[ImageFileFormat.Dng].Provider); // The Windows provider declines this file: the managed provider decodes it. var path = Write("a.jpg", JpegFile(64, 48, 1)); using var image = decoder.Decode(new DecodeRequest(path)); Assert.Equal(1, wic.Calls); Assert.Equal("managed-jpeg", image!.Decoder); Assert.Count(1, DecoderFactory.CreateClient(null).Providers); } [Test] public void SupportedRawDecodesNatively() { var path = Write("IMG_1.CR2", Cr2File("Canon EOS 5D Mark III")); var provider = new ManagedDecoderProvider(); Assert.Equal(DecodeTier.Native, provider.Probe(path).Tier); using var image = DecoderFactory.CreateServer().Decode(new DecodeRequest(path)); Assert.Equal(DecodeTier.Native, image!.Tier); Assert.Equal("managed-cr2", image.Decoder); Assert.Equal(W, image.Pixels.Width); Assert.Equal(W, image.SourceWidth); } [Test] public void UnsupportedBodyFallsBackToTheOrientedPreview() { var path = Write("IMG_2.CR2", Cr2File("Canon EOS R99", orientation: 6)); var probe = new ManagedDecoderProvider().Probe(path); Assert.Equal(DecodeTier.EmbeddedPreview, probe.Tier); Assert.Contains("no colour matrix", probe.Reason); using var image = DecoderFactory.CreateServer().Decode(new DecodeRequest(path)); Assert.Equal(DecodeTier.EmbeddedPreview, image!.Tier); Assert.Equal("managed-preview", image.Decoder); // The 64×48 preview is rotated by the RAW's orientation (6). Assert.Equal(48, image.Pixels.Width); Assert.Equal(64, image.Pixels.Height); Assert.Equal(48, image.SourceWidth); Assert.Null(DecoderFactory.CreateServer().Decode(new DecodeRequest(path, AllowPreview: false))); } [Test] public void ForcePreviewSkipsNativeDevelopment() { var path = Write("IMG_3.CR2", Cr2File("Canon EOS 5D Mark III")); using var image = DecoderFactory.CreateServer().Decode(new DecodeRequest(path, ForcePreview: true)); Assert.Equal(DecodeTier.EmbeddedPreview, image!.Tier); Assert.Equal(64, image.Pixels.Width); } [Test] public void FilesWithoutDecoderOrPreviewAreUnavailable() { // A NEF whose body has no matrix and no preview, and a WebP. using var scene = SyntheticRaw.Smooth(W, H); var nef = Nef(Sensor(scene, "Nikon D850", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 600, 16383), 14, NefEncoding.Lossless); var text = System.Text.Encoding.Latin1.GetString(nef).Replace("NIKON D850", "NIKON Z99X"); var path = Write("DSC_9.NEF", System.Text.Encoding.Latin1.GetBytes(text)); Assert.Equal(DecodeTier.Unavailable, new ManagedDecoderProvider().Probe(path).Tier); Assert.Null(DecoderFactory.CreateServer().Decode(new DecodeRequest(path))); var webp = Write("x.webp", Metadata.Builders.Fixtures.WebP()); Assert.Null(DecoderFactory.CreateServer().Decode(new DecodeRequest(webp))); Assert.Equal(DecodeTier.Unavailable, new ManagedDecoderProvider().Probe(webp).Tier); } [Test] public void JpegUsesDctScalingAndOrientation() { var path = Write("big.jpg", JpegFile(1600, 1200, 6)); using var small = DecoderFactory.CreateServer().Decode(new DecodeRequest(path, MaxLongEdge: 300)); Assert.Equal(225, small!.Pixels.Width); Assert.Equal(300, small.Pixels.Height); Assert.Equal(1200, small.SourceWidth); Assert.Equal(1600, small.SourceHeight); using var stored = DecoderFactory.CreateServer().Decode(new DecodeRequest(path, MaxLongEdge: 300, ApplyOrientation: false)); Assert.Equal(300, stored!.Pixels.Width); Assert.Equal(3, stored.Pixels.Channels); } [Test] public void RawFastPathsBinAndFit() { using var scene = SyntheticRaw.Smooth(W, H); var path = Write("f.dng", SyntheticDng.Write(scene, new DngSpec())); using var thumb = DecoderFactory.CreateServer().Decode(new DecodeRequest(path, MaxLongEdge: 40, Purpose: DecodePurpose.Thumbnail)); Assert.Equal(40, thumb!.Pixels.Width); Assert.Equal(27, thumb.Pixels.Height); Assert.Equal(W, thumb.SourceWidth); using var expected = Resampler.Resize(scene, 40, 27, ResampleFilter.Box); Assert.GreaterOrEqual(SyntheticRaw.Psnr(expected, thumb.Pixels, 1), 35); } [Test] public void PngAndTiffDecodeToRgb() { using var gray = new ImageBuffer(20, 10, 1); gray.Plane(0).Fill(0.25f); var png = Write("g.png", PngEncoder.Encode(gray)); using var p = DecoderFactory.CreateServer().Decode(new DecodeRequest(png)); Assert.Equal(3, p!.Pixels.Channels); Assert.Approximately(0.25, p.Pixels[2, 5, 5], 0.01); var tif = Write("g.tif", TiffWriter.Write(gray)); using var t = DecoderFactory.CreateServer().Decode(new DecodeRequest(tif, MaxLongEdge: 10)); Assert.Equal(3, t!.Pixels.Channels); Assert.Equal(10, t.Pixels.Width); Assert.Equal("managed-tiff", t.Decoder); } [Test] public void CorruptedRawFilesOnlyRaiseInvalidDataOrReturnNull() { var file = Cr2File("Canon EOS 5D Mark III"); var provider = new ManagedDecoderProvider(); var random = new Random(17); for (var i = 0; i < 60; i++) { var variant = i < 20 ? file[..(file.Length * i / 20)] : (byte[])file.Clone(); if (i >= 20) { for (var k = 0; k < 3; k++) variant[random.Next(variant.Length)] = (byte)random.Next(256); } var path = Write($"fuzz{i}.cr2", variant); try { provider.Probe(path); using var image = provider.Decode(new DecodeRequest(path, MaxLongEdge: i % 2 == 0 ? 0 : 32, Purpose: DecodePurpose.Thumbnail)); } catch (InvalidDataException) { } catch (Exception ex) { Assert.Fail($"variant {i}: {ex.GetType().Name}: {ex.Message}\n{ex.StackTrace}"); } } } [Test] public void TheChainProbesEachFileForItsTier() { var server = DecoderFactory.CreateServer(); // JPEG, PNG and TIFF decode natively whatever they hold: the probe does not even open them. Assert.Equal(DecodeTier.Native, server.Probe(Path.Combine(_dir, "absent.jpg"), ImageFileFormat.Jpeg).Tier); var supported = server.Probe(Write("IMG_5.CR2", Cr2File("Canon EOS 5D Mark III")), ImageFileFormat.Cr2); Assert.Equal((DecodeTier.Native, "managed-cr2"), (supported.Tier, supported.Decoder)); // An unsupported body decodes only through its 64×48 preview, rotated like the main image (orientation 6). var preview = server.Probe(Write("IMG_6.CR2", Cr2File("Canon EOS R99", orientation: 6)), ImageFileFormat.Cr2); Assert.Equal((DecodeTier.EmbeddedPreview, 48, 64), (preview.Tier, preview.Width, preview.Height)); Assert.Contains("no colour matrix", preview.Reason); using var scene = SyntheticRaw.Smooth(W, H); var nef = Nef(Sensor(scene, "Nikon D850", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 600, 16383), 14, NefEncoding.Lossless); var unknownBody = System.Text.Encoding.Latin1.GetBytes(System.Text.Encoding.Latin1.GetString(nef).Replace("NIKON D850", "NIKON Z99X")); var none = server.Probe(Write("DSC_7.NEF", unknownBody), ImageFileFormat.Nef); Assert.Equal(DecodeTier.Unavailable, none.Tier); Assert.Contains("no embedded preview", none.Reason); // A Windows-like provider native for CR3 answers from its codec list, before the managed preview tier. var client = DecoderFactory.CreateClient(new FakeProvider()); var cr3 = client.Probe(Path.Combine(_dir, "absent.cr3"), ImageFileFormat.Cr3); Assert.Equal((DecodeTier.Native, "fake"), (cr3.Tier, cr3.Decoder)); Assert.Equal(DecodeTier.Unavailable, client.Probe(Write("y.webp", Fixtures.WebP()), ImageFileFormat.WebP).Tier); } /// /// A provider that reads headers (a conversion's) finds a JPEG, PNG or TIFF native, at its oriented size, only when its /// decoder takes what the headers describe; the others probe as before. Damage past the headers shows only when decoding. /// [Test] public void HeaderProbesSayWhatTheDecodersTake() { var headers = new ManagedDecoderProvider { ReadsHeaders = true }; using var scene = SyntheticRaw.Smooth(W, H); var jpeg = headers.Probe(Write("portrait.jpg", JpegFile(W, H, 6)), ImageFileFormat.Jpeg); Assert.Equal((DecodeTier.Native, "managed-jpeg", H, W), (jpeg.Tier, jpeg.Decoder, jpeg.Width, jpeg.Height)); var png = headers.Probe(Write("a.png", PngEncoder.Encode(scene)), ImageFileFormat.Png); Assert.Equal((DecodeTier.Native, "managed-png", W, H), (png.Tier, png.Decoder, png.Width, png.Height)); var tiff = headers.Probe(Write("a.tif", TiffWriter.Write(scene)), ImageFileFormat.Tiff); Assert.Equal((DecodeTier.Native, "managed-tiff", W, H), (tiff.Tier, tiff.Decoder, tiff.Width, tiff.Height)); Assert.Equal(DecodeTier.Native, headers.Probe(Write("IMG_5.CR2", Cr2File("Canon EOS 5D Mark III")), ImageFileFormat.Cr2).Tier); // Headers alone: what follows them is not read. var header = headers.Probe(Write("header.jpg", Conversion.ColorFixtures.JpegHeader(4_000, 3_000)), ImageFileFormat.Jpeg); Assert.Equal((DecodeTier.Native, 4_000, 3_000), (header.Tier, header.Width, header.Height)); // A CMYK TIFF, a JPEG cut before its first scan, a file that is not what its format says, an arithmetic-coded JPEG, // and a JPEG, PNG or TIFF larger than its decoder takes: refused, like a decode. var cmyk = Write("cmyk.tif", Conversion.ColorFixtures.Tiff(6, 4, 5, [0, 255, 255, 0])); Assert.Throws(() => headers.Probe(cmyk, ImageFileFormat.Tiff)); Assert.Throws(() => headers.Probe(Write("cut.jpg", JpegFile(W, H, 1)[..200]), ImageFileFormat.Jpeg)); Assert.Throws(() => headers.Probe(Write("short.png", [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]), ImageFileFormat.Png)); Assert.Throws(() => headers.Probe(Write("arithmetic.jpg", Conversion.ColorFixtures.JpegHeader(6, 4, sof: 0xC9)), ImageFileFormat.Jpeg)); Assert.Throws(() => headers.Probe(Write("huge.jpg", Conversion.ColorFixtures.JpegHeader(16_384, 16_385)), ImageFileFormat.Jpeg)); Assert.Throws(() => headers.Probe(Write("huge.png", Conversion.ColorFixtures.PngHeader(16_384, 16_385)), ImageFileFormat.Png)); Assert.Throws(() => headers.Probe(Write("huge.tif", Conversion.ColorFixtures.TiffHeader(13_377, 13_378)), ImageFileFormat.Tiff)); // Through a chain: unavailable with the decoder's reason; a provider without header reads still finds it native. var chain = new ImageDecoder([headers]).Probe(cmyk, ImageFileFormat.Tiff); Assert.Equal(DecodeTier.Unavailable, chain.Tier); Assert.Contains("photometric 5", chain.Reason); Assert.Equal(DecodeTier.Native, new ManagedDecoderProvider().Probe(cmyk, ImageFileFormat.Tiff).Tier); Assert.Throws(() => new ManagedDecoderProvider().Decode(new DecodeRequest(cmyk))); } [Test] public void GoProRawDecodesThroughTheJpegBesideIt() { var gpr = Write("GOPR0001.GPR", Gpr(previewWidth: 64, previewHeight: 48)); var server = DecoderFactory.CreateServer(); // Alone, a GPR (VC-5, out of scope) shows its embedded preview. using (var alone = server.Decode(new DecodeRequest(gpr))) Assert.Equal(("managed-preview", 64), (alone!.Decoder, alone.Pixels.Width)); Write("GOPR0001.JPG", JpegFile(160, 120, 1)); using (var withJpeg = server.Decode(new DecodeRequest(gpr))) { Assert.Equal((DecodeTier.EmbeddedPreview, "managed-sidecar"), (withJpeg!.Tier, withJpeg.Decoder)); Assert.Equal((160, 120, 160, 120), (withJpeg.Pixels.Width, withJpeg.Pixels.Height, withJpeg.SourceWidth, withJpeg.SourceHeight)); } using (var scaled = server.Decode(new DecodeRequest(gpr, MaxLongEdge: 40, Purpose: DecodePurpose.Thumbnail))) Assert.Equal(40, scaled!.Pixels.Width); var probe = new ManagedDecoderProvider().Probe(gpr); Assert.Equal((DecodeTier.EmbeddedPreview, "managed-sidecar", 160, 120), (probe.Tier, probe.Decoder, probe.Width, probe.Height)); // A companion smaller than the embedded preview is not the better source. var big = Write("GOPR0002.GPR", Gpr(previewWidth: 320, previewHeight: 240)); Write("GOPR0002.JPG", JpegFile(160, 120, 1)); using (var preview = server.Decode(new DecodeRequest(big))) Assert.Equal(("managed-preview", 320), (preview!.Decoder, preview.Pixels.Width)); Assert.Equal("managed-preview", new ManagedDecoderProvider().Probe(big).Decoder); } [Test] public void GoProRawDecodesThroughItsJpegWhereTheImportKeptIt() { // An import splits sessions per format: the JPEG lives in another sequence folder, under its imported name. var gpr = Write("GOPR0003.GPR", Gpr(previewWidth: 64, previewHeight: 48)); var elsewhere = Path.Combine(context.CreateTempDirectory("jpeg-sequence"), "2026-09-28_0003.JPG"); File.WriteAllBytes(elsewhere, JpegFile(160, 120, 1)); var server = DecoderFactory.CreateServer(); using (var decoded = server.Decode(new DecodeRequest(gpr, Companion: elsewhere))) Assert.Equal(("managed-sidecar", 160, 120), (decoded!.Decoder, decoded.SourceWidth, decoded.SourceHeight)); var probe = server.Probe(gpr, ImageFileFormat.Gpr, elsewhere); Assert.Equal((DecodeTier.EmbeddedPreview, "managed-sidecar", 160, 120), (probe.Tier, probe.Decoder, probe.Width, probe.Height)); // A JPEG that is gone (deleted since) leaves the embedded preview; other formats ignore the companion. var gone = Path.Combine(_dir, "gone.JPG"); using (var preview = server.Decode(new DecodeRequest(gpr, Companion: gone))) Assert.Equal(("managed-preview", 64), (preview!.Decoder, preview.Pixels.Width)); Assert.Equal("managed-preview", server.Probe(gpr, ImageFileFormat.Gpr, gone).Decoder); var jpeg = Write("plain.jpg", JpegFile(64, 48, 1)); using (var plain = server.Decode(new DecodeRequest(jpeg, Companion: elsewhere))) Assert.Equal(("managed-jpeg", 64), (plain!.Decoder, plain.SourceWidth)); } [Test] public void AFileNoProviderCouldReadIsAReadErrorNotAnUndecodableFile() { var path = Write("locked.jpg", JpegFile(64, 48, 1)); // Every provider failed to read the file (locked by another program, a network read failed): nothing is known // about its content, so the caller gets the read error instead of "nothing decodes it". var unreadable = new ImageDecoder([new ScriptedProvider("a", _ => throw new IOException("sharing violation"))]); Assert.Throws(() => unreadable.Decode(new DecodeRequest(path))); // One provider read it and found nothing, another could not read it: still unproven. var mixed = new ImageDecoder([new ScriptedProvider("a", _ => null), new ScriptedProvider("b", _ => throw new IOException("short read"))]); Assert.Throws(() => mixed.Decode(new DecodeRequest(path))); // A provider that produces pixels wins over one that could not read the file. var recovered = new ImageDecoder([new ScriptedProvider("a", _ => throw new IOException("busy")), new ManagedDecoderProvider()]); using (var image = recovered.Decode(new DecodeRequest(path))) Assert.Equal("managed-jpeg", image!.Decoder); // Providers that read the file and found it malformed prove it undecodable. var damaged = new ImageDecoder([new ScriptedProvider("a", _ => throw new InvalidDataException("bad marker"))]); Assert.Null(damaged.Decode(new DecodeRequest(path))); Assert.Null(DecoderFactory.CreateServer().Decode(new DecodeRequest(Write("garbage.jpg", new byte[3000])))); Assert.Throws(() => DecoderFactory.CreateServer().Decode(new DecodeRequest(Path.Combine(_dir, "vanished.jpg")))); } /// /// The owner's archive (R4, owner review 1): GoPro DNGs converted by Lightroom or DNG Converter carry a full-size JPEG /// preview in IFD0 and a lossless or lossy raw image in a SubIFD. They are DNGs, developed natively; only a VC-5 raw /// image (or the .gpr extension) makes a GPR. /// [Test] public void AGoProDngIsGprOnlyWhenItsRawImageIsVc5() { using var scene = SyntheticRaw.Smooth(W, H); var converted = Write("GOPR0100.dng", SyntheticDng.Write(scene, new DngSpec { Make = "GoPro", RawInSubIfd = true, PreviewJpeg = JpegFile(W, H, 1) })); Assert.Equal(ImageFileFormat.Dng, Signature(converted)); using (var decoded = DecoderFactory.CreateServer().Decode(new DecodeRequest(converted))) Assert.Equal((DecodeTier.Native, "managed-dng"), (decoded!.Tier, decoded.Decoder)); var vc5 = new IfdSpec().Long(TiffTags.NewSubfileType, 0).Long(TiffTags.ImageWidth, 64).Long(TiffTags.ImageLength, 48) .Short(TiffTags.BitsPerSample, 16).Short(TiffTags.Compression, 9).Short(TiffTags.PhotometricInterpretation, 32803); var gpr = Write("GOPR0101.dng", TiffFile.Build(Fixtures.Ifd0("GoPro", "HERO8 Black", 1).Bytes(TiffTags.DngVersion, 1, 4, 0, 0).Child(TiffTags.SubIfds, vc5))); Assert.Equal(ImageFileFormat.Gpr, Signature(gpr)); var renamed = Write("GOPR0102.GPR", File.ReadAllBytes(converted)); Assert.Equal(ImageFileFormat.Gpr, Signature(renamed)); } private static ImageFileFormat Signature(string path) { using var stream = File.OpenRead(path); return ImageSignature.Detect(stream, path); } [Test] public void APreferredPreviewIsTakenByChoiceOnlyWhenItIsLargeEnough() { using var scene = SyntheticRaw.Smooth(W, H); var dng = Write("preview.dng", SyntheticDng.Write(scene, new DngSpec { RawInSubIfd = true, PreviewJpeg = JpegFile(W, H, 1) })); var server = DecoderFactory.CreateServer(); // Analysis size within the preview: the preview, marked as taken by choice (the frame still decodes natively). using (var quick = server.Decode(new DecodeRequest(dng, MaxLongEdge: 48, Purpose: DecodePurpose.Analysis, PreferPreview: true))) { Assert.Equal((DecodeTier.EmbeddedPreview, "managed-preview", true), (quick!.Tier, quick.Decoder, quick.ByChoice)); Assert.Equal(48, quick.Pixels.Width); } // Larger than the preview, or no size limit: developed. using (var native = server.Decode(new DecodeRequest(dng, MaxLongEdge: 4 * W, Purpose: DecodePurpose.Analysis, PreferPreview: true))) Assert.Equal((DecodeTier.Native, "managed-dng", false), (native!.Tier, native.Decoder, native.ByChoice)); using (var whole = server.Decode(new DecodeRequest(dng, PreferPreview: true))) Assert.Equal((DecodeTier.Native, false), (whole!.Tier, whole.ByChoice)); // Renders never prefer the preview. using (var render = server.Decode(new DecodeRequest(dng, MaxLongEdge: 48))) Assert.Equal((DecodeTier.Native, "managed-dng", false), (render!.Tier, render.Decoder, render.ByChoice)); } /// A GoPro GPR as far as Chronos reads it: a DNG made by "GoPro" whose only decodable image is a YCbCr JPEG preview. private static byte[] Gpr(int previewWidth, int previewHeight) { var preview = new IfdSpec().Long(TiffTags.NewSubfileType, 1) .Long(TiffTags.ImageWidth, (uint)previewWidth).Long(TiffTags.ImageLength, (uint)previewHeight) .Short(TiffTags.BitsPerSample, 8, 8, 8).Short(TiffTags.Compression, 7) .Short(TiffTags.PhotometricInterpretation, 6).Strip(JpegFile(previewWidth, previewHeight, 1)); var ifd0 = Fixtures.Ifd0("GoPro", "HERO8 Black", 1) .Bytes(TiffTags.DngVersion, 1, 4, 0, 0) .Child(TiffTags.SubIfds, preview); return TiffFile.Build(ifd0); } /// A Windows-like provider claiming native support for everything but declining every file. private sealed class FakeProvider : IImageDecoderProvider { public int Calls { get; private set; } public string Name => "fake"; public DecodeTier? TierFor(ImageFileFormat format) => format is ImageFileFormat.Jpeg or ImageFileFormat.Cr3 ? DecodeTier.Native : null; public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) { Calls++; return null; } } /// A JPEG provider whose decode does what the test says (return nothing, or throw). private sealed class ScriptedProvider(string name, Func decode) : IImageDecoderProvider { public string Name => name; public DecodeTier? TierFor(ImageFileFormat format) => format == ImageFileFormat.Jpeg ? DecodeTier.Native : null; public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) => decode(request); } }