feat(raw): native CR2, NEF, ARW, PEF and RAF decoders
Each container reader builds a RawFrame for the shared pipeline: CR2 sliced lossless JPEG with SensorInfo crop, masked-column black and ColorData WB; NEF uncompressed and Nikon Huffman (lossy type 1, lossless, lossy type 2 incl. split); ARW uncompressed and ARW2 cRAW with tone curve; PEF uncompressed and Pentax Huffman; RAF uncompressed Bayer and X-Trans with FujiIFD. Colour comes from a dcraw adobe_coeff matrix table; bodies without an entry are reported unsupported so the caller uses the embedded preview. Native RAWs detect the sensor's saturation level for clipping only, never rescaling per frame. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
14 files changed
+1974
-24
No files matched your search
@@ -37,6 +37,7 @@ internal static class DngReader
|
||||
var photometric = r.GetUInt(raw, TiffTags.PhotometricInterpretation);
|
||||
var compression = r.GetUInt(raw, TiffTags.Compression) ?? 1;
|
||||
if (compression is not (1 or 7 or 8 or 34892)) throw new InvalidDataException($"DNG: compression {compression} is not supported");
|
||||
if (compression is 1 or 7) RequirePayload(r, raw, (long)width * height * spp);
|
||||
var floating = (r.GetUInt(raw, TiffTags.SampleFormat) ?? 1) == 3;
|
||||
var bits = (int)(r.GetUInt(raw, TiffTags.BitsPerSample) ?? 16);
|
||||
|
||||
@@ -86,6 +87,16 @@ internal static class DngReader
|
||||
return frame;
|
||||
}
|
||||
|
||||
/// <summary>Uncompressed and lossless-JPEG data hold at least one bit per sample; checked before the raster is allocated
|
||||
/// so a corrupted size cannot trigger a huge allocation.</summary>
|
||||
private static void RequirePayload(TiffReader r, Ifd raw, long samples)
|
||||
{
|
||||
var counts = r.GetUInts(raw, raw.Has(TiffTags.TileByteCounts) ? TiffTags.TileByteCounts : TiffTags.StripByteCounts);
|
||||
long total = 0;
|
||||
foreach (var c in counts ?? []) total += c;
|
||||
if (total * 8 < samples) throw new InvalidDataException("DNG: image data too short for the raster");
|
||||
}
|
||||
|
||||
/// <summary>First IFD with NewSubfileType 0 and a CFA/LinearRaw photometric: IFD0, its SubIFDs (two levels), the chain.</summary>
|
||||
private static Ifd? FindRawIfd(TiffReader r, IReadOnlyList<Ifd> chain)
|
||||
{
|
||||
|
||||
@@ -0,0 +1,136 @@
|
||||
using System.Buffers.Binary;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Codecs.Raw;
|
||||
|
||||
/// <summary>
|
||||
/// Sony ARW: the CFA SubIFD holds uncompressed 16-bit words (or packed samples) or ARW2 "cRAW" (Compression 32767 with
|
||||
/// one byte per pixel): 16-pixel blocks of one colour storing an 11-bit maximum and minimum with their positions and
|
||||
/// fourteen 7-bit deltas scaled by a shift, expanded through the tone curve of tag 0x7010 (dcraw
|
||||
/// <c>sony_arw2_load_raw</c>). Black and white come from tags 0x7310/0x787F when present (14-bit scale), otherwise
|
||||
/// 512 and the curve's top (cRAW) or 16383. As-shot white balance sits in the encrypted SR2 block, which is not read: ARW files develop with daylight
|
||||
/// balance. ARW1 (DSLR-A100) and the lossless ARW 5.0 codec are not supported.
|
||||
/// </summary>
|
||||
internal static class ArwReader
|
||||
{
|
||||
private const uint CompressionSony = 32767;
|
||||
private const ushort ToneCurveTag = 0x7010;
|
||||
private const ushort BlackLevelTag = 0x7310;
|
||||
private const ushort WhiteLevelTag = 0x787F;
|
||||
|
||||
public static RawFrame Read(Stream stream)
|
||||
{
|
||||
var r = TiffReader.Open(stream) ?? throw new InvalidDataException("ARW: missing TIFF header");
|
||||
var chain = r.ReadChain();
|
||||
if (chain.Count == 0) throw new InvalidDataException("ARW: no image directory");
|
||||
var ifd0 = chain[0];
|
||||
var raw = NefReader.FindCfa(r, ifd0) ?? throw new InvalidDataException("ARW: CFA image missing");
|
||||
var (width, height) = NativeRaw.Size(r.GetUInt(raw, TiffTags.ImageWidth) ?? 0, r.GetUInt(raw, TiffTags.ImageLength) ?? 0);
|
||||
var bits = (int)(r.GetUInt(raw, TiffTags.BitsPerSample) ?? 0);
|
||||
var compression = r.GetUInt(raw, TiffTags.Compression) ?? 1;
|
||||
var (offset, length) = NefReader.Strip(r, raw);
|
||||
var warnings = new List<string>();
|
||||
var cfa = NativeRaw.TiffEpCfa(r, raw);
|
||||
if (cfa is null)
|
||||
{
|
||||
cfa = CfaPattern.Bayer("RGGB");
|
||||
warnings.Add("ARW: CFA pattern missing; RGGB assumed");
|
||||
}
|
||||
if (!cfa.IsBayer) throw new InvalidDataException("ARW: only Bayer sensors are supported");
|
||||
|
||||
RawLoader loader;
|
||||
double black, white;
|
||||
if (compression == CompressionSony && length == (long)width * height)
|
||||
{
|
||||
if (width < 32 || width % 32 != 0) throw new InvalidDataException("ARW: cRAW width must be a multiple of 32");
|
||||
var curve = ToneCurve(r, raw, ifd0);
|
||||
loader = new Arw2Loader(offset, width, height, curve);
|
||||
// Sensor saturation is the largest 11-bit code through the curve.
|
||||
(black, white) = (512, curve[0x7FF << 1]);
|
||||
}
|
||||
else if (length >= (long)width * height * 2)
|
||||
{
|
||||
loader = new PlainRawLoader(offset, length, width, height, 16, words: true, littleEndian: r.LittleEndian);
|
||||
(black, white) = (512, 16383);
|
||||
}
|
||||
else if (compression == 1 && bits is 12 or 14 && length >= ((long)width * bits + 7) / 8 * height)
|
||||
{
|
||||
loader = new PlainRawLoader(offset, length, width, height, bits, words: false, littleEndian: false);
|
||||
(black, white) = (128 << (bits - 12), (1 << bits) - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new InvalidDataException($"ARW: compression {compression} with {length} bytes is not supported");
|
||||
}
|
||||
|
||||
var blackLevel = IfdValue.UInts(r, raw, BlackLevelTag) is { Length: 4 } b
|
||||
? NativeRaw.Black2x2(cfa, [b[0], b[1], b[2], b[3]])
|
||||
: NativeRaw.Black(black);
|
||||
if (IfdValue.UInts(r, raw, WhiteLevelTag) is { Length: > 0 } w) white = w.Max();
|
||||
return NativeRaw.Frame("managed-arw", width, height, cfa, new RawRect(0, 0, width, height), blackLevel, white, null,
|
||||
(int)(r.GetUInt(ifd0, TiffTags.Orientation) ?? 1), r.GetString(ifd0, TiffTags.Make), r.GetString(ifd0, TiffTags.Model), loader, warnings);
|
||||
}
|
||||
|
||||
/// <summary>Tone curve from the four breakpoints of tag 0x7010: slopes 1, 2, 4, 8, 16 between 0, the breakpoints and 4095.</summary>
|
||||
private static ushort[] ToneCurve(TiffReader r, Ifd raw, Ifd ifd0)
|
||||
{
|
||||
Span<int> knots = [0, 0, 0, 0, 0, 4095];
|
||||
if ((IfdValue.UInts(r, raw, ToneCurveTag) ?? IfdValue.UInts(r, ifd0, ToneCurveTag)) is { Length: >= 4 } t)
|
||||
{
|
||||
for (var i = 0; i < 4; i++) knots[i + 1] = (int)(t[i] >> 2 & 0xFFF);
|
||||
}
|
||||
var curve = new ushort[0x1000];
|
||||
for (var i = 0; i < curve.Length; i++) curve[i] = (ushort)i;
|
||||
for (var i = 0; i < 5; i++)
|
||||
{
|
||||
for (var j = knots[i] + 1; j <= knots[i + 1] && j < curve.Length; j++) curve[j] = (ushort)(curve[j - 1] + (1 << i));
|
||||
}
|
||||
return curve;
|
||||
}
|
||||
|
||||
private sealed class Arw2Loader(long offset, int width, int height, ushort[] curve) : RawLoader
|
||||
{
|
||||
public override RawSamples Load(Stream stream, int maxDegreeOfParallelism, CancellationToken cancellationToken)
|
||||
{
|
||||
var data = NativeRaw.ReadPayload(stream, offset, (long)width * height);
|
||||
var samples = new ushort[width * height];
|
||||
Parallel.For(0, height, new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism, CancellationToken = cancellationToken }, row =>
|
||||
{
|
||||
// One spare byte: the last delta of a block is read as a 16-bit word that reaches one byte past it.
|
||||
Span<byte> line = stackalloc byte[width + 2];
|
||||
line.Clear();
|
||||
data.AsSpan(row * width, width).CopyTo(line);
|
||||
Span<int> pix = stackalloc int[16];
|
||||
var dst = samples.AsSpan(row * width, width);
|
||||
var dp = 0;
|
||||
for (var col = 0; col < width - 30; dp += 16)
|
||||
{
|
||||
var val = BinaryPrimitives.ReadUInt32LittleEndian(line[dp..]);
|
||||
int max = (int)(val & 0x7FF), min = (int)(val >> 11 & 0x7FF), imax = (int)(val >> 22 & 0xF), imin = (int)(val >> 26 & 0xF);
|
||||
var sh = 0;
|
||||
while (sh < 4 && 0x80 << sh <= max - min) sh++;
|
||||
var bit = 30;
|
||||
for (var i = 0; i < 16; i++)
|
||||
{
|
||||
if (i == imax)
|
||||
{
|
||||
pix[i] = max;
|
||||
}
|
||||
else if (i == imin)
|
||||
{
|
||||
pix[i] = min;
|
||||
}
|
||||
else
|
||||
{
|
||||
pix[i] = int.Min(((BinaryPrimitives.ReadUInt16LittleEndian(line[(dp + (bit >> 3))..]) >> (bit & 7) & 0x7F) << sh) + min, 0x7FF);
|
||||
bit += 7;
|
||||
}
|
||||
}
|
||||
for (var i = 0; i < 16; i++, col += 2) dst[col] = curve[pix[i] << 1];
|
||||
col -= (col & 1) != 0 ? 1 : 31;
|
||||
}
|
||||
});
|
||||
return new RawSamples(width, height, 1, samples, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
using Titano.Core.Mathematics;
|
||||
|
||||
namespace Titano.Core.Codecs.Raw;
|
||||
|
||||
/// <summary>
|
||||
/// Camera colour matrices (XYZ → camera, D65 calibration, values × 10 000) for bodies whose native RAW files Titano
|
||||
/// develops, keyed by the normalised "Brand Model" name. The numbers are the public adobe_coeff table of Dave Coffin's
|
||||
/// dcraw (public-domain origin, also carried by LibRaw), which reproduces the ColorMatrix2 values Adobe DNG Converter
|
||||
/// writes for these cameras; they are data, not code. A body missing here is decoded through its embedded preview.
|
||||
/// </summary>
|
||||
internal static class CameraMatrices
|
||||
{
|
||||
private static readonly Dictionary<string, short[]> Table = Build();
|
||||
|
||||
/// <summary>Matrix for a normalised camera name (see <see cref="NativeRaw.CameraName"/>), or null.</summary>
|
||||
public static Matrix3? Find(string? cameraName)
|
||||
{
|
||||
if (cameraName is null || !Table.TryGetValue(cameraName, out var m)) return null;
|
||||
return new Matrix3(m[0] / 1e4, m[1] / 1e4, m[2] / 1e4, m[3] / 1e4, m[4] / 1e4, m[5] / 1e4, m[6] / 1e4, m[7] / 1e4, m[8] / 1e4);
|
||||
}
|
||||
|
||||
/// <summary>Normalised names with an entry (for diagnostics and tests).</summary>
|
||||
public static IEnumerable<string> Names => Table.Keys;
|
||||
|
||||
private static Dictionary<string, short[]> Build()
|
||||
{
|
||||
var t = new Dictionary<string, short[]>(StringComparer.OrdinalIgnoreCase);
|
||||
void Add(short[] m, params string[] names)
|
||||
{
|
||||
foreach (var n in names) t[n] = m;
|
||||
}
|
||||
|
||||
// Canon (CR2).
|
||||
Add([6347, -479, -972, -8297, 15954, 2480, -1968, 2131, 7649], "Canon EOS 5D");
|
||||
Add([4716, 603, -830, -7798, 15474, 2480, -1496, 1937, 6651], "Canon EOS 5D Mark II");
|
||||
Add([6722, -635, -963, -4287, 12460, 2028, -908, 2162, 5668], "Canon EOS 5D Mark III");
|
||||
Add([6446, -366, -864, -4436, 12204, 2513, -952, 2496, 6348], "Canon EOS 5D Mark IV");
|
||||
Add([6250, -711, -808, -5153, 12794, 2636, -1249, 2198, 5610], "Canon EOS 5DS", "Canon EOS 5DS R");
|
||||
Add([7034, -804, -1014, -4420, 12564, 2058, -851, 1994, 5758], "Canon EOS 6D", "Canon EOS 70D");
|
||||
Add([6875, -970, -932, -4691, 12459, 2501, -874, 1953, 5809], "Canon EOS 6D Mark II");
|
||||
Add([6844, -996, -856, -3876, 11761, 2396, -593, 1772, 6198], "Canon EOS 7D");
|
||||
Add([7268, -1082, -969, -4186, 11839, 2663, -825, 2029, 5839], "Canon EOS 7D Mark II");
|
||||
Add([6071, -747, -856, -7653, 15365, 2441, -2025, 2553, 7315], "Canon EOS 40D");
|
||||
Add([4920, 616, -593, -6493, 13964, 2784, -1774, 3178, 7005], "Canon EOS 50D");
|
||||
Add([6719, -994, -925, -4408, 12426, 2211, -887, 2129, 6051], "Canon EOS 60D");
|
||||
Add([7457, -671, -937, -4849, 12495, 2643, -1213, 2354, 5492], "Canon EOS 80D");
|
||||
Add([6941, -1164, -857, -3825, 11597, 2534, -416, 1540, 6039], "Canon EOS 550D", "Canon EOS Rebel T2i", "Canon EOS Kiss X4");
|
||||
Add([6461, -907, -882, -4300, 12184, 2378, -819, 1944, 5931], "Canon EOS 600D", "Canon EOS Rebel T3i", "Canon EOS Kiss X5",
|
||||
"Canon EOS 1200D", "Canon EOS Rebel T5", "Canon EOS Kiss X70");
|
||||
Add([6602, -841, -939, -4472, 12458, 2247, -975, 2039, 6148], "Canon EOS 650D", "Canon EOS Rebel T4i", "Canon EOS Kiss X6i",
|
||||
"Canon EOS 700D", "Canon EOS Rebel T5i", "Canon EOS Kiss X7i", "Canon EOS 100D", "Canon EOS Rebel SL1", "Canon EOS Kiss X7", "Canon EOS M");
|
||||
Add([6362, -823, -847, -4426, 12109, 2616, -743, 1857, 5635], "Canon EOS 750D", "Canon EOS Rebel T6i", "Canon EOS Kiss X8i",
|
||||
"Canon EOS 760D", "Canon EOS Rebel T6s", "Canon EOS 8000D");
|
||||
Add([7377, -742, -998, -4235, 11981, 2549, -673, 1918, 5538], "Canon EOS 77D", "Canon EOS 9000D", "Canon EOS 800D", "Canon EOS Rebel T7i", "Canon EOS Kiss X9i");
|
||||
Add([6847, -614, -1014, -4669, 12737, 2139, -1197, 2488, 6846], "Canon EOS-1D X");
|
||||
Add([7596, -978, -967, -4808, 12571, 2503, -1398, 2567, 5752], "Canon EOS-1D X Mark II");
|
||||
|
||||
// Nikon (NEF).
|
||||
Add([7309, -1403, -519, -8474, 16008, 2622, -2434, 2826, 8064], "Nikon D90");
|
||||
Add([9030, -1992, -715, -8465, 16302, 2255, -2689, 3217, 8069], "Nikon D300", "Nikon D300S");
|
||||
Add([8139, -2171, -663, -8747, 16541, 2295, -1925, 2008, 8093], "Nikon D3", "Nikon D700");
|
||||
Add([8828, -2406, -694, -4874, 12603, 2541, -660, 1509, 7587], "Nikon D3S");
|
||||
Add([7171, -1986, -648, -8085, 15555, 2718, -2170, 2512, 7457], "Nikon D3X");
|
||||
Add([8598, -2848, -857, -5618, 13606, 2195, -1002, 1773, 7137], "Nikon D4", "Nikon Df");
|
||||
Add([9200, -3522, -992, -5755, 13803, 2117, -753, 1486, 6338], "Nikon D5");
|
||||
Add([7911, -2167, -813, -5327, 13150, 2408, -1288, 2483, 7968], "Nikon D3100");
|
||||
Add([7013, -1408, -635, -5268, 12902, 2640, -1470, 2801, 7379], "Nikon D3200");
|
||||
Add([6988, -1384, -714, -5631, 13410, 2447, -1485, 2204, 7318], "Nikon D3300", "Nikon D3400", "Nikon D5300");
|
||||
Add([8198, -2239, -724, -4871, 12389, 2798, -1043, 2050, 7181], "Nikon D5100", "Nikon D7000");
|
||||
Add([8322, -3112, -1047, -6367, 14342, 2179, -988, 1638, 6394], "Nikon D5200", "Nikon D7100", "Nikon D7200");
|
||||
Add([8821, -2938, -785, -4178, 12142, 2287, -824, 1651, 6860], "Nikon D5500", "Nikon D5600");
|
||||
Add([8813, -3210, -1036, -4703, 12868, 2021, -1054, 1940, 6129], "Nikon D500", "Nikon D7500");
|
||||
Add([8178, -2245, -609, -4857, 12394, 2776, -1207, 2086, 7298], "Nikon D600", "Nikon D610");
|
||||
Add([9020, -2890, -715, -4535, 12436, 2348, -934, 1919, 7086], "Nikon D750");
|
||||
Add([7866, -2108, -555, -4869, 12483, 2681, -1176, 2069, 7501], "Nikon D800", "Nikon D800E");
|
||||
Add([9369, -3195, -791, -4488, 12430, 2301, -893, 1796, 6872], "Nikon D810");
|
||||
Add([10405, -3755, -1270, -5461, 13787, 1793, -1040, 2015, 6785], "Nikon D850", "Nikon Z 7");
|
||||
Add([8210, -2534, -683, -5355, 13338, 2212, -1143, 1929, 6464], "Nikon Z 6");
|
||||
|
||||
// Sony (ARW).
|
||||
Add([5271, -712, -347, -6153, 13653, 2763, -1601, 2366, 7242], "Sony ILCE-7", "Sony ILCE-7M2");
|
||||
Add([7374, -2389, -551, -5435, 13162, 2519, -1006, 1795, 6552], "Sony ILCE-7M3");
|
||||
Add([4913, -541, -202, -6130, 13513, 2906, -1564, 2151, 7183], "Sony ILCE-7R");
|
||||
Add([6629, -1900, -483, -4618, 12349, 2550, -622, 1381, 6514], "Sony ILCE-7RM2");
|
||||
Add([6640, -1847, -503, -5238, 13010, 2474, -993, 1673, 6527], "Sony ILCE-7RM3");
|
||||
Add([5838, -1430, -246, -3497, 11477, 2297, -748, 1885, 5778], "Sony ILCE-7S", "Sony ILCE-7SM2");
|
||||
Add([5991, -1456, -455, -4764, 12135, 2980, -707, 1425, 6701], "Sony ILCE-6000", "Sony ILCE-5100", "Sony SLT-A57");
|
||||
Add([5973, -1695, -419, -3826, 11797, 2293, -639, 1398, 5789], "Sony ILCE-6300", "Sony ILCE-6500", "Sony ILCE-6400");
|
||||
Add([5491, -1192, -363, -4951, 12342, 2948, -911, 1722, 7192], "Sony NEX-7", "Sony SLT-A65", "Sony SLT-A77");
|
||||
Add([8651, -2754, -1057, -3464, 12207, 1373, -568, 1398, 4434], "Sony DSC-RX100");
|
||||
Add([6596, -2079, -562, -4782, 13016, 1933, -970, 1581, 5181], "Sony DSC-RX100M2");
|
||||
|
||||
// Pentax (PEF).
|
||||
Add([9566, -2863, -803, -7170, 15172, 2112, -818, 803, 9705], "Pentax K10D");
|
||||
Add([9427, -2714, -868, -7493, 16092, 1373, -2199, 3264, 7180], "Pentax K20D");
|
||||
Add([9142, -2947, -678, -8648, 16967, 1663, -2224, 2898, 8615], "Pentax K-7");
|
||||
Add([8713, -2833, -743, -4342, 11900, 2772, -722, 1543, 6247], "Pentax K-5");
|
||||
Add([8170, -2725, -639, -4440, 12017, 2744, -771, 1465, 6599], "Pentax K-5 II", "Pentax K-5 II s");
|
||||
Add([8843, -2837, -625, -5025, 12644, 2668, -411, 1234, 7410], "Pentax K-x");
|
||||
Add([9895, -3077, -850, -5304, 13035, 2521, -883, 1768, 6936], "Pentax K-r");
|
||||
Add([8710, -2632, -1167, -3995, 12301, 1881, -981, 1719, 6535], "Pentax K-30");
|
||||
Add([7415, -2052, -721, -5186, 12788, 2682, -1446, 2157, 6773], "Pentax K-3");
|
||||
Add([8596, -2981, -639, -4202, 12046, 2431, -685, 1424, 6122], "Pentax K-1");
|
||||
|
||||
// Fujifilm (RAF).
|
||||
Add([10413, -3996, -993, -3721, 11640, 2361, -733, 1540, 6011], "Fujifilm X-E1", "Fujifilm X-Pro1", "Fujifilm X-M1");
|
||||
Add([10592, -4262, -1008, -3514, 11355, 2465, -870, 2025, 6386], "Fujifilm X100S", "Fujifilm X20");
|
||||
Add([8458, -2451, -855, -4597, 12447, 2407, -1475, 2482, 6526], "Fujifilm X-T1", "Fujifilm X-E2", "Fujifilm X-T10", "Fujifilm X100T", "Fujifilm X30");
|
||||
Add([11434, -4948, -1210, -3746, 12042, 1903, -666, 1479, 5235], "Fujifilm X-T2", "Fujifilm X-Pro2", "Fujifilm X-T20", "Fujifilm X100F", "Fujifilm X-E3");
|
||||
Add([13426, -6334, -1177, -4244, 12136, 2371, -580, 1303, 5980], "Fujifilm X-T3", "Fujifilm X-T30");
|
||||
Add([11086, -4555, -839, -3512, 11310, 2517, -815, 1341, 5940], "Fujifilm X-A1");
|
||||
return t;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
using Titano.Core.Codecs.Jpeg;
|
||||
using Titano.Core.Mathematics;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Codecs.Raw;
|
||||
|
||||
/// <summary>
|
||||
/// Canon CR2: the fourth IFD holds one lossless-JPEG (SOF3) strip whose samples are laid out in vertical slices
|
||||
/// (tag 0xC640 cr2_slice = count, slice width, last slice width; dcraw <c>lossless_jpeg_load_raw</c>). The MakerNote
|
||||
/// supplies SensorInfo (0x00E0: sensor borders, i.e. the active area) and ColorData (0x4001: as-shot RGGB levels at a
|
||||
/// version-dependent offset). Black is measured on the masked left columns. sRAW/mRAW (subsampled YCbCr) is not
|
||||
/// supported and falls back to the preview.
|
||||
/// </summary>
|
||||
internal static class Cr2Reader
|
||||
{
|
||||
private const ushort SliceTag = 0xC640;
|
||||
private const ushort SensorInfoTag = 0x00E0;
|
||||
private const ushort ColorDataTag = 0x4001;
|
||||
private const int RawIfdIndex = 3;
|
||||
private const int HeaderProbeBytes = 64 * 1024;
|
||||
|
||||
public static RawFrame Read(Stream stream)
|
||||
{
|
||||
var r = TiffReader.Open(stream) ?? throw new InvalidDataException("CR2: missing TIFF header");
|
||||
var chain = r.ReadChain();
|
||||
if (chain.Count <= RawIfdIndex) throw new InvalidDataException("CR2: raw IFD missing");
|
||||
var ifd0 = chain[0];
|
||||
var raw = chain[RawIfdIndex];
|
||||
var offset = r.GetUInt(raw, TiffTags.StripOffsets) ?? throw new InvalidDataException("CR2: raw strip missing");
|
||||
var length = r.GetUInt(raw, TiffTags.StripByteCounts) ?? throw new InvalidDataException("CR2: raw strip length missing");
|
||||
if (offset + (long)length > stream.Length || length < 16) throw new InvalidDataException("CR2: raw strip outside the file");
|
||||
|
||||
var head = NativeRaw.ReadPayload(stream, offset, long.Min(length, HeaderProbeBytes));
|
||||
JpegInfo info;
|
||||
try
|
||||
{
|
||||
info = JpegDecoder.ReadInfo(head);
|
||||
}
|
||||
catch (InvalidDataException ex)
|
||||
{
|
||||
throw new InvalidDataException("CR2: raw strip is not a JPEG: " + ex.Message);
|
||||
}
|
||||
if (info.Process != JpegProcess.Lossless) throw new InvalidDataException("CR2: raw strip is not lossless JPEG");
|
||||
if (info.Sampling.Any(s => s != (1, 1))) throw new InvalidDataException("CR2: sRAW/mRAW is not supported");
|
||||
var rawWidth = (long)info.Width * info.Components;
|
||||
var slices = IfdValue.UInts(r, raw, SliceTag);
|
||||
if (slices is [var count, var sliceWidth, var lastWidth, ..] && count + sliceWidth + lastWidth > 0)
|
||||
{
|
||||
if (count * (long)sliceWidth + lastWidth != rawWidth || lastWidth == 0 || count > 0 && sliceWidth == 0)
|
||||
throw new InvalidDataException("CR2: slice layout does not match the JPEG frame");
|
||||
}
|
||||
else
|
||||
{
|
||||
slices = null;
|
||||
}
|
||||
var (width, height) = NativeRaw.Size(rawWidth, info.Height);
|
||||
NativeRaw.RequireBits(length, (long)width * height);
|
||||
|
||||
var make = r.GetString(ifd0, TiffTags.Make);
|
||||
var model = r.GetString(ifd0, TiffTags.Model);
|
||||
var warnings = new List<string>();
|
||||
var makerNote = MakerNote(r, ifd0);
|
||||
var active = new RawRect(0, 0, width, height);
|
||||
if (makerNote is not null && IfdValue.UInts(r, makerNote, SensorInfoTag) is { Length: >= 9 } sensor)
|
||||
{
|
||||
// SensorInfo borders are inclusive pixel indices.
|
||||
var area = new RawRect((int)sensor[5], (int)sensor[6], (int)sensor[7] + 1, (int)sensor[8] + 1).Intersect(active);
|
||||
if (!area.IsEmpty && sensor[7] > sensor[5] && sensor[8] > sensor[6]) active = area;
|
||||
else warnings.Add("CR2: SensorInfo borders ignored");
|
||||
}
|
||||
else
|
||||
{
|
||||
warnings.Add("CR2: SensorInfo missing; full raster used");
|
||||
}
|
||||
var cfa = CfaPattern.Bayer("RGGB").Shift(active.Left, active.Top);
|
||||
var white = (1 << info.Precision) - 1;
|
||||
var loader = new Cr2Loader(offset, length, width, height, slices, active);
|
||||
return NativeRaw.Frame("managed-cr2", width, height, cfa, active, NativeRaw.Black(0), white,
|
||||
Multipliers(r, makerNote), (int)(r.GetUInt(ifd0, TiffTags.Orientation) ?? 1), make, model, loader, warnings);
|
||||
}
|
||||
|
||||
/// <summary>Canon MakerNote: a plain IFD inside the Exif IFD, offsets relative to the TIFF header.</summary>
|
||||
private static Ifd? MakerNote(TiffReader r, Ifd ifd0)
|
||||
{
|
||||
if (NativeRaw.ExifIfd(r, ifd0) is not { } exif || !exif.Entries.TryGetValue(TiffTags.MakerNote, out var note) || note.IsInline) return null;
|
||||
return r.ReadIfd(note.ValueOffset);
|
||||
}
|
||||
|
||||
/// <summary>As-shot RGGB levels from ColorData; the offset (in 16-bit words) depends on the record's length (dcraw).</summary>
|
||||
private static Vector3D? Multipliers(TiffReader r, Ifd? makerNote)
|
||||
{
|
||||
if (makerNote is null || !makerNote.Entries.TryGetValue(ColorDataTag, out var e) || e.Count <= 500 || e.Count > 8192) return null;
|
||||
var data = r.GetUInts(e);
|
||||
if (data is null) return null;
|
||||
var at = data.Length switch { 582 => 25, 653 => 34, 5120 => 71, _ => 63 };
|
||||
if (at + 4 > data.Length) return null;
|
||||
double red = data[at], green = (data[at + 1] + data[at + 2]) / 2.0, blue = data[at + 3];
|
||||
return red > 0 && green > 0 && blue > 0 ? new Vector3D(red / green, 1, blue / green) : null;
|
||||
}
|
||||
|
||||
/// <summary>Decodes the strip, places samples by slice, and measures black on the masked columns left of the active area.</summary>
|
||||
private sealed class Cr2Loader(long offset, long length, int width, int height, uint[]? slices, RawRect active) : RawLoader
|
||||
{
|
||||
public override RawSamples Load(Stream stream, int maxDegreeOfParallelism, CancellationToken cancellationToken)
|
||||
{
|
||||
var data = NativeRaw.ReadPayload(stream, offset, length);
|
||||
var jpeg = JpegLosslessDecoder.Decode(data);
|
||||
var src = jpeg.Samples;
|
||||
if ((long)jpeg.Width * jpeg.Components != width || jpeg.Height != height) throw new InvalidDataException("CR2: JPEG frame changed size");
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
ushort[] samples;
|
||||
if (slices is null)
|
||||
{
|
||||
samples = src;
|
||||
}
|
||||
else
|
||||
{
|
||||
samples = new ushort[src.Length];
|
||||
int count = (int)slices[0], sliceWidth = (int)slices[1], lastWidth = (int)slices[2];
|
||||
var perSlice = (long)sliceWidth * height;
|
||||
Parallel.For(0, count + 1, new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism, CancellationToken = cancellationToken }, s =>
|
||||
{
|
||||
var w = s < count ? sliceWidth : lastWidth;
|
||||
var start = s * perSlice;
|
||||
for (var row = 0; row < height; row++)
|
||||
{
|
||||
src.AsSpan((int)(start + (long)row * w), w).CopyTo(samples.AsSpan(row * width + s * sliceWidth, w));
|
||||
}
|
||||
});
|
||||
}
|
||||
var result = new RawSamples(width, height, 1, samples, null);
|
||||
result.MeasuredBlack = MaskedBlack(samples, result.Warnings);
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>Per-CFA-colour mean of the masked columns (4 px away from both edges of the mask).</summary>
|
||||
private RawBlackLevel MaskedBlack(ushort[] samples, List<string> warnings)
|
||||
{
|
||||
if (active.Left < 12)
|
||||
{
|
||||
warnings.Add("CR2: no masked columns; black level 0 assumed");
|
||||
return NativeRaw.Black(0);
|
||||
}
|
||||
Span<double> sum = stackalloc double[4];
|
||||
Span<long> n = stackalloc long[4];
|
||||
for (var y = active.Top; y < active.Bottom; y++)
|
||||
{
|
||||
for (var x = 4; x < active.Left - 4; x++)
|
||||
{
|
||||
// Cell index relative to the active area's CFA phase.
|
||||
var cell = ((y - active.Top) & 1) * 2 + ((x - active.Left) & 1);
|
||||
sum[cell] += samples[y * width + x];
|
||||
n[cell]++;
|
||||
}
|
||||
}
|
||||
var values = new float[4];
|
||||
for (var i = 0; i < 4; i++) values[i] = n[i] > 0 ? (float)(sum[i] / n[i]) : 0f;
|
||||
return new RawBlackLevel(2, 2, values, null, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,251 @@
|
||||
using Titano.Core.Codecs.Dng;
|
||||
using Titano.Core.Mathematics;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Codecs.Raw;
|
||||
|
||||
/// <summary>Shared pieces of the native (non-DNG) RAW readers: camera naming, frame construction, MakerNote access and
|
||||
/// bounded payload reads.</summary>
|
||||
internal static class NativeRaw
|
||||
{
|
||||
/// <summary>Largest raw raster accepted (256 megapixels).</summary>
|
||||
public const long MaxPixels = 1L << 28;
|
||||
|
||||
/// <summary>"Brand Model" as keyed in <see cref="CameraMatrices"/>: "NIKON CORPORATION" + "NIKON D850" → "Nikon D850".</summary>
|
||||
public static string? CameraName(string? make, string? model)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(model)) return null;
|
||||
var m = make?.Trim() ?? string.Empty;
|
||||
string brand;
|
||||
if (m.StartsWith("Canon", StringComparison.OrdinalIgnoreCase)) brand = "Canon";
|
||||
else if (m.StartsWith("NIKON", StringComparison.OrdinalIgnoreCase)) brand = "Nikon";
|
||||
else if (m.StartsWith("SONY", StringComparison.OrdinalIgnoreCase)) brand = "Sony";
|
||||
else if (m.StartsWith("PENTAX", StringComparison.OrdinalIgnoreCase) || m.StartsWith("RICOH", StringComparison.OrdinalIgnoreCase) || m.StartsWith("ASAHI", StringComparison.OrdinalIgnoreCase)) brand = "Pentax";
|
||||
else if (m.StartsWith("FUJIFILM", StringComparison.OrdinalIgnoreCase)) brand = "Fujifilm";
|
||||
else brand = m.Split(' ', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() ?? string.Empty;
|
||||
var words = model.Split(' ', StringSplitOptions.RemoveEmptyEntries).ToList();
|
||||
if (words.Count > 1 && (words[0].Equals(brand, StringComparison.OrdinalIgnoreCase) || words[0].Equals("PENTAX", StringComparison.OrdinalIgnoreCase)))
|
||||
words.RemoveAt(0);
|
||||
return words.Count == 0 ? null : $"{brand} {string.Join(' ', words)}";
|
||||
}
|
||||
|
||||
/// <summary>Builds the frame of a native RAW developed with a tabulated D65 matrix.</summary>
|
||||
/// <param name="multipliers">As-shot white-balance multipliers (R, G, B); null falls back to daylight.</param>
|
||||
/// <exception cref="InvalidDataException">The body has no colour matrix (the caller falls back to the preview).</exception>
|
||||
public static RawFrame Frame(string decoder, int width, int height, CfaPattern cfa, RawRect active, RawBlackLevel black, double white,
|
||||
Vector3D? multipliers, int orientation, string? make, string? model, RawLoader loader, IEnumerable<string> warnings)
|
||||
{
|
||||
var name = CameraName(make, model);
|
||||
var matrix = CameraMatrices.Find(name) ?? throw new InvalidDataException($"RAW: no colour matrix for {name ?? "unknown camera"}");
|
||||
if (active.IsEmpty || active.Left < 0 || active.Top < 0 || active.Right > width || active.Bottom > height)
|
||||
throw new InvalidDataException("RAW: sensor area outside the raster");
|
||||
Vector3D? neutral = multipliers is { } m && m.X > 0 && m.Y > 0 && m.Z > 0 && double.IsFinite(m.X + m.Y + m.Z)
|
||||
? new Vector3D(1 / m.X, 1 / m.Y, 1 / m.Z)
|
||||
: null;
|
||||
var frame = new RawFrame
|
||||
{
|
||||
Decoder = decoder,
|
||||
Width = width,
|
||||
Height = height,
|
||||
Cfa = cfa,
|
||||
ActiveArea = active,
|
||||
Black = black,
|
||||
White = [white],
|
||||
DetectSaturation = true,
|
||||
Color = new DngColorProfile
|
||||
{
|
||||
ColorMatrix1 = matrix,
|
||||
CalibrationIlluminant1 = 21,
|
||||
AsShotNeutral = neutral,
|
||||
AsShotWhite = neutral is null ? Chromaticity.D65 : null,
|
||||
},
|
||||
Orientation = orientation is >= 1 and <= 8 ? orientation : 1,
|
||||
Make = make,
|
||||
Model = model,
|
||||
Loader = loader,
|
||||
};
|
||||
frame.Warnings.AddRange(warnings);
|
||||
if (neutral is null) frame.Warnings.Add("RAW: as-shot white balance unavailable; daylight assumed");
|
||||
return frame;
|
||||
}
|
||||
|
||||
/// <summary>Validated raster size.</summary>
|
||||
public static (int Width, int Height) Size(long width, long height)
|
||||
{
|
||||
if (width <= 0 || height <= 0 || width * height > MaxPixels) throw new InvalidDataException($"RAW: unsupported raster size {width}x{height}");
|
||||
return ((int)width, (int)height);
|
||||
}
|
||||
|
||||
/// <summary>Rejects entropy-coded payloads too short to hold one bit per sample, before the raster is allocated (a
|
||||
/// corrupted size must not trigger a huge allocation).</summary>
|
||||
public static void RequireBits(long payloadBytes, long samples)
|
||||
{
|
||||
if (payloadBytes * 8 < samples) throw new InvalidDataException("RAW: compressed data too short for the raster");
|
||||
}
|
||||
|
||||
/// <summary>Uniform black level for every CFA cell.</summary>
|
||||
public static RawBlackLevel Black(double value) => new(1, 1, [(float)value], null, null);
|
||||
|
||||
/// <summary>Black level of a 2×2 CFA from values in R, G1, G2, B order, re-anchored at the active area.</summary>
|
||||
public static RawBlackLevel Black2x2(CfaPattern cfa, ReadOnlySpan<double> rggb)
|
||||
{
|
||||
var values = new float[4];
|
||||
for (var y = 0; y < 2; y++)
|
||||
{
|
||||
for (var x = 0; x < 2; x++)
|
||||
{
|
||||
var c = cfa.ColorAt(x, y);
|
||||
// The second green of a 2×2 cell is the one sharing a row with blue.
|
||||
var index = c == 0 ? 0 : c == 2 ? 3 : cfa.ColorAt(x ^ 1, y) == 0 ? 1 : 2;
|
||||
values[y * 2 + x] = (float)rggb[index];
|
||||
}
|
||||
}
|
||||
return new RawBlackLevel(2, 2, values, null, null);
|
||||
}
|
||||
|
||||
/// <summary>Exif IFD of IFD0, or null.</summary>
|
||||
public static Ifd? ExifIfd(TiffReader r, Ifd ifd0) => r.GetUInt(ifd0, TiffTags.ExifIfd) is { } offset and > 0 ? r.ReadIfd(offset) : null;
|
||||
|
||||
/// <summary>Reads <paramref name="length"/> bytes at an absolute position (bounded by the stream).</summary>
|
||||
public static byte[] ReadPayload(Stream stream, long position, long length)
|
||||
{
|
||||
if (position < 0 || length <= 0 || length > int.MaxValue || position > stream.Length - length)
|
||||
throw new InvalidDataException("RAW: image data outside the file");
|
||||
var data = new byte[length];
|
||||
stream.Position = position;
|
||||
stream.ReadExactly(data);
|
||||
return data;
|
||||
}
|
||||
|
||||
/// <summary>CFA pattern from TIFF/EP CFARepeatPatternDim/CFAPattern tags (as written in NEF/ARW/PEF raw IFDs), or null.</summary>
|
||||
public static CfaPattern? TiffEpCfa(TiffReader r, Ifd ifd)
|
||||
{
|
||||
if (IfdValue.UInts(r, ifd, TiffTags.CfaPattern) is not { } pattern) return null;
|
||||
var dim = IfdValue.UInts(r, ifd, TiffTags.CfaRepeatPatternDim) ?? [2, 2];
|
||||
if (dim.Length < 2 || dim[0] is < 1 or > CfaPattern.MaxSize || dim[1] is < 1 or > CfaPattern.MaxSize || pattern.Length < dim[0] * dim[1]) return null;
|
||||
var colors = new byte[dim[0] * dim[1]];
|
||||
for (var i = 0; i < colors.Length; i++)
|
||||
{
|
||||
if (pattern[i] > 2) return null;
|
||||
colors[i] = (byte)pattern[i];
|
||||
}
|
||||
try
|
||||
{
|
||||
return new CfaPattern((int)dim[1], (int)dim[0], colors);
|
||||
}
|
||||
catch (InvalidDataException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Uncompressed raw payloads: 16-bit words (either byte order) or MSB-first packed samples (TIFF convention).</summary>
|
||||
internal sealed class PlainRawLoader(long offset, long length, int width, int height, int bits, bool words, bool littleEndian) : RawLoader
|
||||
{
|
||||
public override RawSamples Load(Stream stream, int maxDegreeOfParallelism, CancellationToken cancellationToken)
|
||||
{
|
||||
var rowBytes = words ? width * 2L : (width * (long)bits + 7) / 8;
|
||||
if (rowBytes * height > length) throw new InvalidDataException("RAW: image data truncated");
|
||||
var data = NativeRaw.ReadPayload(stream, offset, rowBytes * height);
|
||||
var samples = new ushort[width * height];
|
||||
var mask = (1 << bits) - 1;
|
||||
Parallel.For(0, height, new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism, CancellationToken = cancellationToken }, y =>
|
||||
{
|
||||
var row = data.AsSpan((int)(y * rowBytes), (int)rowBytes);
|
||||
var dst = samples.AsSpan(y * width, width);
|
||||
if (words)
|
||||
{
|
||||
for (var x = 0; x < width; x++)
|
||||
dst[x] = (ushort)((littleEndian ? row[2 * x] | row[2 * x + 1] << 8 : row[2 * x] << 8 | row[2 * x + 1]) & mask);
|
||||
return;
|
||||
}
|
||||
long bit = 0;
|
||||
for (var x = 0; x < width; x++, bit += bits)
|
||||
{
|
||||
var b = (int)(bit >> 3);
|
||||
// Up to 16 bits spanning at most three bytes.
|
||||
var window = row[b] << 16 | (b + 1 < row.Length ? row[b + 1] << 8 : 0) | (b + 2 < row.Length ? row[b + 2] : 0);
|
||||
dst[x] = (ushort)(window >> (24 - (int)(bit & 7) - bits) & mask);
|
||||
}
|
||||
});
|
||||
return new RawSamples(width, height, 1, samples, null);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>MSB-first bit reader without byte stuffing (Nikon and Pentax Huffman streams). Reading past the end yields
|
||||
/// zero bits and sets <see cref="Overrun"/>.</summary>
|
||||
internal ref struct MsbBitReader(ReadOnlySpan<byte> data)
|
||||
{
|
||||
private readonly ReadOnlySpan<byte> _data = data;
|
||||
private int _pos;
|
||||
private ulong _buffer;
|
||||
private int _bits;
|
||||
|
||||
public readonly bool Overrun => _pos > _data.Length + 8;
|
||||
|
||||
/// <summary>Next <paramref name="n"/> bits (n ≤ 32) without consuming them.</summary>
|
||||
public uint Peek(int n)
|
||||
{
|
||||
if (n == 0) return 0;
|
||||
while (_bits < n)
|
||||
{
|
||||
_buffer = _buffer << 8 | (_pos < _data.Length ? _data[_pos] : 0u);
|
||||
_pos++;
|
||||
_bits += 8;
|
||||
}
|
||||
return (uint)(_buffer >> (_bits - n)) & (uint)((1UL << n) - 1);
|
||||
}
|
||||
|
||||
public void Skip(int n) => _bits -= n;
|
||||
|
||||
public uint Read(int n)
|
||||
{
|
||||
var v = Peek(n);
|
||||
_bits -= n;
|
||||
return v;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Huffman lookup in dcraw's <c>make_decoder</c> layout: code-length counts for lengths 1–16 followed by symbols,
|
||||
/// codes assigned canonically; each table entry is (length << 8 | symbol) indexed by the next <see cref="Bits"/> bits.</summary>
|
||||
internal sealed class HuffmanTable
|
||||
{
|
||||
private readonly ushort[] _lut;
|
||||
|
||||
public HuffmanTable(ReadOnlySpan<byte> countsAndSymbols)
|
||||
{
|
||||
var bits = 16;
|
||||
while (bits > 0 && countsAndSymbols[bits - 1] == 0) bits--;
|
||||
if (bits == 0) throw new InvalidDataException("RAW: empty Huffman table");
|
||||
Bits = bits;
|
||||
_lut = new ushort[1 << bits];
|
||||
var h = 0;
|
||||
var symbol = 16;
|
||||
for (var len = 1; len <= bits; len++)
|
||||
{
|
||||
for (var i = 0; i < countsAndSymbols[len - 1]; i++, symbol++)
|
||||
{
|
||||
var value = symbol < countsAndSymbols.Length ? countsAndSymbols[symbol] : (byte)0;
|
||||
for (var j = 0; j < 1 << (bits - len) && h < _lut.Length; j++) _lut[h++] = (ushort)(len << 8 | value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Wraps a prebuilt lookup (Pentax tables).</summary>
|
||||
public HuffmanTable(ushort[] lut, int bits)
|
||||
{
|
||||
_lut = lut;
|
||||
Bits = bits;
|
||||
}
|
||||
|
||||
public int Bits { get; }
|
||||
|
||||
/// <summary>Decodes one symbol.</summary>
|
||||
public int Decode(ref MsbBitReader reader)
|
||||
{
|
||||
var entry = _lut[reader.Peek(Bits)];
|
||||
reader.Skip(entry >> 8);
|
||||
return entry & 0xFF;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
using System.Buffers.Binary;
|
||||
using Titano.Core.Mathematics;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Codecs.Raw;
|
||||
|
||||
/// <summary>
|
||||
/// Nikon NEF: the CFA SubIFD is uncompressed (16-bit words or MSB-packed samples) or Nikon-compressed (Compression
|
||||
/// 34713): lossy type 1, lossless and lossy type 2 including the "after split" variant, decoded as dcraw's
|
||||
/// <c>nikon_load_raw</c> does from the MakerNote decode info (0x0096: version, vertical predictors, tone curve, split row)
|
||||
/// with Nikon's six Huffman trees and two-column horizontal prediction. White balance comes from MakerNote 0x000C, black
|
||||
/// from 0x003D. Packed 12-bit "uncompressed" variants, YUV NEFs and the high-efficiency (TicoRAW) codec are not supported
|
||||
/// and fall back to the preview.
|
||||
/// </summary>
|
||||
internal static class NefReader
|
||||
{
|
||||
private const ushort WbLevelsTag = 0x000C;
|
||||
private const ushort BlackLevelTag = 0x003D;
|
||||
private const ushort DecodeInfoTag = 0x0096;
|
||||
private const uint CompressionNikon = 34713;
|
||||
|
||||
/// <summary>Nikon Huffman trees (dcraw <c>nikon_tree</c>): 16 code-length counts, then the symbols (len | shift << 4).</summary>
|
||||
internal static readonly byte[][] Trees =
|
||||
[
|
||||
[0, 1, 5, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 5, 4, 3, 6, 2, 7, 1, 0, 8, 9, 11, 10, 12, 0, 0, 0],
|
||||
[0, 1, 5, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0x39, 0x5a, 0x38, 0x27, 0x16, 5, 4, 3, 2, 1, 0, 11, 12, 12, 0, 0],
|
||||
[0, 1, 4, 2, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 6, 3, 7, 2, 8, 1, 9, 0, 10, 11, 12, 0, 0, 0],
|
||||
[0, 1, 4, 3, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 5, 6, 4, 7, 8, 3, 9, 2, 1, 0, 10, 11, 12, 13, 14, 0],
|
||||
[0, 1, 5, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 8, 0x5c, 0x4b, 0x3a, 0x29, 7, 6, 5, 4, 3, 2, 1, 0, 13, 14, 0],
|
||||
[0, 1, 4, 2, 2, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 7, 6, 8, 5, 9, 4, 10, 3, 11, 12, 2, 0, 1, 13, 14, 0],
|
||||
];
|
||||
|
||||
public static RawFrame Read(Stream stream)
|
||||
{
|
||||
var r = TiffReader.Open(stream) ?? throw new InvalidDataException("NEF: missing TIFF header");
|
||||
var chain = r.ReadChain();
|
||||
if (chain.Count == 0) throw new InvalidDataException("NEF: no image directory");
|
||||
var ifd0 = chain[0];
|
||||
var raw = FindCfa(r, ifd0) ?? throw new InvalidDataException("NEF: CFA image missing");
|
||||
var (width, height) = NativeRaw.Size(r.GetUInt(raw, TiffTags.ImageWidth) ?? 0, r.GetUInt(raw, TiffTags.ImageLength) ?? 0);
|
||||
var bits = (int)(r.GetUInt(raw, TiffTags.BitsPerSample) ?? 0);
|
||||
if (bits is not (12 or 14)) throw new InvalidDataException($"NEF: {bits}-bit data is not supported");
|
||||
var (offset, length) = Strip(r, raw);
|
||||
var compression = r.GetUInt(raw, TiffTags.Compression) ?? 1;
|
||||
var note = MakerNote(stream, r, ifd0);
|
||||
var warnings = new List<string>();
|
||||
var cfa = NativeRaw.TiffEpCfa(r, raw);
|
||||
if (cfa is null)
|
||||
{
|
||||
cfa = CfaPattern.Bayer("RGGB");
|
||||
warnings.Add("NEF: CFA pattern missing; RGGB assumed");
|
||||
}
|
||||
if (!cfa.IsBayer) throw new InvalidDataException("NEF: only Bayer sensors are supported");
|
||||
|
||||
RawLoader loader;
|
||||
double white = (1 << bits) - 1;
|
||||
if (compression == CompressionNikon && length != (long)width * height * 2)
|
||||
{
|
||||
if (note is not { } mn || !mn.Ifd.Entries.TryGetValue(DecodeInfoTag, out var meta) || mn.Reader.ReadBytes(meta) is not { } info)
|
||||
throw new InvalidDataException("NEF: compressed data without decode information");
|
||||
NativeRaw.RequireBits(length, (long)width * height);
|
||||
var decode = DecodeInfo.Parse(info, mn.Reader.LittleEndian, bits);
|
||||
white = decode.White;
|
||||
loader = new NikonHuffmanLoader(offset, length, width, height, decode);
|
||||
}
|
||||
else if (compression is CompressionNikon or 1 && length >= (long)width * height * 2)
|
||||
{
|
||||
// Nikon writes unpacked "compressed" data big-endian; plain uncompressed follows the TIFF byte order.
|
||||
loader = new PlainRawLoader(offset, length, width, height, bits, words: true, littleEndian: compression == 1 && r.LittleEndian);
|
||||
}
|
||||
else if (compression == 1 && length >= ((long)width * bits + 7) / 8 * height)
|
||||
{
|
||||
loader = new PlainRawLoader(offset, length, width, height, bits, words: false, littleEndian: false);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new InvalidDataException($"NEF: compression {compression} with {length} bytes is not supported");
|
||||
}
|
||||
|
||||
var black = NativeRaw.Black(0);
|
||||
if (note is { } n && IfdValue.UInts(n.Reader, n.Ifd, BlackLevelTag) is { Length: 4 } b)
|
||||
{
|
||||
// Stored on a 14-bit scale whatever the bit depth.
|
||||
black = NativeRaw.Black2x2(cfa, [b[0] >> (14 - bits), b[1] >> (14 - bits), b[2] >> (14 - bits), b[3] >> (14 - bits)]);
|
||||
}
|
||||
Vector3D? multipliers = note is { } w && IfdValue.Doubles(w.Reader, w.Ifd, WbLevelsTag, 2) is [var red, var blue, ..] ? new Vector3D(red, 1, blue) : null;
|
||||
return NativeRaw.Frame("managed-nef", width, height, cfa, new RawRect(0, 0, width, height), black, white, multipliers,
|
||||
(int)(r.GetUInt(ifd0, TiffTags.Orientation) ?? 1), r.GetString(ifd0, TiffTags.Make), r.GetString(ifd0, TiffTags.Model), loader, warnings);
|
||||
}
|
||||
|
||||
/// <summary>The full-resolution CFA IFD: IFD0 or one of its SubIFDs.</summary>
|
||||
internal static Ifd? FindCfa(TiffReader r, Ifd ifd0)
|
||||
{
|
||||
bool IsRaw(Ifd ifd) => (r.GetUInt(ifd, TiffTags.NewSubfileType) ?? 0) == 0 && r.GetUInt(ifd, TiffTags.PhotometricInterpretation) == 32803;
|
||||
if (IsRaw(ifd0)) return ifd0;
|
||||
if (!ifd0.Entries.TryGetValue(TiffTags.SubIfds, out var sub) || sub.Count > 16) return null;
|
||||
foreach (var offset in r.GetUInts(sub) ?? [])
|
||||
{
|
||||
if (r.ReadIfd(offset) is { } child && IsRaw(child)) return child;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>Absolute position and length of the image data (several strips must be contiguous).</summary>
|
||||
internal static (long Offset, long Length) Strip(TiffReader r, Ifd ifd)
|
||||
{
|
||||
var offsets = IfdValue.UInts(r, ifd, TiffTags.StripOffsets) ?? r.GetUInts(ifd, TiffTags.StripOffsets);
|
||||
var counts = IfdValue.UInts(r, ifd, TiffTags.StripByteCounts) ?? r.GetUInts(ifd, TiffTags.StripByteCounts);
|
||||
if (offsets is not { Length: > 0 } || counts is null || counts.Length < offsets.Length) throw new InvalidDataException("RAW: strip offsets missing");
|
||||
long length = 0;
|
||||
for (var i = 0; i < offsets.Length; i++)
|
||||
{
|
||||
if (offsets[i] != offsets[0] + length) throw new InvalidDataException("RAW: non-contiguous strips are not supported");
|
||||
length += counts[i];
|
||||
}
|
||||
var offset = r.Base + offsets[0];
|
||||
if (offset + length > r.StreamLength) throw new InvalidDataException("RAW: image data outside the file");
|
||||
return (offset, length);
|
||||
}
|
||||
|
||||
/// <summary>Nikon type-3 MakerNote: "Nikon\0", version, then an embedded TIFF header 10 bytes in.</summary>
|
||||
private static (TiffReader Reader, Ifd Ifd)? MakerNote(Stream stream, TiffReader r, Ifd ifd0)
|
||||
{
|
||||
if (NativeRaw.ExifIfd(r, ifd0) is not { } exif || !exif.Entries.TryGetValue(TiffTags.MakerNote, out var e) || e.IsInline || e.Count < 18) return null;
|
||||
var start = e.ValuePosition(r.Base);
|
||||
var head = r.ReadRelative(start - r.Base, 6);
|
||||
if (head is null || !head.AsSpan().SequenceEqual("Nikon\0"u8)) return null;
|
||||
var reader = TiffReader.Open(stream, start + 10);
|
||||
return reader?.ReadIfd(reader.FirstIfdOffset) is { } ifd ? (reader, ifd) : null;
|
||||
}
|
||||
|
||||
/// <summary>Parsed MakerNote 0x0096: Huffman tree, initial vertical predictors, tone curve and split row.</summary>
|
||||
internal sealed record DecodeInfo(int Tree, ushort[] Predictors, ushort[] Curve, int Split, double White)
|
||||
{
|
||||
public static DecodeInfo Parse(byte[] meta, bool littleEndian, int bits)
|
||||
{
|
||||
if (meta.Length < 12) throw new InvalidDataException("NEF: decode information truncated");
|
||||
var pos = 0;
|
||||
ushort U16()
|
||||
{
|
||||
if (pos + 2 > meta.Length) throw new InvalidDataException("NEF: decode information truncated");
|
||||
var v = littleEndian ? BinaryPrimitives.ReadUInt16LittleEndian(meta.AsSpan(pos)) : BinaryPrimitives.ReadUInt16BigEndian(meta.AsSpan(pos));
|
||||
pos += 2;
|
||||
return v;
|
||||
}
|
||||
int ver0 = meta[0], ver1 = meta[1];
|
||||
pos = ver0 == 0x49 || ver1 == 0x58 ? 2 + 2110 : 2;
|
||||
var tree = (ver0 == 0x46 ? 2 : 0) + (bits == 14 ? 3 : 0);
|
||||
ushort[] predictors = [U16(), U16(), U16(), U16()];
|
||||
var max = 1 << bits & 0x7FFF;
|
||||
var curve = new ushort[0x10000];
|
||||
for (var i = 0; i < curve.Length; i++) curve[i] = (ushort)i;
|
||||
var size = U16();
|
||||
var step = size > 1 ? max / (size - 1) : 0;
|
||||
var split = 0;
|
||||
var top = max;
|
||||
if (ver0 == 0x44 && ver1 == 0x20 && step > 0)
|
||||
{
|
||||
// Lossy type 2: curve sampled every 'step' codes, linearly interpolated; split row at offset 562.
|
||||
for (var i = 0; i < size; i++) curve[int.Min(i * step, curve.Length - 1)] = U16();
|
||||
for (var i = 0; i < max; i++)
|
||||
{
|
||||
var k = i % step;
|
||||
var a = i - k;
|
||||
curve[i] = (ushort)((curve[a] * (step - k) + curve[int.Min(a + step, curve.Length - 1)] * k) / step);
|
||||
}
|
||||
if (meta.Length >= 564)
|
||||
{
|
||||
pos = 562;
|
||||
split = U16();
|
||||
}
|
||||
}
|
||||
else if (ver0 != 0x46 && size <= 0x4001)
|
||||
{
|
||||
// Lossy type 1: the curve is stored in full.
|
||||
for (var i = 0; i < size; i++) curve[i] = U16();
|
||||
top = size;
|
||||
}
|
||||
double white = 0;
|
||||
for (var i = 0; i < int.Max(top, 1); i++) white = double.Max(white, curve[i]);
|
||||
return new DecodeInfo(tree, predictors, curve, split, white);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>dcraw <c>nikon_load_raw</c>.</summary>
|
||||
private sealed class NikonHuffmanLoader(long offset, long length, int width, int height, DecodeInfo info) : RawLoader
|
||||
{
|
||||
public override RawSamples Load(Stream stream, int maxDegreeOfParallelism, CancellationToken cancellationToken)
|
||||
{
|
||||
var data = NativeRaw.ReadPayload(stream, offset, length);
|
||||
var samples = new ushort[width * height];
|
||||
var huff = new HuffmanTable(Trees[info.Tree]);
|
||||
var reader = new MsbBitReader(data);
|
||||
Span<ushort> vpred = stackalloc ushort[4];
|
||||
info.Predictors.CopyTo(vpred);
|
||||
Span<ushort> hpred = stackalloc ushort[2];
|
||||
var curve = info.Curve;
|
||||
for (var row = 0; row < height; row++)
|
||||
{
|
||||
if (info.Split > 0 && row == info.Split && info.Tree + 1 < Trees.Length) huff = new HuffmanTable(Trees[info.Tree + 1]);
|
||||
if ((row & 63) == 0) cancellationToken.ThrowIfCancellationRequested();
|
||||
var dst = samples.AsSpan(row * width, width);
|
||||
for (var col = 0; col < width; col++)
|
||||
{
|
||||
var symbol = huff.Decode(ref reader);
|
||||
int len = symbol & 15, shl = symbol >> 4;
|
||||
var diff = 0;
|
||||
if (len > 0)
|
||||
{
|
||||
diff = (int)(((reader.Read(int.Max(len - shl, 0)) << 1) + 1) << shl >> 1);
|
||||
if ((diff & 1 << (len - 1)) == 0) diff -= (1 << len) - (shl == 0 ? 1 : 0);
|
||||
}
|
||||
ushort predicted;
|
||||
if (col < 2)
|
||||
{
|
||||
ref var v = ref vpred[(row & 1) * 2 + col];
|
||||
v = (ushort)(v + diff);
|
||||
predicted = hpred[col] = v;
|
||||
}
|
||||
else
|
||||
{
|
||||
predicted = hpred[col & 1] = (ushort)(hpred[col & 1] + diff);
|
||||
}
|
||||
dst[col] = curve[int.Clamp((short)predicted, 0, 0x3FFF)];
|
||||
}
|
||||
if (reader.Overrun) throw new InvalidDataException($"NEF: compressed data ends at row {row}");
|
||||
}
|
||||
return new RawSamples(width, height, 1, samples, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
using System.Buffers.Binary;
|
||||
using Titano.Core.Mathematics;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Codecs.Raw;
|
||||
|
||||
/// <summary>
|
||||
/// Pentax PEF: the CFA image in IFD0 is uncompressed or Pentax-Huffman coded (Compression 65535): a code table from
|
||||
/// MakerNote 0x0220 (code values left-aligned in 12 bits and their lengths, dcraw <c>pentax_load_raw</c>), JPEG-style
|
||||
/// difference magnitudes, and two-column horizontal prediction seeded per row parity. Black (0x0200) and as-shot RGGB
|
||||
/// levels (0x0201) come from the "AOC" MakerNote, whose offsets are relative to the TIFF header.
|
||||
/// </summary>
|
||||
internal static class PefReader
|
||||
{
|
||||
private const uint CompressionPentax = 65535;
|
||||
private const ushort BlackPointTag = 0x0200;
|
||||
private const ushort WhiteBalanceTag = 0x0201;
|
||||
private const ushort HuffmanTag = 0x0220;
|
||||
|
||||
public static RawFrame Read(Stream stream)
|
||||
{
|
||||
var r = TiffReader.Open(stream) ?? throw new InvalidDataException("PEF: missing TIFF header");
|
||||
var chain = r.ReadChain();
|
||||
if (chain.Count == 0) throw new InvalidDataException("PEF: no image directory");
|
||||
var ifd0 = chain[0];
|
||||
var raw = NefReader.FindCfa(r, ifd0) ?? throw new InvalidDataException("PEF: CFA image missing");
|
||||
var (width, height) = NativeRaw.Size(r.GetUInt(raw, TiffTags.ImageWidth) ?? 0, r.GetUInt(raw, TiffTags.ImageLength) ?? 0);
|
||||
var bits = (int)(r.GetUInt(raw, TiffTags.BitsPerSample) ?? 0);
|
||||
if (bits is not (12 or 14)) throw new InvalidDataException($"PEF: {bits}-bit data is not supported");
|
||||
var compression = r.GetUInt(raw, TiffTags.Compression) ?? 1;
|
||||
var (offset, length) = NefReader.Strip(r, raw);
|
||||
var note = MakerNote(stream, r, ifd0);
|
||||
var warnings = new List<string>();
|
||||
var cfa = NativeRaw.TiffEpCfa(r, raw);
|
||||
if (cfa is null)
|
||||
{
|
||||
cfa = CfaPattern.Bayer("RGGB");
|
||||
warnings.Add("PEF: CFA pattern missing; RGGB assumed");
|
||||
}
|
||||
if (!cfa.IsBayer) throw new InvalidDataException("PEF: only Bayer sensors are supported");
|
||||
|
||||
RawLoader loader;
|
||||
if (compression == CompressionPentax)
|
||||
{
|
||||
if (note is not { } mn || !mn.Ifd.Entries.TryGetValue(HuffmanTag, out var e) || mn.Reader.ReadBytes(e) is not { } table)
|
||||
throw new InvalidDataException("PEF: Huffman table missing");
|
||||
NativeRaw.RequireBits(length, (long)width * height);
|
||||
loader = new PentaxLoader(offset, length, width, height, bits, Table(table, mn.Reader.LittleEndian));
|
||||
}
|
||||
else if (compression == 1 && length >= (long)width * height * 2)
|
||||
{
|
||||
loader = new PlainRawLoader(offset, length, width, height, bits, words: true, littleEndian: r.LittleEndian);
|
||||
}
|
||||
else if (compression == 1 && length >= ((long)width * bits + 7) / 8 * height)
|
||||
{
|
||||
loader = new PlainRawLoader(offset, length, width, height, bits, words: false, littleEndian: false);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new InvalidDataException($"PEF: compression {compression} is not supported");
|
||||
}
|
||||
|
||||
var black = note is { } n && IfdValue.UInts(n.Reader, n.Ifd, BlackPointTag) is { Length: 4 } b
|
||||
? NativeRaw.Black2x2(cfa, [b[0], b[1], b[2], b[3]])
|
||||
: NativeRaw.Black(0);
|
||||
Vector3D? multipliers = note is { } w && IfdValue.UInts(w.Reader, w.Ifd, WhiteBalanceTag) is { Length: 4 } wb && wb[1] + wb[2] > 0
|
||||
? new Vector3D(wb[0] * 2.0 / (wb[1] + wb[2]), 1, wb[3] * 2.0 / (wb[1] + wb[2]))
|
||||
: null;
|
||||
return NativeRaw.Frame("managed-pef", width, height, cfa, new RawRect(0, 0, width, height), black, (1 << bits) - 1, multipliers,
|
||||
(int)(r.GetUInt(ifd0, TiffTags.Orientation) ?? 1), r.GetString(ifd0, TiffTags.Make), r.GetString(ifd0, TiffTags.Model), loader, warnings);
|
||||
}
|
||||
|
||||
/// <summary>"AOC\0" + byte order ("MM"/"II", else the file's) + IFD; offsets relative to the file's TIFF header.</summary>
|
||||
private static (TiffReader Reader, Ifd Ifd)? MakerNote(Stream stream, TiffReader r, Ifd ifd0)
|
||||
{
|
||||
if (NativeRaw.ExifIfd(r, ifd0) is not { } exif || !exif.Entries.TryGetValue(TiffTags.MakerNote, out var e) || e.IsInline || e.Count < 8) return null;
|
||||
var start = e.ValuePosition(r.Base);
|
||||
var head = r.ReadRelative(start - r.Base, 6);
|
||||
if (head is null || !head.AsSpan(0, 4).SequenceEqual("AOC\0"u8)) return null;
|
||||
var littleEndian = head[4] == 'I' && head[5] == 'I' || !(head[4] == 'M' && head[5] == 'M') && r.LittleEndian;
|
||||
var reader = TiffReader.ForEmbedded(stream, r.Base, littleEndian);
|
||||
return reader.ReadIfd((uint)(start + 6 - r.Base)) is { } ifd ? (reader, ifd) : null;
|
||||
}
|
||||
|
||||
/// <summary>12-bit lookup from MakerNote 0x0220: a code count, 12 skipped bytes, left-aligned code values (16-bit) and
|
||||
/// code lengths (8-bit); every 12-bit prefix of a code maps to (length, difference magnitude).</summary>
|
||||
internal static HuffmanTable Table(byte[] table, bool littleEndian)
|
||||
{
|
||||
if (table.Length < 14) throw new InvalidDataException("PEF: Huffman table truncated");
|
||||
ushort U16(int at) => littleEndian ? BinaryPrimitives.ReadUInt16LittleEndian(table.AsSpan(at)) : BinaryPrimitives.ReadUInt16BigEndian(table.AsSpan(at));
|
||||
var depth = (U16(0) + 12) & 15;
|
||||
if (table.Length < 14 + depth * 3) throw new InvalidDataException("PEF: Huffman table truncated");
|
||||
var lut = new ushort[4096];
|
||||
for (var c = 0; c < depth; c++)
|
||||
{
|
||||
int code = U16(14 + 2 * c), len = table[14 + 2 * depth + c];
|
||||
if (code > 4095 || len > 12) continue;
|
||||
var end = (code + (4096 >> len) - 1) & 4095;
|
||||
for (var i = code; i <= end; i++) lut[i] = (ushort)(len << 8 | c);
|
||||
}
|
||||
return new HuffmanTable(lut, 12);
|
||||
}
|
||||
|
||||
private sealed class PentaxLoader(long offset, long length, int width, int height, int bits, HuffmanTable huff) : RawLoader
|
||||
{
|
||||
public override RawSamples Load(Stream stream, int maxDegreeOfParallelism, CancellationToken cancellationToken)
|
||||
{
|
||||
var data = NativeRaw.ReadPayload(stream, offset, length);
|
||||
var samples = new ushort[width * height];
|
||||
var reader = new MsbBitReader(data);
|
||||
Span<int> vpred = stackalloc int[4];
|
||||
Span<int> hpred = stackalloc int[2];
|
||||
var limit = (1 << bits) - 1;
|
||||
var outOfRange = false;
|
||||
for (var row = 0; row < height; row++)
|
||||
{
|
||||
if ((row & 63) == 0) cancellationToken.ThrowIfCancellationRequested();
|
||||
var dst = samples.AsSpan(row * width, width);
|
||||
for (var col = 0; col < width; col++)
|
||||
{
|
||||
var len = huff.Decode(ref reader);
|
||||
var diff = 0;
|
||||
if (len == 16)
|
||||
{
|
||||
diff = -32768;
|
||||
}
|
||||
else if (len > 0)
|
||||
{
|
||||
diff = (int)reader.Read(len);
|
||||
if ((diff & 1 << (len - 1)) == 0) diff -= (1 << len) - 1;
|
||||
}
|
||||
int value;
|
||||
if (col < 2) value = hpred[col] = vpred[(row & 1) * 2 + col] += diff;
|
||||
else value = hpred[col & 1] += diff;
|
||||
if ((uint)value > (uint)limit)
|
||||
{
|
||||
outOfRange = true;
|
||||
value = int.Clamp(value, 0, limit);
|
||||
}
|
||||
dst[col] = (ushort)value;
|
||||
}
|
||||
if (reader.Overrun) throw new InvalidDataException($"PEF: compressed data ends at row {row}");
|
||||
}
|
||||
var result = new RawSamples(width, height, 1, samples, null);
|
||||
if (outOfRange) result.Warnings.Add("PEF: predicted values outside the bit depth were clamped");
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
using System.Buffers.Binary;
|
||||
using Titano.Core.Mathematics;
|
||||
using Titano.Core.Metadata;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Codecs.Raw;
|
||||
|
||||
/// <summary>
|
||||
/// Fujifilm RAF, uncompressed: the header's CFA offset (0x64) points to a big-endian TIFF block whose FujiIFD (0xF000)
|
||||
/// gives the raster size (0xF001/0xF002), bit depth (0xF003), the data offset relative to that block (0xF007), its length
|
||||
/// (0xF008) and black levels (0xF00A); the RAF directory supplies the crop (0x0110 top-left, 0x0111 size), the 6×6
|
||||
/// colour layout (0x0131, stored reversed, anchored at the raster origin; Bayer bodies describe their 2×2 pattern the same
|
||||
/// way) and the as-shot GRGB levels (0x2FF0). Samples are 16-bit words in the block's byte order. Compressed RAFs and
|
||||
/// SuperCCD (45°) layouts are not supported and fall back to the preview.
|
||||
/// </summary>
|
||||
internal static class RafReader
|
||||
{
|
||||
private const int HeaderLength = 0x6C;
|
||||
private const int MaxDirectoryBytes = 1 << 20;
|
||||
private const ushort FullSizeRecord = 0x0100, CropTopLeftRecord = 0x0110, CropSizeRecord = 0x0111;
|
||||
private const ushort LayoutRecord = 0x0130, CfaRecord = 0x0131, WhiteBalanceRecord = 0x2FF0;
|
||||
private const ushort FujiIfdTag = 0xF000, WidthTag = 0xF001, HeightTag = 0xF002, BitsTag = 0xF003;
|
||||
private const ushort OffsetTag = 0xF007, LengthTag = 0xF008, BlackTag = 0xF00A;
|
||||
|
||||
public static RawFrame Read(Stream stream)
|
||||
{
|
||||
var header = new byte[HeaderLength];
|
||||
stream.Position = 0;
|
||||
if (stream.ReadAtLeast(header, HeaderLength, throwOnEndOfStream: false) < HeaderLength || !header.AsSpan().StartsWith("FUJIFILMCCD-RAW "u8))
|
||||
throw new InvalidDataException("RAF: header missing");
|
||||
var records = Directory(stream, BinaryPrimitives.ReadUInt32BigEndian(header.AsSpan(0x5C)), BinaryPrimitives.ReadUInt32BigEndian(header.AsSpan(0x60)));
|
||||
if (records.TryGetValue(LayoutRecord, out var layout) && layout.Length >= 2 && (layout[1] & 8) == 0)
|
||||
throw new InvalidDataException("RAF: SuperCCD layouts are not supported");
|
||||
if (!records.TryGetValue(CfaRecord, out var pattern) || pattern.Length < 36) throw new InvalidDataException("RAF: colour layout record missing");
|
||||
|
||||
var blockBase = BinaryPrimitives.ReadUInt32BigEndian(header.AsSpan(0x64));
|
||||
var r = TiffReader.Open(stream, blockBase) ?? throw new InvalidDataException("RAF: raw block is not TIFF-structured");
|
||||
var fuji = r.ReadIfd(r.FirstIfdOffset) is { } top && r.GetUInt(top, FujiIfdTag) is { } sub ? r.ReadIfd(sub) : null;
|
||||
if (fuji is null) throw new InvalidDataException("RAF: FujiIFD missing");
|
||||
var (width, height) = NativeRaw.Size(r.GetUInt(fuji, WidthTag) ?? 0, r.GetUInt(fuji, HeightTag) ?? 0);
|
||||
var bits = (int)(r.GetUInt(fuji, BitsTag) ?? 0);
|
||||
if (bits is < 12 or > 16) throw new InvalidDataException($"RAF: {bits}-bit data is not supported");
|
||||
var offset = blockBase + (long)(r.GetUInt(fuji, OffsetTag) ?? 0);
|
||||
var length = (long)(r.GetUInt(fuji, LengthTag) ?? 0);
|
||||
if (length < (long)width * height * 2) throw new InvalidDataException("RAF: compressed RAF is not supported");
|
||||
|
||||
var warnings = new List<string>();
|
||||
var active = new RawRect(0, 0, width, height);
|
||||
if (records.TryGetValue(CropTopLeftRecord, out var tl) && tl.Length >= 4 && records.TryGetValue(CropSizeRecord, out var size) && size.Length >= 4)
|
||||
{
|
||||
int top0 = BinaryPrimitives.ReadUInt16BigEndian(tl), left0 = BinaryPrimitives.ReadUInt16BigEndian(tl.AsSpan(2));
|
||||
int h = BinaryPrimitives.ReadUInt16BigEndian(size), w = BinaryPrimitives.ReadUInt16BigEndian(size.AsSpan(2));
|
||||
var crop = new RawRect(left0, top0, left0 + w, top0 + h).Intersect(active);
|
||||
if (!crop.IsEmpty) active = crop;
|
||||
}
|
||||
var colors = new byte[36];
|
||||
for (var i = 0; i < 36; i++) colors[35 - i] = (byte)(pattern[i] & 3);
|
||||
var cfa = new CfaPattern(6, 6, colors).Shift(active.Left, active.Top);
|
||||
|
||||
var black = NativeRaw.Black(1024 >> (14 - int.Min(bits, 14)));
|
||||
if (fuji.Entries.TryGetValue(BlackTag, out var be) && be.Count is > 0 and <= 64 && r.GetUInts(be) is { } levels)
|
||||
{
|
||||
if (levels.Length >= 36)
|
||||
{
|
||||
// A 6×6 grid anchored at the raster origin, re-anchored at the active area.
|
||||
var grid = new float[36];
|
||||
for (var y = 0; y < 6; y++)
|
||||
{
|
||||
for (var x = 0; x < 6; x++) grid[y * 6 + x] = levels[(y + active.Top) % 6 * 6 + (x + active.Left) % 6];
|
||||
}
|
||||
black = new RawBlackLevel(6, 6, grid, null, null);
|
||||
}
|
||||
else
|
||||
{
|
||||
black = NativeRaw.Black(levels.Average(v => (double)v));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
warnings.Add("RAF: black level missing; default used");
|
||||
}
|
||||
|
||||
Vector3D? multipliers = null;
|
||||
if (records.TryGetValue(WhiteBalanceRecord, out var wb) && wb.Length >= 8)
|
||||
{
|
||||
double g = BinaryPrimitives.ReadUInt16BigEndian(wb), red = BinaryPrimitives.ReadUInt16BigEndian(wb.AsSpan(2)), blue = BinaryPrimitives.ReadUInt16BigEndian(wb.AsSpan(6));
|
||||
if (g > 0) multipliers = new Vector3D(red / g, 1, blue / g);
|
||||
}
|
||||
var metadata = MetadataReader.Read(stream, "frame.raf");
|
||||
var loader = new PlainRawLoader(offset, length, width, height, 16, words: true, littleEndian: r.LittleEndian);
|
||||
return NativeRaw.Frame("managed-raf", width, height, cfa, active, black, (1 << bits) - 1, multipliers, metadata.Orientation,
|
||||
metadata.Make ?? "FUJIFILM", metadata.Model, loader, warnings);
|
||||
}
|
||||
|
||||
/// <summary>RAF directory: u32 record count, then (u16 tag, u16 size, data) records, big-endian.</summary>
|
||||
private static Dictionary<ushort, byte[]> Directory(Stream stream, uint offset, uint length)
|
||||
{
|
||||
var result = new Dictionary<ushort, byte[]>();
|
||||
if (offset < HeaderLength || length < 4 || length > MaxDirectoryBytes || offset > stream.Length - length) throw new InvalidDataException("RAF: directory missing");
|
||||
var data = NativeRaw.ReadPayload(stream, offset, length);
|
||||
var count = BinaryPrimitives.ReadUInt32BigEndian(data);
|
||||
var pos = 4;
|
||||
for (var i = 0; i < count && pos + 4 <= data.Length; i++)
|
||||
{
|
||||
var tag = BinaryPrimitives.ReadUInt16BigEndian(data.AsSpan(pos));
|
||||
var size = BinaryPrimitives.ReadUInt16BigEndian(data.AsSpan(pos + 2));
|
||||
pos += 4;
|
||||
if (pos + size > data.Length) break;
|
||||
result.TryAdd(tag, data.AsSpan(pos, size).ToArray());
|
||||
pos += size;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -58,15 +58,15 @@ public sealed class RawDecodeResult(ImageBuffer image, RawImageInfo info, IReadO
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Managed RAW decoding (BRIEF §8.2): DNG (CFA and LinearRaw) through <see cref="DngReader"/>,
|
||||
/// developed by the shared pipeline. Bodies or encodings
|
||||
/// Managed RAW decoding (BRIEF §8.2): DNG (CFA and LinearRaw) through <see cref="DngReader"/>, and the native containers
|
||||
/// Canon CR2, Nikon NEF, Sony ARW, Pentax PEF and Fujifilm RAF, all developed by the same pipeline. Bodies or encodings
|
||||
/// without support are reported by <see cref="Probe"/> so callers can fall back to the embedded preview.
|
||||
/// </summary>
|
||||
public static class RawDecoder
|
||||
{
|
||||
/// <summary>Formats with a managed decoder (individual files may still be unsupported).</summary>
|
||||
public static IReadOnlyList<ImageFileFormat> Formats { get; } =
|
||||
[ImageFileFormat.Dng];
|
||||
[ImageFileFormat.Dng, ImageFileFormat.Cr2, ImageFileFormat.Nef, ImageFileFormat.Arw, ImageFileFormat.Pef, ImageFileFormat.Raf];
|
||||
|
||||
/// <summary>Parses the container and decides whether it can be developed natively; never reads the pixel payload.</summary>
|
||||
public static RawProbe Probe(Stream stream, string? fileName = null)
|
||||
@@ -112,6 +112,11 @@ public static class RawDecoder
|
||||
var frame = format switch
|
||||
{
|
||||
ImageFileFormat.Dng => DngReader.Read(stream),
|
||||
ImageFileFormat.Cr2 => Cr2Reader.Read(stream),
|
||||
ImageFileFormat.Nef => NefReader.Read(stream),
|
||||
ImageFileFormat.Arw => ArwReader.Read(stream),
|
||||
ImageFileFormat.Pef => PefReader.Read(stream),
|
||||
ImageFileFormat.Raf => RafReader.Read(stream),
|
||||
_ => throw new InvalidDataException($"RAW: no managed decoder for {format}"),
|
||||
};
|
||||
return (format, frame);
|
||||
|
||||
@@ -17,8 +17,11 @@ internal static class RawDeveloper
|
||||
/// <summary>Normalised level at or above which a sample counts as clipped.</summary>
|
||||
private const float ClipThreshold = 0.999f;
|
||||
|
||||
/// <summary>LibRaw's adjust_maximum_thr: the data maximum replaces the nominal white level above this fraction of it.</summary>
|
||||
private const double AdjustMaximumThreshold = 0.75;
|
||||
/// <summary>A pile-up of samples at the data maximum counts as sensor saturation only above this fraction of the white level.</summary>
|
||||
private const double SaturationFloor = 0.75;
|
||||
|
||||
/// <summary>Samples that must sit at the data maximum for it to count as saturation rather than the brightest detail.</summary>
|
||||
private const int SaturationPileUp = 16;
|
||||
|
||||
public static ImageBuffer Develop(RawFrame frame, RawSamples samples, RawDecodeOptions options, ICollection<string> warnings, CancellationToken cancellationToken)
|
||||
{
|
||||
@@ -28,8 +31,8 @@ internal static class RawDeveloper
|
||||
var spp = frame.SamplesPerPixel;
|
||||
var active = frame.ActiveArea;
|
||||
var black = samples.MeasuredBlack ?? frame.Black;
|
||||
var white = (double[])frame.White.Clone();
|
||||
if (frame.AdjustWhiteToData) AdjustWhite(samples, active, white, warnings);
|
||||
var white = frame.White;
|
||||
var saturation = frame.DetectSaturation && frame.Linearization is null && spp == 1 ? Saturation(samples, active, black, white[0]) : 1f;
|
||||
|
||||
var list1 = DngOpcodes.Parse(frame.OpcodeList1, 1, warnings);
|
||||
ImageBuffer? stage1 = null;
|
||||
@@ -50,7 +53,7 @@ internal static class RawDeveloper
|
||||
byte[]? clip;
|
||||
try
|
||||
{
|
||||
(linear, clip) = Linearize(frame, samples, stage1, black, white, dop, cancellationToken);
|
||||
(linear, clip) = Linearize(frame, samples, stage1, black, white, saturation * ClipThreshold, dop, cancellationToken);
|
||||
}
|
||||
finally
|
||||
{
|
||||
@@ -63,7 +66,7 @@ internal static class RawDeveloper
|
||||
DngOpcodes.Apply(DngOpcodes.Parse(frame.OpcodeList2, 2, warnings), stage, warnings, cancellationToken);
|
||||
return frame.Cfa is null && spp == 1
|
||||
? DevelopMonochrome(frame, stage, options, warnings, cancellationToken)
|
||||
: DevelopColour(frame, stage, options, warnings, cancellationToken);
|
||||
: DevelopColour(frame, stage, saturation, options, warnings, cancellationToken);
|
||||
}
|
||||
finally
|
||||
{
|
||||
@@ -71,7 +74,7 @@ internal static class RawDeveloper
|
||||
}
|
||||
}
|
||||
|
||||
private static ImageBuffer DevelopColour(RawFrame frame, OpcodeImage stage, RawDecodeOptions options, ICollection<string> warnings, CancellationToken cancellationToken)
|
||||
private static ImageBuffer DevelopColour(RawFrame frame, OpcodeImage stage, float saturation, RawDecodeOptions options, ICollection<string> warnings, CancellationToken cancellationToken)
|
||||
{
|
||||
var dop = options.MaxDegreeOfParallelism;
|
||||
var colour = frame.Color.Solve(warnings);
|
||||
@@ -109,7 +112,7 @@ internal static class RawDeveloper
|
||||
var image = new OpcodeImage(rgb, stage.Left, stage.Top, step, null);
|
||||
try
|
||||
{
|
||||
if (bits is not null) HighlightReconstruction.Apply(rgb, bits, wb, dop, cancellationToken);
|
||||
if (bits is not null) HighlightReconstruction.Apply(rgb, bits, [wb[0] * saturation, wb[1] * saturation, wb[2] * saturation], dop, cancellationToken);
|
||||
var list3 = DngOpcodes.Parse(frame.OpcodeList3, 3, warnings);
|
||||
if (list3.Count > 0)
|
||||
{
|
||||
@@ -190,7 +193,7 @@ internal static class RawDeveloper
|
||||
|
||||
/// <summary>Linear reference values over the active area plus a clip map (bit = CFA colour or sample plane), or null
|
||||
/// when nothing clipped.</summary>
|
||||
private static (ImageBuffer Image, byte[]? Clip) Linearize(RawFrame frame, RawSamples samples, ImageBuffer? stage1, RawBlackLevel black, double[] white, int dop, CancellationToken cancellationToken)
|
||||
private static (ImageBuffer Image, byte[]? Clip) Linearize(RawFrame frame, RawSamples samples, ImageBuffer? stage1, RawBlackLevel black, double[] white, float clipLevel, int dop, CancellationToken cancellationToken)
|
||||
{
|
||||
var active = frame.ActiveArea;
|
||||
int w = active.Width, h = active.Height, spp = frame.SamplesPerPixel;
|
||||
@@ -227,7 +230,7 @@ internal static class RawDeveloper
|
||||
+ (black.DeltaH is { } dh && x < dh.Length ? dh[x] : 0f);
|
||||
var value = (v - b) * scale[s];
|
||||
row[x] = value;
|
||||
if (value >= ClipThreshold)
|
||||
if (value >= clipLevel)
|
||||
{
|
||||
clip[y * w + x] |= (byte)(1 << (cfa is null ? s : cfa.ColorAt(x, y)));
|
||||
rowClip = 1;
|
||||
@@ -239,19 +242,34 @@ internal static class RawDeveloper
|
||||
return (image, anyClip != 0 ? clip : null);
|
||||
}
|
||||
|
||||
private static void AdjustWhite(RawSamples samples, RawRect active, double[] white, ICollection<string> warnings)
|
||||
/// <summary>Normalised saturation level of a native RAW: the data maximum when at least <see cref="SaturationPileUp"/>
|
||||
/// samples reach it and it lies between <see cref="SaturationFloor"/> and 1 of the white level, else 1. It only moves
|
||||
/// the clip threshold; scaling stays tied to the white level so brightness never depends on frame content.</summary>
|
||||
private static float Saturation(RawSamples samples, RawRect active, RawBlackLevel black, double white)
|
||||
{
|
||||
var max = 0f;
|
||||
var count = 0;
|
||||
for (var y = active.Top; y < active.Bottom; y++)
|
||||
{
|
||||
var o = (long)y * samples.Width * samples.SamplesPerPixel;
|
||||
for (var x = active.Left * samples.SamplesPerPixel; x < active.Right * samples.SamplesPerPixel; x++) max = float.Max(max, samples[o + x]);
|
||||
var o = (long)y * samples.Width;
|
||||
for (var x = active.Left; x < active.Right; x++)
|
||||
{
|
||||
var v = samples[o + x];
|
||||
if (v > max + 1)
|
||||
{
|
||||
max = v;
|
||||
count = 1;
|
||||
}
|
||||
else if (v >= max - 1)
|
||||
{
|
||||
count++;
|
||||
max = float.Max(max, v);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (var s = 0; s < white.Length; s++)
|
||||
{
|
||||
if (max > 0 && max < white[s] && max > white[s] * AdjustMaximumThreshold) white[s] = max;
|
||||
}
|
||||
if (max > white.Max()) warnings.Add($"RAW: samples exceed the white level ({max} > {white.Max()})");
|
||||
if (count < SaturationPileUp || max >= white || max < white * SaturationFloor) return 1f;
|
||||
var floor = black.Max(0, 1);
|
||||
return (float)double.Clamp((max - 1 - floor) / (white - floor), 0.5, 1);
|
||||
}
|
||||
|
||||
private static void ScaleMosaic(ImageBuffer mosaic, CfaPattern cfa, float[] wb, int dop, CancellationToken cancellationToken)
|
||||
|
||||
@@ -112,9 +112,9 @@ internal sealed class RawFrame
|
||||
/// <summary>White level per sample plane, in linearised units.</summary>
|
||||
public required double[] White { get; init; }
|
||||
|
||||
/// <summary>Lower the white level to the data maximum when that exceeds 75 % of it (LibRaw adjust_maximum_thr): native
|
||||
/// RAWs state a nominal bit-depth maximum while sensors saturate earlier.</summary>
|
||||
public bool AdjustWhiteToData { get; init; }
|
||||
/// <summary>Find the clip threshold in the data: native RAWs state a nominal bit-depth maximum while sensors saturate
|
||||
/// earlier. Only clip detection uses it; the white level keeps scaling every frame the same (no flicker).</summary>
|
||||
public bool DetectSaturation { get; init; }
|
||||
|
||||
public required DngColorProfile Color { get; init; }
|
||||
public byte[]? OpcodeList1 { get; init; }
|
||||
|
||||
@@ -0,0 +1,183 @@
|
||||
using Titano.Core.Codecs.Raw;
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Testing;
|
||||
using static Titano.Core.Tests.Raw.NativeRawWriters;
|
||||
|
||||
namespace Titano.Core.Tests.Raw;
|
||||
|
||||
/// <summary>Native RAW decoders on synthetic files written in each container's layout: the decoded image must match the
|
||||
/// scene the sensor data was generated from (camera matrix, as-shot white balance, black/white levels, crop).</summary>
|
||||
public sealed class NativeRawTests(TestContext context)
|
||||
{
|
||||
private const int W = 96, H = 64;
|
||||
|
||||
private RawDecodeResult Decode(byte[] file, string name, RawDecodeOptions? options = null)
|
||||
{
|
||||
var result = RawDecoder.Decode(new MemoryStream(file), name, options);
|
||||
context.Log($"{name}: {result.Info} warnings: {string.Join("; ", result.Warnings)}");
|
||||
return result;
|
||||
}
|
||||
|
||||
private static void AssertScene(ImageBuffer scene, ImageBuffer image, double minimum, TestContext context)
|
||||
{
|
||||
Assert.Equal(scene.Width, image.Width);
|
||||
Assert.Equal(scene.Height, image.Height);
|
||||
var psnr = SyntheticRaw.Psnr(scene, image, 4);
|
||||
context.Log($"PSNR {psnr:F1} dB");
|
||||
Assert.GreaterOrEqual(psnr, minimum);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Cr2SlicedLosslessJpegWithMaskedBlack()
|
||||
{
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
// 24 masked columns left and 4 rows on top; Canon's CFA is RGGB at the raster origin.
|
||||
var active = new RawRect(24, 4, 24 + W, 4 + H);
|
||||
var sensor = Sensor(scene, "Canon EOS 5D Mark III", CfaPattern.Bayer("RGGB"), 128, 72, active.Left, active.Top, 2048, 16383);
|
||||
using var result = Decode(Cr2(sensor, active), "IMG_0001.CR2");
|
||||
Assert.Equal("managed-cr2", result.Info.Decoder);
|
||||
Assert.Equal("RGGB", result.Info.Layout);
|
||||
AssertScene(scene, result.Image, 38, context);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(NefEncoding.Lossless, 14)]
|
||||
[Case(NefEncoding.Lossless, 12)]
|
||||
[Case(NefEncoding.Unpacked, 14)]
|
||||
[Case(NefEncoding.Packed, 12)]
|
||||
public void NefEncodings(NefEncoding encoding, int bits)
|
||||
{
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
var sensor = Sensor(scene, "Nikon D850", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 600 >> (14 - bits), (1 << bits) - 1);
|
||||
using var result = Decode(Nef(sensor, bits, encoding), "DSC_0001.NEF");
|
||||
Assert.Equal("managed-nef", result.Info.Decoder);
|
||||
AssertScene(scene, result.Image, 38, context);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(NefEncoding.LossyType1, 12, 0)]
|
||||
[Case(NefEncoding.LossyType2, 14, 0)]
|
||||
[Case(NefEncoding.LossyType2, 14, 40)]
|
||||
public void NefLossyCurves(NefEncoding encoding, int bits, int split)
|
||||
{
|
||||
// A square-law curve: dense codes in the shadows, coarse in the highlights.
|
||||
var size = encoding == NefEncoding.LossyType1 ? 683 : 1 << bits;
|
||||
var curve = Enumerable.Range(0, size).Select(i => (ushort)double.Round(((1 << bits) - 1) * (i / (double)(size - 1)) * (i / (double)(size - 1)))).ToArray();
|
||||
var white = encoding == NefEncoding.LossyType1 ? curve[^1] : InterpolatedCurve(curve, bits).Max();
|
||||
// After the split row the tree has no unshifted codes for 9–12-bit differences: keep that scene gentle.
|
||||
using var scene = split > 0 ? Gentle() : SyntheticRaw.Smooth(W, H);
|
||||
var sensor = Sensor(scene, "Nikon D850", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 600 >> (14 - bits), white);
|
||||
using var result = Decode(Nef(sensor, bits, encoding, curve: curve, split: split), "DSC_0002.NEF");
|
||||
AssertScene(scene, result.Image, 36, context);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(true)]
|
||||
[Case(false)]
|
||||
public void ArwCompressedAndUncompressed(bool compressed)
|
||||
{
|
||||
ushort[] knots = [8000, 10400, 12900, 14100];
|
||||
var curve = ToneCurve(knots);
|
||||
double white = compressed ? curve[0x7FF << 1] : 16383;
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
var sensor = Sensor(scene, "Sony ILCE-7M3", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 512, white);
|
||||
using var result = Decode(Arw(sensor, knots, compressed), "DSC00001.ARW");
|
||||
Assert.Equal("managed-arw", result.Info.Decoder);
|
||||
Assert.Contains(result.Warnings, w => w.Contains("daylight"));
|
||||
AssertScene(scene, result.Image, compressed ? 36 : 38, context);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(true)]
|
||||
[Case(false)]
|
||||
public void PefHuffmanAndUncompressed(bool compressed)
|
||||
{
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
var sensor = Sensor(scene, "Pentax K-1", CfaPattern.Bayer("BGGR"), W, H, 0, 0, 512, 16383);
|
||||
using var result = Decode(Pef(sensor, 14, compressed), "IMGP0001.PEF");
|
||||
Assert.Equal("managed-pef", result.Info.Decoder);
|
||||
Assert.Equal("BGGR", result.Info.Layout);
|
||||
AssertScene(scene, result.Image, 38, context);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(true)]
|
||||
[Case(false)]
|
||||
public void RafXTransAndBayerLayouts(bool xtrans)
|
||||
{
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
var rasterCfa = xtrans ? DemosaicTests.XTrans : CfaPattern.Bayer("GRBG");
|
||||
// Crop starts at an odd offset so the pattern must be re-anchored.
|
||||
var crop = new RawRect(5, 3, 5 + W, 3 + H);
|
||||
var sensor = Sensor(scene, "Fujifilm X-T2", rasterCfa, W + 8, H + 6, crop.Left, crop.Top, 1024, 16383);
|
||||
using var result = Decode(Raf(sensor, Expand(rasterCfa), crop, orientation: 1), "DSCF0001.RAF");
|
||||
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 });
|
||||
Assert.Equal(W / (xtrans ? 3 : 2), binned.Image.Width);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void OrientationComesFromTheContainer()
|
||||
{
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
var sensor = Sensor(scene, "Nikon D850", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 600, 16383);
|
||||
using var result = Decode(Nef(sensor, 14, NefEncoding.Lossless, orientation: 8), "DSC_0003.NEF");
|
||||
Assert.Equal(H, result.Image.Width);
|
||||
Assert.Equal(W, result.Image.Height);
|
||||
Assert.Equal(H, result.Info.Width);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UnknownBodyIsUnsupported()
|
||||
{
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
var active = new RawRect(24, 4, 24 + W, 4 + H);
|
||||
var sensor = Sensor(scene, "Canon EOS 5D Mark III", CfaPattern.Bayer("RGGB"), 128, 72, active.Left, active.Top, 2048, 16383);
|
||||
var probe = RawDecoder.Probe(new MemoryStream(Cr2(sensor, active, model: "Canon EOS R99")), "x.cr2");
|
||||
Assert.False(probe.IsSupported);
|
||||
Assert.Contains("no colour matrix", probe.Reason);
|
||||
Assert.Throws<InvalidDataException>(() => RawDecoder.Decode(new MemoryStream(Cr2(sensor, active, model: "Canon EOS R99")), "x.cr2"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CameraNamesNormalise()
|
||||
{
|
||||
Assert.Equal("Nikon D850", NativeRaw.CameraName("NIKON CORPORATION", "NIKON D850"));
|
||||
Assert.Equal("Canon EOS 5D Mark III", NativeRaw.CameraName("Canon", "Canon EOS 5D Mark III"));
|
||||
Assert.Equal("Sony ILCE-7M3", NativeRaw.CameraName("SONY", "ILCE-7M3"));
|
||||
Assert.Equal("Pentax K-1", NativeRaw.CameraName("RICOH IMAGING COMPANY, LTD.", "PENTAX K-1"));
|
||||
Assert.Equal("Fujifilm X-T2", NativeRaw.CameraName("FUJIFILM", "X-T2"));
|
||||
// Every tabulated matrix maps D65 to a positive camera neutral with green the strongest channel.
|
||||
foreach (var name in CameraMatrices.Names)
|
||||
{
|
||||
var m = CameraMatrices.Find(name)!.Value;
|
||||
var n = m * Titano.Core.Mathematics.Chromaticity.D65.ToXyz();
|
||||
Assert.True(n.X > 0 && n.Z > 0 && n.Y > n.X && n.Y > n.Z, name);
|
||||
}
|
||||
}
|
||||
|
||||
private static ImageBuffer Gentle()
|
||||
{
|
||||
var scene = new ImageBuffer(W, H);
|
||||
for (var y = 0; y < H; y++)
|
||||
{
|
||||
for (var x = 0; x < W; x++)
|
||||
{
|
||||
scene[0, x, y] = 0.3f + 0.03f * x / W;
|
||||
scene[1, x, y] = 0.32f + 0.02f * y / H;
|
||||
scene[2, x, y] = 0.25f + 0.01f * (x + y) / (W + H);
|
||||
}
|
||||
}
|
||||
return scene;
|
||||
}
|
||||
|
||||
/// <summary>The pattern written into the RAF layout record, expanded to 6×6.</summary>
|
||||
private static CfaPattern Expand(CfaPattern cfa)
|
||||
{
|
||||
var colors = new byte[36];
|
||||
for (var i = 0; i < 36; i++) colors[i] = (byte)cfa.ColorAt(i % 6, i / 6);
|
||||
return new CfaPattern(6, 6, colors);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,485 @@
|
||||
using System.Buffers.Binary;
|
||||
using Titano.Core.Codecs.Jpeg;
|
||||
using Titano.Core.Codecs.Raw;
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Core.Mathematics;
|
||||
using Titano.Core.Metadata;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
using Titano.Core.Tests.Metadata.Builders;
|
||||
|
||||
namespace Titano.Core.Tests.Raw;
|
||||
|
||||
/// <summary>Payload encodings of the synthetic NEF writer.</summary>
|
||||
public enum NefEncoding
|
||||
{
|
||||
Lossless,
|
||||
LossyType1,
|
||||
LossyType2,
|
||||
Unpacked,
|
||||
Packed,
|
||||
}
|
||||
|
||||
/// <summary>A synthetic sensor readout: stored samples of a scene through a camera model, plus the as-shot neutral.</summary>
|
||||
internal sealed record SensorData(ushort[] Samples, int Width, int Height, Vector3D Neutral);
|
||||
|
||||
/// <summary>
|
||||
/// Test-side writers for native RAW containers. Each follows the layout its reader documents (and dcraw/LibRaw decode):
|
||||
/// CR2 sliced lossless JPEG with Canon MakerNote, NEF Nikon Huffman with type-3 MakerNote, ARW2 cRAW blocks with tone
|
||||
/// curve, PEF Pentax Huffman with AOC MakerNote, RAF with FujiIFD and RAF directory.
|
||||
/// </summary>
|
||||
internal static class NativeRawWriters
|
||||
{
|
||||
/// <summary>Stored sensor values of <paramref name="scene"/> placed at (left, top) of a raster, CFA anchored at the raster
|
||||
/// origin, outside pixels at black.</summary>
|
||||
public static SensorData Sensor(ImageBuffer scene, string camera, CfaPattern cfa, int width, int height, int left, int top, double black, double white)
|
||||
{
|
||||
var matrix = CameraMatrices.Find(camera) ?? throw new ArgumentException("No matrix for " + camera);
|
||||
var (rgb, neutral) = SyntheticRaw.ToCamera(scene, matrix, Chromaticity.D65);
|
||||
var samples = new ushort[width * height];
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
int sx = x - left, sy = y - top;
|
||||
var v = black;
|
||||
if (sx >= 0 && sy >= 0 && sx < scene.Width && sy < scene.Height) v += rgb[cfa.ColorAt(x, y)][sy * scene.Width + sx] * (white - black);
|
||||
samples[y * width + x] = (ushort)double.Clamp(double.Round(v), 0, white);
|
||||
}
|
||||
}
|
||||
return new SensorData(samples, width, height, neutral);
|
||||
}
|
||||
|
||||
/// <summary>Real JPEG preview with an Exif block (make, model, orientation).</summary>
|
||||
public static byte[] Preview(string make, string model, int orientation, int width = 64, int height = 48)
|
||||
{
|
||||
using var image = new ImageBuffer(width, height);
|
||||
for (var i = 0; i < image.PlaneLength; i++)
|
||||
{
|
||||
image.Plane(0)[i] = 0.5f;
|
||||
image.Plane(1)[i] = 0.3f;
|
||||
image.Plane(2)[i] = 0.2f;
|
||||
}
|
||||
var exif = ExifWriter.BuildTiff(new FrameMetadata { Make = make, Model = model, Orientation = orientation });
|
||||
return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [[.. "Exif\0\0"u8, .. exif]] });
|
||||
}
|
||||
|
||||
/// <summary>Canon CR2: "CR" header, IFD0 JPEG preview, two dummy IFDs, IFD3 lossless raw in two slices.</summary>
|
||||
public static byte[] Cr2(SensorData s, RawRect active, int orientation = 1, string model = "Canon EOS 5D Mark III")
|
||||
{
|
||||
const int components = 2;
|
||||
var sliceWidth = s.Width / 2;
|
||||
var stream = new ushort[s.Samples.Length];
|
||||
var k = 0;
|
||||
foreach (var x0 in new[] { 0, sliceWidth })
|
||||
{
|
||||
for (var y = 0; y < s.Height; y++)
|
||||
{
|
||||
for (var x = 0; x < sliceWidth; x++) stream[k++] = s.Samples[y * s.Width + x0 + x];
|
||||
}
|
||||
}
|
||||
var jpeg = JpegLosslessEncoder.Encode(stream, s.Width / components, s.Height, components, 14);
|
||||
var sensor = new ushort[17];
|
||||
sensor[1] = (ushort)s.Width;
|
||||
sensor[2] = (ushort)s.Height;
|
||||
sensor[5] = (ushort)active.Left;
|
||||
sensor[6] = (ushort)active.Top;
|
||||
sensor[7] = (ushort)(active.Right - 1);
|
||||
sensor[8] = (ushort)(active.Bottom - 1);
|
||||
var colorData = new ushort[1338];
|
||||
colorData[63] = (ushort)double.Round(1024 * s.Neutral.Y / s.Neutral.X);
|
||||
colorData[64] = colorData[65] = 1024;
|
||||
colorData[66] = (ushort)double.Round(1024 * s.Neutral.Y / s.Neutral.Z);
|
||||
var makerNote = new IfdSpec().Short(0x00E0, sensor).Short(0x4001, colorData);
|
||||
var exif = new IfdSpec().Ascii(TiffTags.DateTimeOriginal, "2024:05:01 12:00:00").Embedded(TiffTags.MakerNote, [], makerNote, relativeToTiff: true, littleEndian: true);
|
||||
var preview = Preview("Canon", model, orientation);
|
||||
var ifd0 = new IfdSpec().Ascii(TiffTags.Make, "Canon").Ascii(TiffTags.Model, model).Short(TiffTags.Orientation, (ushort)orientation)
|
||||
.Short(TiffTags.Compression, 6).Strip(preview).Child(TiffTags.ExifIfd, exif);
|
||||
var ifd1 = new IfdSpec().Short(TiffTags.Compression, 6);
|
||||
var ifd2 = new IfdSpec().Short(TiffTags.Compression, 1);
|
||||
var ifd3 = new IfdSpec().Short(TiffTags.Compression, 6).Strip(jpeg).Short(0xC640, 1, (ushort)sliceWidth, (ushort)(s.Width - sliceWidth));
|
||||
ifd0.Next = ifd1;
|
||||
ifd1.Next = ifd2;
|
||||
ifd2.Next = ifd3;
|
||||
return TiffFile.Build(ifd0, true, headerExtra: [(byte)'C', (byte)'R', 2, 0, 0, 0, 0, 0]);
|
||||
}
|
||||
|
||||
/// <summary>Canonical codes of a dcraw-layout Huffman specification: symbol → (code, length).</summary>
|
||||
public static Dictionary<int, (int Code, int Length)> Codes(byte[] spec)
|
||||
{
|
||||
var max = 16;
|
||||
while (spec[max - 1] == 0) max--;
|
||||
var codes = new Dictionary<int, (int, int)>();
|
||||
var h = 0;
|
||||
var symbol = 16;
|
||||
for (var len = 1; len <= max; len++)
|
||||
{
|
||||
for (var i = 0; i < spec[len - 1]; i++, symbol++)
|
||||
{
|
||||
codes.TryAdd(spec[symbol], (h >> (max - len), len));
|
||||
h += 1 << (max - len);
|
||||
}
|
||||
}
|
||||
return codes;
|
||||
}
|
||||
|
||||
/// <summary>JPEG difference category and its bits (negative values one's-complement style).</summary>
|
||||
public static (int Length, int Bits) Category(int diff)
|
||||
{
|
||||
if (diff == 0) return (0, 0);
|
||||
var len = 32 - int.LeadingZeroCount(int.Abs(diff));
|
||||
return (len, diff > 0 ? diff : diff + (1 << len) - 1);
|
||||
}
|
||||
|
||||
/// <summary>Two-column horizontal prediction seeded by per-row-parity vertical predictors (Nikon and Pentax).</summary>
|
||||
public static byte[] PredictiveHuffman(ushort[] values, int width, int height, Func<int, Dictionary<int, (int Code, int Length)>> codesForRow, ushort[] initial)
|
||||
{
|
||||
var w = new BitWriter();
|
||||
var vpred = (int[])[initial[0], initial[1], initial[2], initial[3]];
|
||||
var hpred = new int[2];
|
||||
for (var row = 0; row < height; row++)
|
||||
{
|
||||
var codes = codesForRow(row);
|
||||
for (var col = 0; col < width; col++)
|
||||
{
|
||||
int v = values[row * width + col], predicted;
|
||||
if (col < 2)
|
||||
{
|
||||
predicted = vpred[(row & 1) * 2 + col];
|
||||
vpred[(row & 1) * 2 + col] = v;
|
||||
hpred[col] = v;
|
||||
}
|
||||
else
|
||||
{
|
||||
predicted = hpred[col & 1];
|
||||
hpred[col & 1] = v;
|
||||
}
|
||||
var (len, bits) = Category(v - predicted);
|
||||
var (code, codeLength) = codes[len];
|
||||
w.Write(code, codeLength);
|
||||
w.Write(bits, len);
|
||||
}
|
||||
}
|
||||
return w.ToArray();
|
||||
}
|
||||
|
||||
/// <summary>Big-endian Nikon NEF: IFD0 thumbnail, SubIFD CFA raw, Exif with a type-3 MakerNote.</summary>
|
||||
public static byte[] Nef(SensorData s, int bits, NefEncoding encoding, int orientation = 1, ushort[]? curve = null, int split = 0)
|
||||
{
|
||||
byte[] data;
|
||||
uint compression = 34713;
|
||||
var meta = new List<byte> { 0x46, 0x30 };
|
||||
ushort[] vpred = [100, 200, 300, 400];
|
||||
switch (encoding)
|
||||
{
|
||||
case NefEncoding.Lossless:
|
||||
data = PredictiveHuffman(s.Samples, s.Width, s.Height, _ => Codes(NefTrees(bits == 14 ? 5 : 2)), vpred);
|
||||
break;
|
||||
case NefEncoding.LossyType1:
|
||||
{
|
||||
meta = [0x44, 0x10];
|
||||
var indices = Indices(s.Samples, curve!);
|
||||
data = PredictiveHuffman(indices, s.Width, s.Height, _ => Codes(NefTrees(bits == 14 ? 3 : 0)), vpred);
|
||||
break;
|
||||
}
|
||||
case NefEncoding.LossyType2:
|
||||
{
|
||||
meta = [0x44, 0x20];
|
||||
var indices = Indices(s.Samples, InterpolatedCurve(curve!, bits));
|
||||
var tree = bits == 14 ? 3 : 0;
|
||||
data = PredictiveHuffman(indices, s.Width, s.Height, row => Codes(NefTrees(split > 0 && row >= split ? tree + 1 : tree)), vpred);
|
||||
break;
|
||||
}
|
||||
case NefEncoding.Unpacked:
|
||||
data = new byte[s.Samples.Length * 2];
|
||||
for (var i = 0; i < s.Samples.Length; i++) BinaryPrimitives.WriteUInt16BigEndian(data.AsSpan(2 * i), s.Samples[i]);
|
||||
break;
|
||||
default:
|
||||
compression = 1;
|
||||
data = Packed(s.Samples, s.Width, s.Height, bits);
|
||||
break;
|
||||
}
|
||||
foreach (var v in vpred) meta.AddRange([(byte)(v >> 8), (byte)v]);
|
||||
if (encoding == NefEncoding.LossyType1)
|
||||
{
|
||||
meta.AddRange([(byte)(curve!.Length >> 8), (byte)curve.Length]);
|
||||
foreach (var v in curve) meta.AddRange([(byte)(v >> 8), (byte)v]);
|
||||
}
|
||||
else if (encoding == NefEncoding.LossyType2)
|
||||
{
|
||||
// Curve sampled every 'step' codes; split row at byte 562.
|
||||
meta.AddRange([(byte)(CurvePoints >> 8), unchecked((byte)CurvePoints)]);
|
||||
foreach (var v in CurveSamples(curve!, bits)) meta.AddRange([(byte)(v >> 8), (byte)v]);
|
||||
while (meta.Count < 562) meta.Add(0);
|
||||
meta.AddRange([(byte)(split >> 8), (byte)split]);
|
||||
}
|
||||
else
|
||||
{
|
||||
meta.AddRange([0, 0]);
|
||||
}
|
||||
var nikon = new IfdSpec()
|
||||
.Rational(0x000C, ((uint)double.Round(1e5 * s.Neutral.Y / s.Neutral.X), 100000u), ((uint)double.Round(1e5 * s.Neutral.Y / s.Neutral.Z), 100000u), (1u, 1u), (1u, 1u))
|
||||
.Short(0x003D, 600, 600, 600, 600)
|
||||
.Short(0x0093, (ushort)(encoding == NefEncoding.Lossless ? 3 : encoding == NefEncoding.LossyType1 ? 1 : encoding == NefEncoding.LossyType2 ? 4 : 2))
|
||||
.Undefined(0x0096, [.. meta]);
|
||||
var exif = new IfdSpec().Undefined(TiffTags.MakerNote, [.. "Nikon\0"u8, 2, 0x11, 0, 0, .. TiffFile.Build(nikon, littleEndian: false)]);
|
||||
var raw = new IfdSpec().Long(TiffTags.NewSubfileType, 0)
|
||||
.Long(TiffTags.ImageWidth, (uint)s.Width).Long(TiffTags.ImageLength, (uint)s.Height)
|
||||
.Short(TiffTags.BitsPerSample, (ushort)bits).Short(TiffTags.Compression, (ushort)compression)
|
||||
.Short(TiffTags.PhotometricInterpretation, 32803)
|
||||
.Short(TiffTags.CfaRepeatPatternDim, 2, 2).Bytes(TiffTags.CfaPattern, 0, 1, 1, 2)
|
||||
.Strip(data);
|
||||
var ifd0 = new IfdSpec().Ascii(TiffTags.Make, "NIKON CORPORATION").Ascii(TiffTags.Model, "NIKON D850")
|
||||
.Short(TiffTags.Orientation, (ushort)orientation).Long(TiffTags.NewSubfileType, 1)
|
||||
.Child(TiffTags.SubIfds, raw).Child(TiffTags.ExifIfd, exif);
|
||||
return TiffFile.Build(ifd0, littleEndian: false);
|
||||
}
|
||||
|
||||
private static byte[] NefTrees(int index) => NefReader.Trees[index];
|
||||
|
||||
private const int CurvePoints = 257;
|
||||
|
||||
private static ushort[] CurveSamples(ushort[] curve, int bits)
|
||||
{
|
||||
var step = (1 << bits & 0x7FFF) / (CurvePoints - 1);
|
||||
return [.. Enumerable.Range(0, CurvePoints).Select(i => curve[int.Min(i * step, curve.Length - 1)])];
|
||||
}
|
||||
|
||||
/// <summary>The curve a lossy type-2 decoder rebuilds: samples every step codes, linearly interpolated.</summary>
|
||||
public static ushort[] InterpolatedCurve(ushort[] curve, int bits)
|
||||
{
|
||||
var max = 1 << bits & 0x7FFF;
|
||||
var step = max / (CurvePoints - 1);
|
||||
var samples = CurveSamples(curve, bits);
|
||||
var result = new ushort[max];
|
||||
for (var i = 0; i < max; i++)
|
||||
{
|
||||
int k = i % step, a = i / step;
|
||||
result[i] = (ushort)((samples[a] * (step - k) + samples[int.Min(a + 1, samples.Length - 1)] * k) / step);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>Curve indices whose values are nearest to the samples (monotonic curve).</summary>
|
||||
public static ushort[] Indices(ushort[] samples, ushort[] curve)
|
||||
{
|
||||
var result = new ushort[samples.Length];
|
||||
for (var i = 0; i < samples.Length; i++)
|
||||
{
|
||||
var target = samples[i];
|
||||
int lo = 0, hi = curve.Length - 1;
|
||||
while (lo < hi)
|
||||
{
|
||||
var mid = (lo + hi) / 2;
|
||||
if (curve[mid] < target) lo = mid + 1;
|
||||
else hi = mid;
|
||||
}
|
||||
if (lo > 0 && target - curve[lo - 1] < curve[lo] - target) lo--;
|
||||
result[i] = (ushort)lo;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>MSB-first packed samples (TIFF convention), rows padded to whole bytes.</summary>
|
||||
public static byte[] Packed(ushort[] samples, int width, int height, int bits)
|
||||
{
|
||||
var w = new BitWriter();
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
for (var x = 0; x < width; x++) w.Write(samples[y * width + x], bits);
|
||||
w.Align();
|
||||
}
|
||||
return w.ToArray();
|
||||
}
|
||||
|
||||
/// <summary>Sony ARW2 (cRAW): 16-pixel blocks of one colour in 32-column groups, values through the inverse tone curve.</summary>
|
||||
public static byte[] Arw(SensorData s, ushort[] knots, bool compressed, int orientation = 1)
|
||||
{
|
||||
byte[] data;
|
||||
uint compression = 32767;
|
||||
if (compressed)
|
||||
{
|
||||
var curve = ToneCurve(knots);
|
||||
var even = new ushort[2048];
|
||||
for (var i = 0; i < even.Length; i++) even[i] = curve[i << 1];
|
||||
var codes = Indices(s.Samples, even);
|
||||
data = new byte[s.Width * s.Height];
|
||||
for (var y = 0; y < s.Height; y++)
|
||||
{
|
||||
for (var group = 0; group < s.Width; group += 32)
|
||||
{
|
||||
for (var parity = 0; parity < 2; parity++)
|
||||
{
|
||||
var block = data.AsSpan(y * s.Width + group + parity * 16, 16);
|
||||
var pix = new int[16];
|
||||
for (var i = 0; i < 16; i++) pix[i] = codes[y * s.Width + group + parity + 2 * i];
|
||||
EncodeBlock(pix, block);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
data = new byte[s.Samples.Length * 2];
|
||||
for (var i = 0; i < s.Samples.Length; i++) BinaryPrimitives.WriteUInt16LittleEndian(data.AsSpan(2 * i), s.Samples[i]);
|
||||
}
|
||||
var raw = new IfdSpec().Long(TiffTags.NewSubfileType, 0)
|
||||
.Long(TiffTags.ImageWidth, (uint)s.Width).Long(TiffTags.ImageLength, (uint)s.Height)
|
||||
.Short(TiffTags.BitsPerSample, (ushort)(compressed ? 8 : 14)).Short(TiffTags.Compression, (ushort)compression)
|
||||
.Short(TiffTags.PhotometricInterpretation, 32803)
|
||||
.Short(TiffTags.CfaRepeatPatternDim, 2, 2).Bytes(TiffTags.CfaPattern, 0, 1, 1, 2)
|
||||
.Short(0x7010, knots).Short(0x7310, 512, 512, 512, 512)
|
||||
.Strip(data);
|
||||
var ifd0 = new IfdSpec().Ascii(TiffTags.Make, "SONY").Ascii(TiffTags.Model, "ILCE-7M3").Short(TiffTags.Orientation, (ushort)orientation)
|
||||
.Long(TiffTags.NewSubfileType, 1).Child(TiffTags.SubIfds, raw);
|
||||
return TiffFile.Build(ifd0);
|
||||
}
|
||||
|
||||
/// <summary>The reader's tone curve (slopes 1, 2, 4, 8, 16 between the knots).</summary>
|
||||
public static ushort[] ToneCurve(ushort[] knots)
|
||||
{
|
||||
int[] k = [0, knots[0] >> 2 & 0xFFF, knots[1] >> 2 & 0xFFF, knots[2] >> 2 & 0xFFF, knots[3] >> 2 & 0xFFF, 4095];
|
||||
var curve = new ushort[4096];
|
||||
for (var i = 0; i < curve.Length; i++) curve[i] = (ushort)i;
|
||||
for (var i = 0; i < 5; i++)
|
||||
{
|
||||
for (var j = k[i] + 1; j <= k[i + 1]; j++) curve[j] = (ushort)(curve[j - 1] + (1 << i));
|
||||
}
|
||||
return curve;
|
||||
}
|
||||
|
||||
private static void EncodeBlock(int[] pix, Span<byte> block)
|
||||
{
|
||||
int imax = 0, imin = 0;
|
||||
for (var i = 1; i < 16; i++)
|
||||
{
|
||||
if (pix[i] > pix[imax]) imax = i;
|
||||
if (pix[i] < pix[imin]) imin = i;
|
||||
}
|
||||
if (imax == imin) imin = imax == 0 ? 1 : 0;
|
||||
int max = pix[imax], min = pix[imin];
|
||||
var sh = 0;
|
||||
while (sh < 4 && 0x80 << sh <= max - min) sh++;
|
||||
var bits = new System.Collections.BitArray(130);
|
||||
void Put(int value, int at, int count)
|
||||
{
|
||||
for (var b = 0; b < count; b++) bits[at + b] = (value >> b & 1) != 0;
|
||||
}
|
||||
Put(max, 0, 11);
|
||||
Put(min, 11, 11);
|
||||
Put(imax, 22, 4);
|
||||
Put(imin, 26, 4);
|
||||
var bit = 30;
|
||||
for (var i = 0; i < 16; i++)
|
||||
{
|
||||
if (i == imax || i == imin) continue;
|
||||
Put(int.Min((pix[i] - min) >> sh, 0x7F), bit, 7);
|
||||
bit += 7;
|
||||
}
|
||||
for (var i = 0; i < 16; i++)
|
||||
{
|
||||
byte v = 0;
|
||||
for (var b = 0; b < 8; b++) v |= (byte)(bits[i * 8 + b] ? 1 << b : 0);
|
||||
block[i] = v;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Pentax PEF: big-endian, raw in IFD0, AOC MakerNote with black, WB and the Huffman table.</summary>
|
||||
public static byte[] Pef(SensorData s, int bits, bool compressed, int orientation = 1)
|
||||
{
|
||||
// Prefix code over difference lengths 0..14 (Kraft sum below 1).
|
||||
int[] lengths = [3, 3, 3, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 10];
|
||||
var codes = new Dictionary<int, (int Code, int Length)>();
|
||||
var code = 0;
|
||||
var previous = lengths[0];
|
||||
for (var c = 0; c < lengths.Length; c++)
|
||||
{
|
||||
code <<= lengths[c] - previous;
|
||||
previous = lengths[c];
|
||||
codes[c] = (code, lengths[c]);
|
||||
code++;
|
||||
}
|
||||
var table = new List<byte> { 0, (byte)((lengths.Length - 12) & 15) };
|
||||
table.AddRange(new byte[12]);
|
||||
for (var c = 0; c < lengths.Length; c++)
|
||||
{
|
||||
var aligned = codes[c].Code << (12 - codes[c].Length);
|
||||
table.AddRange([(byte)(aligned >> 8), (byte)aligned]);
|
||||
}
|
||||
foreach (var len in lengths) table.Add((byte)len);
|
||||
var data = compressed ? PredictiveHuffman(s.Samples, s.Width, s.Height, _ => codes, [0, 0, 0, 0]) : Packed(s.Samples, s.Width, s.Height, bits);
|
||||
var levels = new ushort[] { (ushort)double.Round(1000 * s.Neutral.Y / s.Neutral.X), 1000, 1000, (ushort)double.Round(1000 * s.Neutral.Y / s.Neutral.Z) };
|
||||
var pentax = new IfdSpec().Short(0x0200, 512, 512, 512, 512).Short(0x0201, levels).Undefined(0x0220, [.. table]);
|
||||
var exif = new IfdSpec().Embedded(TiffTags.MakerNote, [.. "AOC\0MM"u8], pentax, relativeToTiff: true, littleEndian: false);
|
||||
var ifd0 = new IfdSpec().Ascii(TiffTags.Make, "RICOH IMAGING COMPANY, LTD.").Ascii(TiffTags.Model, "PENTAX K-1")
|
||||
.Short(TiffTags.Orientation, (ushort)orientation).Long(TiffTags.NewSubfileType, 0)
|
||||
.Long(TiffTags.ImageWidth, (uint)s.Width).Long(TiffTags.ImageLength, (uint)s.Height)
|
||||
.Short(TiffTags.BitsPerSample, (ushort)bits).Short(TiffTags.Compression, (ushort)(compressed ? 65535 : 1))
|
||||
.Short(TiffTags.PhotometricInterpretation, 32803)
|
||||
.Short(TiffTags.CfaRepeatPatternDim, 2, 2).Bytes(TiffTags.CfaPattern, 2, 1, 1, 0)
|
||||
.Strip(data).Child(TiffTags.ExifIfd, exif);
|
||||
return TiffFile.Build(ifd0, littleEndian: false);
|
||||
}
|
||||
|
||||
/// <summary>Fujifilm RAF: header, JPEG with Exif, RAF directory (crop, layout, WB), FujiIFD block with 16-bit data.</summary>
|
||||
public static byte[] Raf(SensorData s, CfaPattern rasterCfa, RawRect crop, int orientation = 1, string model = "X-T2")
|
||||
{
|
||||
var jpeg = Preview("FUJIFILM", model, orientation);
|
||||
var pattern = new byte[36];
|
||||
for (var i = 0; i < 36; i++) pattern[35 - i] = (byte)rasterCfa.ColorAt(i % 6, i / 6);
|
||||
var records = new List<byte>();
|
||||
void Record(ushort tag, byte[] payload) => records.AddRange([.. Box.U16(tag), .. Box.U16((ushort)payload.Length), .. payload]);
|
||||
Record(0x0100, [.. Box.U16((ushort)s.Height), .. Box.U16((ushort)s.Width)]);
|
||||
Record(0x0110, [.. Box.U16((ushort)crop.Top), .. Box.U16((ushort)crop.Left)]);
|
||||
Record(0x0111, [.. Box.U16((ushort)crop.Height), .. Box.U16((ushort)crop.Width)]);
|
||||
Record(0x0130, [0, 8, 0, 0]);
|
||||
Record(0x0131, pattern);
|
||||
Record(0x2FF0, [.. Box.U16(302), .. Box.U16((ushort)double.Round(302 * s.Neutral.Y / s.Neutral.X)), .. Box.U16(302), .. Box.U16((ushort)double.Round(302 * s.Neutral.Y / s.Neutral.Z))]);
|
||||
byte[] directory = [.. Box.U32(6), .. records];
|
||||
var data = new byte[s.Samples.Length * 2];
|
||||
for (var i = 0; i < s.Samples.Length; i++) BinaryPrimitives.WriteUInt16BigEndian(data.AsSpan(2 * i), s.Samples[i]);
|
||||
var fuji = new IfdSpec().Long(0xF001, (uint)s.Width).Long(0xF002, (uint)s.Height).Long(0xF003, 14)
|
||||
.Long(0xF00A, [.. Enumerable.Repeat(1024u, 36)]).Blob(0xF007, 0xF008, data);
|
||||
var block = TiffFile.Build(new IfdSpec().Child(0xF000, fuji), littleEndian: false);
|
||||
var jpegOffset = 0x6C;
|
||||
var directoryOffset = jpegOffset + jpeg.Length;
|
||||
var blockOffset = directoryOffset + directory.Length;
|
||||
var header = new byte[0x6C];
|
||||
"FUJIFILMCCD-RAW 0201FF129502"u8.CopyTo(header);
|
||||
System.Text.Encoding.ASCII.GetBytes(model).CopyTo(header.AsSpan(0x1C));
|
||||
uint[] fields = [(uint)jpegOffset, (uint)jpeg.Length, (uint)directoryOffset, (uint)directory.Length, (uint)blockOffset, (uint)block.Length];
|
||||
for (var i = 0; i < fields.Length; i++) BinaryPrimitives.WriteUInt32BigEndian(header.AsSpan(0x54 + 4 * i), fields[i]);
|
||||
return [.. header, .. jpeg, .. directory, .. block];
|
||||
}
|
||||
|
||||
/// <summary>MSB-first bit writer.</summary>
|
||||
internal sealed class BitWriter
|
||||
{
|
||||
private readonly List<byte> _bytes = [];
|
||||
private int _accumulator;
|
||||
private int _count;
|
||||
|
||||
public void Write(int value, int bits)
|
||||
{
|
||||
for (var b = bits - 1; b >= 0; b--)
|
||||
{
|
||||
_accumulator = _accumulator << 1 | (value >> b & 1);
|
||||
if (++_count == 8)
|
||||
{
|
||||
_bytes.Add((byte)_accumulator);
|
||||
_accumulator = _count = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void Align()
|
||||
{
|
||||
if (_count > 0) Write(0, 8 - _count);
|
||||
}
|
||||
|
||||
public byte[] ToArray()
|
||||
{
|
||||
Align();
|
||||
return [.. _bytes, 0, 0, 0, 0];
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
using Titano.Core.Codecs.Raw;
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Testing;
|
||||
using static Titano.Core.Tests.Raw.NativeRawWriters;
|
||||
|
||||
namespace Titano.Core.Tests.Raw;
|
||||
|
||||
/// <summary>Truncated and corrupted RAW files may only raise <see cref="InvalidDataException"/> (or decode).</summary>
|
||||
public sealed class RawFuzzTests(TestContext context)
|
||||
{
|
||||
private const int W = 48, H = 32;
|
||||
|
||||
private static byte[] Sample(string format)
|
||||
{
|
||||
using var scene = SyntheticRaw.Smooth(W, H);
|
||||
return format switch
|
||||
{
|
||||
"dng" => SyntheticDng.Write(scene, new DngSpec { TileSize = 16, OpcodeList2 = GainMapList(), OpcodeList3 = new OpcodeListBuilder().Add(3, 0, p => p.F64(0.1).F64(0).F64(0).F64(0).F64(0).F64(0.5).F64(0.5)).Build() }),
|
||||
"linear.dng" => SyntheticDng.Write(scene, new DngSpec { Cfa = null, Compression = 8 }),
|
||||
"cr2" => Cr2(Sensor(scene, "Canon EOS 5D Mark III", CfaPattern.Bayer("RGGB"), 80, 36, 24, 4, 2048, 16383), new RawRect(24, 4, 24 + W, 4 + H)),
|
||||
"nef" => Nef(Sensor(scene, "Nikon D850", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 600, 16383), 14, NefEncoding.Lossless),
|
||||
"arw" => Arw(Sensor(scene, "Sony ILCE-7M3", CfaPattern.Bayer("RGGB"), 64, H, 0, 0, 512, 16000), [8000, 10400, 12900, 14100], compressed: true),
|
||||
"pef" => Pef(Sensor(scene, "Pentax K-1", CfaPattern.Bayer("BGGR"), W, H, 0, 0, 512, 16383), 14, compressed: true),
|
||||
_ => Raf(Sensor(scene, "Fujifilm X-T2", DemosaicTests.XTrans, W + 6, H + 6, 3, 3, 1024, 16383), DemosaicTests.XTrans, new RawRect(3, 3, 3 + W, 3 + H)),
|
||||
};
|
||||
}
|
||||
|
||||
private static byte[] GainMapList() => new OpcodeListBuilder().Add(9, 0, p =>
|
||||
{
|
||||
OpcodeListBuilder.Area(p, 0, 0, H, W);
|
||||
p.U32(2).U32(2).F64(1).F64(1).F64(0).F64(0).U32(1).F32(1).F32(1.1f).F32(1.2f).F32(1.3f);
|
||||
}).Build();
|
||||
|
||||
[Theory]
|
||||
[Case("dng")]
|
||||
[Case("linear.dng")]
|
||||
[Case("cr2")]
|
||||
[Case("nef")]
|
||||
[Case("arw")]
|
||||
[Case("pef")]
|
||||
[Case("raf")]
|
||||
public void TruncatedAndCorruptedFilesOnlyRaiseInvalidData(string format)
|
||||
{
|
||||
var file = Sample(format);
|
||||
var name = "fuzz." + format.Split('.').Last();
|
||||
var options = new RawDecodeOptions { Quality = DemosaicQuality.Draft, MaxDegreeOfParallelism = 1 };
|
||||
using (var clean = RawDecoder.Decode(new MemoryStream(file), name, options)) Assert.Equal(format == "arw" ? 64 : W, clean.Image.Width);
|
||||
var random = new Random(format.Length * 7919);
|
||||
var outcomes = new Dictionary<string, int>();
|
||||
for (var i = 0; i < 120; i++)
|
||||
{
|
||||
byte[] variant;
|
||||
if (i < 40)
|
||||
{
|
||||
variant = file[..(int)((long)file.Length * i / 40)];
|
||||
}
|
||||
else
|
||||
{
|
||||
variant = (byte[])file.Clone();
|
||||
var flips = 1 + random.Next(4);
|
||||
for (var k = 0; k < flips; k++)
|
||||
{
|
||||
// Bias corruption toward the headers, where structure lives.
|
||||
var at = random.Next(2) == 0 ? random.Next(int.Min(variant.Length, 512)) : random.Next(variant.Length);
|
||||
variant[at] = (byte)random.Next(256);
|
||||
}
|
||||
}
|
||||
var outcome = Run(variant, name, options);
|
||||
outcomes[outcome] = outcomes.GetValueOrDefault(outcome) + 1;
|
||||
}
|
||||
context.Log($"{format}: " + string.Join(", ", outcomes.Select(o => $"{o.Key} {o.Value}")));
|
||||
}
|
||||
|
||||
private static string Run(byte[] data, string name, RawDecodeOptions options)
|
||||
{
|
||||
try
|
||||
{
|
||||
RawDecoder.Probe(new MemoryStream(data), name);
|
||||
using var result = RawDecoder.Decode(new MemoryStream(data), name, options);
|
||||
return "decoded";
|
||||
}
|
||||
catch (InvalidDataException)
|
||||
{
|
||||
return "invalid";
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Assert.Fail($"{ex.GetType().Name}: {ex.Message}\n{ex.StackTrace}");
|
||||
return "";
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user