diff --git a/src/Titano.Core/Codecs/Raw/RawDecoder.cs b/src/Titano.Core/Codecs/Raw/RawDecoder.cs
index 51094fb1..5f2848d3 100644
--- a/src/Titano.Core/Codecs/Raw/RawDecoder.cs
+++ b/src/Titano.Core/Codecs/Raw/RawDecoder.cs
@@ -21,9 +21,10 @@ public sealed record RawDecodeOptions
public DemosaicQuality Quality { get; init; } = DemosaicQuality.Best;
- /// Bin CFA blocks into RGB pixels instead of demosaicing: half size for Bayer, one third for X-Trans.
- /// Ignored for linear (already demosaiced) data and for patterns that cannot be binned.
- public bool Binning { get; init; }
+ /// Target long edge (0 = full size). When the CFA can be binned (half size for Bayer, one third for X-Trans)
+ /// and the binned image keeps at least this long edge, blocks are binned into RGB pixels instead of demosaiced. The
+ /// result is not resized further; linear (already demosaiced) data is always developed at full size.
+ public int MaxLongEdge { get; init; }
/// Rotate/flip according to the file's orientation.
public bool ApplyOrientation { get; init; } = true;
diff --git a/src/Titano.Core/Codecs/Raw/RawDeveloper.cs b/src/Titano.Core/Codecs/Raw/RawDeveloper.cs
index fcd185a1..0b106121 100644
--- a/src/Titano.Core/Codecs/Raw/RawDeveloper.cs
+++ b/src/Titano.Core/Codecs/Raw/RawDeveloper.cs
@@ -87,7 +87,8 @@ internal static class RawDeveloper
if (stage.Cfa is { } cfa)
{
ScaleMosaic(stage.Pixels, cfa, wb, dop, cancellationToken);
- var bin = options.Binning ? cfa.BinSize : 0;
+ var bin = cfa.BinSize;
+ if (options.MaxLongEdge <= 0 || int.Max(stage.Width, stage.Height) / int.Max(bin, 1) < options.MaxLongEdge) bin = 0;
if (bin > 0)
{
rgb = Demosaic.Bin(stage.Pixels, cfa, bin, dop, cancellationToken);
diff --git a/src/Titano.Core/Imaging/Decoders/DecoderFactory.cs b/src/Titano.Core/Imaging/Decoders/DecoderFactory.cs
new file mode 100644
index 00000000..78a0cfaa
--- /dev/null
+++ b/src/Titano.Core/Imaging/Decoders/DecoderFactory.cs
@@ -0,0 +1,45 @@
+namespace Titano.Core.Imaging.Decoders;
+
+/// One row of the "Settings › Formats" table: the best tier a decoder chain reaches for a format, and who
+/// delivers it.
+/// Format with its family and extensions.
+/// Best tier across the chain's providers.
+/// Name of the provider delivering that tier ("wic", "managed"), null when unavailable.
+public sealed record FormatSupport(ImageFormatInfo Format, DecodeTier Tier, string? Provider);
+
+///
+/// Builds the decoder chains of BRIEF §8.2. The desktop client tries the Windows provider (WIC) first and the managed
+/// one second ( keeps that order among providers offering the same tier); the server and
+/// render nodes without WIC use the managed provider alone.
+///
+public static class DecoderFactory
+{
+ /// Client chain: (WIC on Windows; null elsewhere) then managed.
+ public static ImageDecoder CreateClient(IImageDecoderProvider? windowsProvider) =>
+ new(windowsProvider is null ? [new ManagedDecoderProvider()] : [windowsProvider, new ManagedDecoderProvider()]);
+
+ /// Server chain: managed decoders only.
+ public static ImageDecoder CreateServer() => new([new ManagedDecoderProvider()]);
+
+ /// Per-format tier on this machine for every known format, in order.
+ public static IReadOnlyList DescribeFormats(ImageDecoder decoder)
+ {
+ ArgumentNullException.ThrowIfNull(decoder);
+ var rows = new List();
+ foreach (var info in ImageFormatInfo.Known)
+ {
+ var tier = DecodeTier.Unavailable;
+ string? provider = null;
+ foreach (var p in decoder.Providers)
+ {
+ if (p.TierFor(info.Format) is { } t && t < tier)
+ {
+ tier = t;
+ provider = p.Name;
+ }
+ }
+ rows.Add(new FormatSupport(info, tier, provider));
+ }
+ return rows;
+ }
+}
diff --git a/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs b/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs
new file mode 100644
index 00000000..2021371f
--- /dev/null
+++ b/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs
@@ -0,0 +1,221 @@
+using Titano.Core.Codecs.Jpeg;
+using Titano.Core.Codecs.Png;
+using Titano.Core.Codecs.Raw;
+using Titano.Core.Codecs.Tiff;
+using Titano.Core.Diagnostics;
+using Titano.Core.Metadata;
+
+namespace Titano.Core.Imaging.Decoders;
+
+/// Tier a provider would use for one specific file, with the reason when it is not native.
+/// Format detected from the file's signature (extension only breaks ties).
+/// Best tier available for this file.
+/// Decoder that would produce it ("managed-cr2", "managed-preview"…), null when unavailable.
+/// Why the native tier is not used (unsupported body or encoding), else null.
+public sealed record FileTier(ImageFileFormat Format, DecodeTier Tier, string? Decoder, string? Reason);
+
+///
+/// The managed decoder (BRIEF §8.2), available on every platform and the only one on the server: JPEG, PNG and TIFF
+/// natively; DNG and the supported camera RAWs (CR2, NEF, ARW, PEF, RAF) through ; every other
+/// RAW, CR3 and HEIF through the largest suitable embedded JPEG preview; nothing for formats without either.
+/// fast paths: JPEG DCT scaling and RAW CFA binning when
+/// allows, bilinear demosaicing for thumbnails and analysis, and to skip native
+/// RAW development. Results fit within MaxLongEdge (never upscaled) and are always RGB.
+///
+public sealed class ManagedDecoderProvider : IImageDecoderProvider
+{
+ private const string LogCategory = "Decode";
+ private const int FileBufferSize = 1 << 16;
+ private const long MaxPreviewBytes = 256L << 20;
+
+ public string Name => "managed";
+
+ public DecodeTier? TierFor(ImageFileFormat format)
+ {
+ var info = ImageFormatInfo.Of(format);
+ if (format is ImageFileFormat.Jpeg or ImageFileFormat.Png or ImageFileFormat.Tiff || RawDecoder.Formats.Contains(format)) return DecodeTier.Native;
+ return info.Family is ImageFamily.CameraRaw or ImageFamily.Heif ? DecodeTier.EmbeddedPreview : null;
+ }
+
+ /// Decodes the file, or returns null when it has no decodable pixels here (no native decoder and no preview).
+ /// A JPEG, PNG or TIFF is malformed.
+ /// The file cannot be read.
+ public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default)
+ {
+ ArgumentNullException.ThrowIfNull(request);
+ cancellationToken.ThrowIfCancellationRequested();
+ using var stream = Open(request.Path);
+ var format = ImageSignature.Detect(stream, request.Path);
+ var family = ImageFormatInfo.Of(format).Family;
+ var result = family switch
+ {
+ ImageFamily.Jpeg => request.ForcePreview && Preview(stream, request, adequateOnly: true, cancellationToken) is { } p ? p : Jpeg(stream, request),
+ ImageFamily.Png => Png(stream, request),
+ ImageFamily.Tiff => Tiff(stream, request),
+ ImageFamily.Dng or ImageFamily.CameraRaw => Raw(stream, format, request, cancellationToken),
+ ImageFamily.Heif => request.AllowPreview || request.ForcePreview ? Preview(stream, request, adequateOnly: false, cancellationToken) : null,
+ _ => null,
+ };
+ Log.Debug(LogCategory, $"{Path.GetFileName(request.Path)}: {(result is null ? "unavailable" : $"{result.Tier} via {result.Decoder}")}");
+ return result;
+ }
+
+ /// The tier this provider would use for the file at , without decoding pixels.
+ public FileTier Probe(string path)
+ {
+ using var stream = Open(path);
+ var format = ImageSignature.Detect(stream, path);
+ var family = ImageFormatInfo.Of(format).Family;
+ switch (family)
+ {
+ case ImageFamily.Jpeg:
+ return new FileTier(format, DecodeTier.Native, "managed-jpeg", null);
+ case ImageFamily.Png:
+ return new FileTier(format, DecodeTier.Native, "managed-png", null);
+ case ImageFamily.Tiff:
+ return new FileTier(format, DecodeTier.Native, "managed-tiff", null);
+ }
+ string? reason = null;
+ if (family is ImageFamily.Dng or ImageFamily.CameraRaw && RawDecoder.Formats.Contains(format))
+ {
+ var probe = RawDecoder.Probe(stream, path);
+ if (probe.IsSupported) return new FileTier(format, DecodeTier.Native, probe.Info!.Decoder, null);
+ reason = probe.Reason;
+ }
+ else if (family is ImageFamily.Dng or ImageFamily.CameraRaw or ImageFamily.Heif)
+ {
+ reason = $"no managed decoder for {format}";
+ }
+ else
+ {
+ return new FileTier(format, DecodeTier.Unavailable, null, $"no managed decoder for {format}");
+ }
+ var previews = MetadataReader.Read(stream, path).Previews;
+ return previews.Count > 0
+ ? new FileTier(format, DecodeTier.EmbeddedPreview, "managed-preview", reason)
+ : new FileTier(format, DecodeTier.Unavailable, null, reason + "; no embedded preview");
+ }
+
+ private static FileStream Open(string path) =>
+ new(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, FileBufferSize, FileOptions.RandomAccess);
+
+ private static DecodedImage Jpeg(Stream stream, DecodeRequest request)
+ {
+ var data = ReadAll(stream);
+ var info = JpegDecoder.ReadInfo(data);
+ var image = JpegDecoder.DecodeToLinear(data, new JpegDecodeOptions { MaxLongEdge = request.MaxLongEdge }, expandGray: true);
+ var orientation = request.ApplyOrientation ? MetadataReader.Read(stream, request.Path).Orientation : 1;
+ return Finish(image, orientation, request, info.Width, info.Height, DecodeTier.Native, "managed-jpeg");
+ }
+
+ private static DecodedImage Png(Stream stream, DecodeRequest request)
+ {
+ var data = ReadAll(stream);
+ var image = PngDecoder.DecodeToLinear(data, expandGray: true);
+ var orientation = request.ApplyOrientation ? MetadataReader.Read(stream, request.Path).Orientation : 1;
+ return Finish(image, orientation, request, image.Width, image.Height, DecodeTier.Native, "managed-png");
+ }
+
+ private static DecodedImage Tiff(Stream stream, DecodeRequest request)
+ {
+ var decoded = TiffImageReader.Decode(stream);
+ var image = decoded;
+ if (decoded.Channels == 1)
+ {
+ image = PixelConvert.GrayToRgb(decoded);
+ decoded.Dispose();
+ }
+ var orientation = request.ApplyOrientation ? MetadataReader.Read(stream, request.Path).Orientation : 1;
+ return Finish(image, orientation, request, image.Width, image.Height, DecodeTier.Native, "managed-tiff");
+ }
+
+ private static DecodedImage? Raw(Stream stream, ImageFileFormat format, DecodeRequest request, CancellationToken cancellationToken)
+ {
+ if (!request.ForcePreview && RawDecoder.Formats.Contains(format))
+ {
+ try
+ {
+ var options = new RawDecodeOptions
+ {
+ Quality = request.Purpose is DecodePurpose.Thumbnail or DecodePurpose.Analysis ? DemosaicQuality.Draft : DemosaicQuality.Best,
+ MaxLongEdge = request.MaxLongEdge,
+ ApplyOrientation = request.ApplyOrientation,
+ };
+ var raw = RawDecoder.Decode(stream, request.Path, options, cancellationToken);
+ foreach (var warning in raw.Warnings) Log.Debug(LogCategory, $"{Path.GetFileName(request.Path)}: {warning}");
+ return Finish(raw.Image, 1, request, raw.Info.Width, raw.Info.Height, DecodeTier.Native, raw.Info.Decoder, oriented: true);
+ }
+ catch (InvalidDataException ex) when (request.AllowPreview)
+ {
+ Log.Debug(LogCategory, $"{Path.GetFileName(request.Path)}: native decode unavailable ({ex.Message}); trying the embedded preview");
+ }
+ }
+ return request.AllowPreview || request.ForcePreview ? Preview(stream, request, adequateOnly: false, cancellationToken) : null;
+ }
+
+ /// Embedded-preview tier: the smallest preview whose long edge still reaches MaxLongEdge (the largest when none
+ /// does or no limit is set; null then if ), decoded with DCT scaling and oriented like the
+ /// main image.
+ private static DecodedImage? Preview(Stream stream, DecodeRequest request, bool adequateOnly, CancellationToken cancellationToken)
+ {
+ var metadata = MetadataReader.Read(stream, request.Path, cancellationToken: cancellationToken);
+ if (metadata.Previews.Count == 0) return null;
+ EmbeddedPreview? adequate = null;
+ foreach (var p in metadata.Previews)
+ {
+ if (request.MaxLongEdge > 0 && int.Max(p.Width, p.Height) >= request.MaxLongEdge) adequate = p;
+ }
+ if (adequate is null && adequateOnly) return null;
+ var preview = adequate ?? metadata.Previews[0];
+ if (preview.Length > MaxPreviewBytes || preview.Offset < 0 || preview.Offset > stream.Length - preview.Length)
+ throw new InvalidDataException("Preview: embedded JPEG outside the file");
+ var data = new byte[preview.Length];
+ stream.Position = preview.Offset;
+ stream.ReadExactly(data);
+ var image = JpegDecoder.DecodeToLinear(data, new JpegDecodeOptions { MaxLongEdge = request.MaxLongEdge }, expandGray: true);
+ var orientation = request.ApplyOrientation ? metadata.Orientation : 1;
+ return Finish(image, orientation, request, preview.Width, preview.Height, DecodeTier.EmbeddedPreview, "managed-preview");
+ }
+
+ /// Applies orientation, fits within MaxLongEdge, and wraps the result (takes ownership of ).
+ private static DecodedImage Finish(ImageBuffer image, int orientation, DecodeRequest request, int sourceWidth, int sourceHeight, DecodeTier tier, string decoder, bool oriented = false)
+ {
+ var current = image;
+ try
+ {
+ if (orientation is >= 2 and <= 8)
+ {
+ var rotated = PixelConvert.ApplyOrientation(current, orientation);
+ current.Dispose();
+ current = rotated;
+ }
+ if (!oriented) (sourceWidth, sourceHeight) = PixelConvert.OrientedSize(sourceWidth, sourceHeight, orientation);
+ if (request.MaxLongEdge > 0)
+ {
+ var (w, h) = Resampler.FitWithin(current.Width, current.Height, request.MaxLongEdge);
+ if (w != current.Width || h != current.Height)
+ {
+ var filter = request.Purpose == DecodePurpose.Thumbnail ? ResampleFilter.Box : ResampleFilter.Auto;
+ var resized = Resampler.Resize(current, w, h, filter);
+ current.Dispose();
+ current = resized;
+ }
+ }
+ return new DecodedImage(current, tier, decoder, sourceWidth, sourceHeight);
+ }
+ catch
+ {
+ current.Dispose();
+ throw;
+ }
+ }
+
+ private static byte[] ReadAll(Stream stream)
+ {
+ if (stream.Length > int.MaxValue) throw new InvalidDataException("Image file too large");
+ var data = new byte[stream.Length];
+ stream.Position = 0;
+ stream.ReadExactly(data);
+ return data;
+ }
+}
diff --git a/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs b/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs
new file mode 100644
index 00000000..bcbc861e
--- /dev/null
+++ b/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs
@@ -0,0 +1,217 @@
+using Titano.Core.Codecs.Jpeg;
+using Titano.Core.Codecs.Png;
+using Titano.Core.Codecs.Raw;
+using Titano.Core.Codecs.Tiff;
+using Titano.Core.Imaging;
+using Titano.Core.Imaging.Decoders;
+using Titano.Core.Metadata;
+using Titano.Core.Tests.Raw;
+using Titano.Testing;
+using static Titano.Core.Tests.Raw.NativeRawWriters;
+
+namespace Titano.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}");
+ }
+ }
+ }
+
+ /// 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;
+ }
+ }
+}
diff --git a/tests/Titano.Core.Tests/Raw/DngDecoderTests.cs b/tests/Titano.Core.Tests/Raw/DngDecoderTests.cs
index d0a47334..463093c6 100644
--- a/tests/Titano.Core.Tests/Raw/DngDecoderTests.cs
+++ b/tests/Titano.Core.Tests/Raw/DngDecoderTests.cs
@@ -183,7 +183,7 @@ public sealed class DngDecoderTests(TestContext context)
public void BinningHalvesTheSize(DemosaicQuality quality)
{
using var scene = SyntheticRaw.Smooth(W, H);
- using var result = Decode(SyntheticDng.Write(scene, new DngSpec()), new RawDecodeOptions { Binning = true, Quality = quality });
+ using var result = Decode(SyntheticDng.Write(scene, new DngSpec()), new RawDecodeOptions { MaxLongEdge = W / 2, Quality = quality });
Assert.Equal(W / 2, result.Image.Width);
Assert.Equal(H / 2, result.Image.Height);
using var expected = Resampler.Resize(scene, W / 2, H / 2, ResampleFilter.Box);
diff --git a/tests/Titano.Core.Tests/Raw/HighlightTests.cs b/tests/Titano.Core.Tests/Raw/HighlightTests.cs
index eb142ba6..1f10dbfd 100644
--- a/tests/Titano.Core.Tests/Raw/HighlightTests.cs
+++ b/tests/Titano.Core.Tests/Raw/HighlightTests.cs
@@ -31,7 +31,7 @@ public sealed class HighlightTests(TestContext context)
{
using var scene = Patches();
var dng = SyntheticDng.Write(scene, new DngSpec());
- using var result = RawDecoder.Decode(new MemoryStream(dng), "h.dng", new RawDecodeOptions { Quality = quality, Binning = binning });
+ using var result = RawDecoder.Decode(new MemoryStream(dng), "h.dng", new RawDecodeOptions { Quality = quality, MaxLongEdge = binning ? 1 : 0 });
var s = binning ? 2 : 1;
var (r0, g0, b0) = Pixel(result.Image, 16 / s, 32 / s);
var (r1, g1, b1) = Pixel(result.Image, 48 / s, 32 / s);
diff --git a/tests/Titano.Core.Tests/Raw/NativeRawTests.cs b/tests/Titano.Core.Tests/Raw/NativeRawTests.cs
index 6166181a..5dd8fae1 100644
--- a/tests/Titano.Core.Tests/Raw/NativeRawTests.cs
+++ b/tests/Titano.Core.Tests/Raw/NativeRawTests.cs
@@ -114,7 +114,7 @@ public sealed class NativeRawTests(TestContext context)
Assert.Equal("managed-raf", result.Info.Decoder);
Assert.Equal("X-T2", result.Info.Model);
AssertScene(scene, result.Image, xtrans ? 34 : 38, context);
- using var binned = Decode(Raf(sensor, Expand(rasterCfa), crop), "DSCF0001.RAF", new RawDecodeOptions { Binning = true });
+ using var binned = Decode(Raf(sensor, Expand(rasterCfa), crop), "DSCF0001.RAF", new RawDecodeOptions { MaxLongEdge = 1 });
Assert.Equal(W / (xtrans ? 3 : 2), binned.Image.Width);
}
diff --git a/tests/Titano.Core.Tests/Raw/RawPerformanceTests.cs b/tests/Titano.Core.Tests/Raw/RawPerformanceTests.cs
index 0d2048ac..dee7cbda 100644
--- a/tests/Titano.Core.Tests/Raw/RawPerformanceTests.cs
+++ b/tests/Titano.Core.Tests/Raw/RawPerformanceTests.cs
@@ -25,7 +25,7 @@ public sealed class RawPerformanceTests(TestContext context)
var dng = Mosaic();
var ahd = Best(dng, RawDecodeOptions.Default, out var size);
Assert.Equal(W, size.Width);
- var half = Best(dng, new RawDecodeOptions { Quality = DemosaicQuality.Draft, Binning = true }, out var halfSize);
+ var half = Best(dng, new RawDecodeOptions { Quality = DemosaicQuality.Draft, MaxLongEdge = W / 2 }, out var halfSize);
Assert.Equal(W / 2, halfSize.Width);
context.Log($"24 MP DNG: AHD full size {ahd.TotalMilliseconds:F0} ms, binned half size {half.TotalMilliseconds:F0} ms ({Environment.ProcessorCount} cores)");
Console.WriteLine($"[perf] {context.LogText.Trim()}");