fix(imaging): record decode tiers per frame and keep undecodable frames out of renders

BRIEF §8.2 tiers 2 and 3 had no writer: PreviewOnly and Undecodable were never set,
so the advisor could not cap the output at the preview size and one unreadable frame
failed a whole render.

- ImageDecoder.Probe names a file's tier without decoding it (JPEG, PNG and TIFF
  without opening the file); the light analysis probes frames whose tier is unknown,
  and the deep analysis, renders from originals and thumbnail/proxy passes record
  what decoding actually found (FrameTiers). Sidecar frames gain "tier", "previewW"
  and "previewH"; the index gains frames.preview_width/height and
  sequences.preview_only_count (migration 0005, SQLite and PostgreSQL).
- SequenceContext takes the preview size from preview-only frames, so the advisor's
  output cap applies; the light analysis reports format tiers (preview-only frames as
  information, undecodable ones as a warning under the deep analysis' key, listed
  once); a sequence that gains undecodable frames warns at once.
- Only a file in a format the host decodes natively is flagged undecodable; files
  beyond the host's decoders keep their tier without the flag, so render nodes and
  proxies can still supply them.
- A frame that stops decoding during a render is replaced by its nearest planned
  neighbour and logged instead of failing the job; the render fails only when no
  planned frame decodes.
- The Library card shows a preview-only chip with the count (local and server
  sequences: SequenceDto.PreviewOnlyCount, FrameDto preview size).
- GoPro GPR decodes through the JPEG the camera writes beside it when that is larger
  than the embedded preview (BRIEF §8.1).
- Thumbnails use a stored embedded preview only when it reaches 320 px; a smaller one
  sends the frame through the host's decoders instead (BRIEF §8.5).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-12 09:58:36 +00:00
1 parent 61d913baa9
commit 4d321a84b0
48 files changed
+1132 -87

No files matched your search

@@ -5,6 +5,8 @@ using Titano.Core.Codecs.Tiff;
using Titano.Core.Imaging;
using Titano.Core.Imaging.Decoders;
using Titano.Core.Metadata;
using Titano.Core.Metadata.Tiff;
using Titano.Core.Tests.Metadata.Builders;
using Titano.Core.Tests.Raw;
using Titano.Testing;
using static Titano.Core.Tests.Raw.NativeRawWriters;
@@ -201,6 +203,76 @@ public sealed class ManagedDecoderProviderTests(TestContext context)
}
}
[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);
}
[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);
}
/// <summary>A GoPro GPR as far as Titano reads it: a DNG made by "GoPro" whose only decodable image is a YCbCr JPEG preview.</summary>
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);
}
/// <summary>A Windows-like provider claiming native support for everything but declining every file.</summary>
private sealed class FakeProvider : IImageDecoderProvider
{