WicDecoderProvider decodes through a pull chain (decoder, Fant scaler to MaxLongEdge, format converter) read in bounded row bands. Integer sources are requested as 64bppRGBA and linearised with the exact sRGB EOTF (Linear16); float/fixed sources as 128bppRGBAFloat (scRGB, already linear). The Exif orientation (photo policy, then raw IFD queries) is applied while de-interleaving instead of through IWICBitmapFlipRotator, which Microsoft documents as quadratic over scanline decoders. CodecInventory enumerates installed decoders (CreateComponentEnumerator), probes HEVC/AV1 decoders with MFTEnumEx and identifies the Raw Image Extension by package family, since it shares the in-box RAW codec's CLSID. It maps every ImageFileFormat to its decoder, native flag and the Store extensions (product ids, ms-windows-store links) that would unlock it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
146 lines
7.3 KiB
C#
146 lines
7.3 KiB
C#
using Titano.Core.Imaging;
|
|
using Titano.Core.Windows.Codecs;
|
|
using Titano.Core.Windows.Wic;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.Core.Windows.Tests.Codecs;
|
|
|
|
public sealed class CodecInventoryTests
|
|
{
|
|
private static readonly WicDecoderInfo Jpeg = Decoder("JPEG Decoder", Guid.NewGuid(), WicGuids.VendorMicrosoftBuiltIn, ".jpeg,.jpe,.jpg,.jfif,.exif");
|
|
private static readonly WicDecoderInfo InBoxDng = Decoder("DNG Decoder", Guid.NewGuid(), WicGuids.VendorMicrosoftBuiltIn, ".dng");
|
|
private static readonly WicDecoderInfo Raw = Decoder("Microsoft Raw Image Decoder", WicGuids.RawDecoder, WicGuids.VendorMicrosoft, ".arw,.cr2,.cr3,.dng,.nef,.raf");
|
|
private static readonly WicDecoderInfo Heif = Decoder("HEIF Decoder", WicGuids.HeifDecoder, WicGuids.VendorMicrosoft, ".heic,.heif,.hif");
|
|
private static readonly WicDecoderInfo Webp = Decoder("WebP Decoder", WicGuids.WebpDecoder, WicGuids.VendorMicrosoft, ".webp");
|
|
|
|
[Test]
|
|
[WindowsOnly]
|
|
public void DetectFindsTheBuiltInDecoders()
|
|
{
|
|
var inventory = CodecInventory.Detect();
|
|
Assert.NotEmpty(inventory.Decoders);
|
|
foreach (var format in new[] { ImageFileFormat.Jpeg, ImageFileFormat.Png, ImageFileFormat.Tiff })
|
|
{
|
|
var support = inventory.For(format);
|
|
Assert.True(support.IsNative, $"{format} should decode natively through WIC");
|
|
var decoder = Assert.NotNull(support.Decoder);
|
|
Assert.False(string.IsNullOrWhiteSpace(decoder.FriendlyName), $"{format} decoder has no name");
|
|
Assert.NotEqual(Guid.Empty, decoder.ContainerFormat);
|
|
Assert.Empty(support.MissingExtensions);
|
|
}
|
|
Assert.Equal(ImageFormatInfo.Known.Count, inventory.Formats.Count);
|
|
}
|
|
|
|
[Test]
|
|
public void RawNeedsTheRawImageExtension()
|
|
{
|
|
var inventory = Inventory([Jpeg, InBoxDng, Classified(Raw, rawExtensionInstalled: false)]);
|
|
var dng = inventory.For(ImageFileFormat.Dng);
|
|
Assert.False(dng.IsNative);
|
|
Assert.Equal<string?>("DNG Decoder", dng.Decoder?.FriendlyName);
|
|
Assert.SequenceEqual([StoreExtension.Get(StoreExtensionKind.RawImage)], dng.MissingExtensions);
|
|
Assert.False(inventory.IsNative(ImageFileFormat.Cr3));
|
|
Assert.Contains(StoreExtension.Get(StoreExtensionKind.RawImage), inventory.MissingExtensions);
|
|
}
|
|
|
|
[Test]
|
|
public void RawIsNativeThroughTheExtension()
|
|
{
|
|
var inventory = Inventory([Jpeg, InBoxDng, Classified(Raw, rawExtensionInstalled: true)]);
|
|
Assert.True(inventory.IsNative(ImageFileFormat.Dng));
|
|
Assert.Equal<StoreExtensionKind?>(StoreExtensionKind.RawImage, inventory.For(ImageFileFormat.Dng).Decoder?.Extension);
|
|
Assert.True(inventory.IsNative(ImageFileFormat.Cr3));
|
|
// Installed but without this extension registered: nothing to install, still not native.
|
|
var gpr = inventory.For(ImageFileFormat.Gpr);
|
|
Assert.False(gpr.IsNative);
|
|
Assert.Empty(gpr.MissingExtensions);
|
|
}
|
|
|
|
[Test]
|
|
public void HeifNeedsAnHevcDecoder()
|
|
{
|
|
var withoutHevc = Inventory([Jpeg, Classified(Heif)]).For(ImageFileFormat.Heif);
|
|
Assert.False(withoutHevc.IsNative);
|
|
Assert.SequenceEqual([StoreExtension.Get(StoreExtensionKind.HevcVideo)], withoutHevc.MissingExtensions);
|
|
|
|
Assert.True(Inventory([Jpeg, Classified(Heif)], hevc: true).IsNative(ImageFileFormat.Heif));
|
|
|
|
var nothing = Inventory([Jpeg]).For(ImageFileFormat.Heif);
|
|
Assert.SequenceEqual(
|
|
[StoreExtension.Get(StoreExtensionKind.HeifImage), StoreExtension.Get(StoreExtensionKind.HevcVideo)],
|
|
nothing.MissingExtensions);
|
|
}
|
|
|
|
[Test]
|
|
public void AvifUsesTheHeifDecoderWithAnAv1Decoder()
|
|
{
|
|
var withoutAv1 = Inventory([Classified(Heif)], hevc: true).For(ImageFileFormat.Avif);
|
|
Assert.False(withoutAv1.IsNative);
|
|
Assert.Equal<string?>("HEIF Decoder", withoutAv1.Decoder?.FriendlyName);
|
|
Assert.SequenceEqual([StoreExtension.Get(StoreExtensionKind.Av1Video)], withoutAv1.MissingExtensions);
|
|
|
|
Assert.True(Inventory([Classified(Heif)], av1: true).IsNative(ImageFileFormat.Avif));
|
|
}
|
|
|
|
[Test]
|
|
public void WebpNeedsTheWebpExtension()
|
|
{
|
|
Assert.SequenceEqual([StoreExtension.Get(StoreExtensionKind.WebpImage)], Inventory([Jpeg]).For(ImageFileFormat.WebP).MissingExtensions);
|
|
Assert.True(Inventory([Jpeg, Classified(Webp)]).IsNative(ImageFileFormat.WebP));
|
|
}
|
|
|
|
[Test]
|
|
public void BuiltInFormatsNeverAskForExtensions()
|
|
{
|
|
var inventory = Inventory([Jpeg]);
|
|
Assert.True(inventory.IsNative(ImageFileFormat.Jpeg));
|
|
Assert.False(inventory.IsNative(ImageFileFormat.Png));
|
|
Assert.Empty(inventory.For(ImageFileFormat.Png).MissingExtensions);
|
|
Assert.False(inventory.IsNative(ImageFileFormat.Unknown));
|
|
}
|
|
|
|
[Test]
|
|
public void ClassificationUsesClsidPackageAndVendor()
|
|
{
|
|
Assert.Null(CodecInventory.Classify(Raw, rawExtensionInstalled: false));
|
|
Assert.Equal<StoreExtensionKind?>(StoreExtensionKind.RawImage, CodecInventory.Classify(Raw, rawExtensionInstalled: true));
|
|
Assert.Equal<StoreExtensionKind?>(StoreExtensionKind.HeifImage, CodecInventory.Classify(Heif, false));
|
|
Assert.Equal<StoreExtensionKind?>(StoreExtensionKind.WebpImage, CodecInventory.Classify(Webp, false));
|
|
var avif = Decoder("AVIF Decoder", Guid.NewGuid(), WicGuids.VendorMicrosoft, ".avif");
|
|
Assert.Equal<StoreExtensionKind?>(StoreExtensionKind.Av1Video, CodecInventory.Classify(avif, false));
|
|
var thirdParty = Decoder("Other AVIF", Guid.NewGuid(), Guid.NewGuid(), ".avif");
|
|
Assert.Null(CodecInventory.Classify(thirdParty, false));
|
|
Assert.Null(CodecInventory.Classify(Jpeg, false));
|
|
}
|
|
|
|
[Test]
|
|
public void StoreLinksUseTheProductIds()
|
|
{
|
|
Assert.Equal(5, StoreExtension.All.Count);
|
|
var raw = StoreExtension.Get(StoreExtensionKind.RawImage);
|
|
Assert.Equal("ms-windows-store://pdp/?ProductId=9NCTDW2W1BH8", raw.StoreUri.AbsoluteUri);
|
|
Assert.Equal("https://apps.microsoft.com/detail/9nctdw2w1bh8", raw.WebUri.AbsoluteUri);
|
|
Assert.Equal("9PMMSR1CGPWG", StoreExtension.Get(StoreExtensionKind.HeifImage).ProductId);
|
|
Assert.Equal("9NMZLZ57R3T7", StoreExtension.Get(StoreExtensionKind.HevcVideo).ProductId);
|
|
Assert.Equal("9MVZQVXJBQ9V", StoreExtension.Get(StoreExtensionKind.Av1Video).ProductId);
|
|
Assert.Equal("9PG2DK419DRG", StoreExtension.Get(StoreExtensionKind.WebpImage).ProductId);
|
|
}
|
|
|
|
[Test]
|
|
public void ExtensionListsAreNormalised()
|
|
{
|
|
Assert.SequenceEqual(["jpg", "jpeg", "jfif"], WicDecoderInfo.ParseExtensions(".JPG, .jpeg;.jfif,,.jpg"));
|
|
Assert.True(Jpeg.Handles(".JPG"));
|
|
Assert.True(Jpeg.Handles("jfif"));
|
|
Assert.False(Jpeg.Handles("png"));
|
|
}
|
|
|
|
private static CodecInventory Inventory(WicDecoderInfo[] decoders, bool hevc = false, bool av1 = false) => new(decoders, hevc, av1);
|
|
|
|
private static WicDecoderInfo Classified(WicDecoderInfo decoder, bool rawExtensionInstalled = false) =>
|
|
decoder with { Extension = CodecInventory.Classify(decoder, rawExtensionInstalled) };
|
|
|
|
private static WicDecoderInfo Decoder(string name, Guid clsid, Guid vendor, string extensions) =>
|
|
new(name, clsid, Guid.NewGuid(), vendor, "1.0", WicDecoderInfo.ParseExtensions(extensions), null);
|
|
}
|