diff --git a/src/Titano.Core/Codecs/Dng/LinearDngWriter.cs b/src/Titano.Core/Codecs/Dng/LinearDngWriter.cs new file mode 100644 index 00000000..8e112346 --- /dev/null +++ b/src/Titano.Core/Codecs/Dng/LinearDngWriter.cs @@ -0,0 +1,155 @@ +using System.Buffers.Binary; +using Titano.Core.Codecs.Jpeg; +using Titano.Core.Codecs.Tiff; +using Titano.Core.Imaging; +using Titano.Core.Metadata.Tiff; + +namespace Titano.Core.Codecs.Dng; + +/// Tile compression of a linear DNG. +public enum DngCompression +{ + Uncompressed = 1, + + /// Lossless JPEG (SOF3, predictor 1) per tile, DNG Compression = 7. + LosslessJpeg = 7, +} + +/// Options for . +public sealed record LinearDngOptions +{ + public static LinearDngOptions Default { get; } = new(); + + public DngCompression Compression { get; init; } = DngCompression.LosslessJpeg; + + /// UniqueCameraModel (and Model): raw editors key their profiles on it. + public string UniqueCameraModel { get; init; } = "Titano"; + + /// TIFF-structured Exif block (JPEG APP1 payload) whose capture metadata is embedded. + public byte[]? Exif { get; init; } + + /// Tile edge in pixels (multiple of 16). + public int TileSize { get; init; } = 256; + + /// Worker limit for tile encoding (-1 = all cores). + public int MaxDegreeOfParallelism { get; init; } = -1; +} + +/// +/// Writes linear Rec.709/sRGB-primaries RGB as a 16-bit LinearRaw DNG 1.4 that raw editors render with correct +/// colours: ColorMatrix1 = XYZ(D65) → linear sRGB, ForwardMatrix1 = linear sRGB → XYZ(D50), illuminant D65, +/// AsShotNeutral 1/1/1, WhiteLevel 65535, BaselineExposure 0. Values above 1.0 are clipped. +/// +public static class LinearDngWriter +{ + /// XYZ (D65) → linear sRGB, i.e. the inverse of the sRGB → XYZ matrix (IEC 61966-2-1). + internal static readonly double[] XyzToLinearSrgb = + [ + 3.2404542, -1.5371385, -0.4985314, + -0.9692660, 1.8760108, 0.0415560, + 0.0556434, -0.2040259, 1.0572252, + ]; + + /// Linear sRGB → XYZ (D50), Bradford-adapted: neutral (1,1,1) maps to the D50 white point. + internal static readonly double[] LinearSrgbToXyzD50 = + [ + 0.4360747, 0.3850649, 0.1430804, + 0.2225045, 0.7168786, 0.0606169, + 0.0139322, 0.0971045, 0.7141733, + ]; + + public static byte[] Write(ImageBuffer image, LinearDngOptions? options = null) + { + using var ms = new MemoryStream(); + Write(ms, image, options); + return ms.ToArray(); + } + + /// Writes a linear-light buffer (gray is stored as neutral RGB; alpha is dropped). + public static void Write(Stream output, ImageBuffer image, LinearDngOptions? options = null) + { + var o = options ?? LinearDngOptions.Default; + if (o.TileSize is < 16 or > 4096 || o.TileSize % 16 != 0) throw new ArgumentOutOfRangeException(nameof(options), "Tile size must be a multiple of 16 in 16..4096"); + if (!output.CanSeek) + { + using var buffer = new MemoryStream(); + Write(buffer, image, o); + buffer.Position = 0; + buffer.CopyTo(output); + return; + } + int w = image.Width, h = image.Height, t = o.TileSize; + int across = (w + t - 1) / t, down = (h + t - 1) / t; + var offsets = new uint[across * down]; + var counts = new uint[across * down]; + var start = output.Position; + output.Write("II*\0\0\0\0\0"u8); + var parallel = new ParallelOptions { MaxDegreeOfParallelism = o.MaxDegreeOfParallelism }; + var band = new ushort[w * t * 3]; + var tiles = new byte[across][]; + for (var ty = 0; ty < down; ty++) + { + var y0 = ty * t; + var rows = Math.Min(t, h - y0); + Parallel.For(0, rows, parallel, r => PixelConvert.EncodeRow16(image, y0 + r, band.AsSpan(r * w * 3, w * 3), 3, TransferFunction.Linear)); + Parallel.For(0, across, parallel, tx => tiles[tx] = EncodeTile(band, w, rows, tx * t, t, o.Compression)); + for (var tx = 0; tx < across; tx++) + { + if (output.Position - start > uint.MaxValue - (long)tiles[tx].Length) throw new InvalidOperationException("DNG exceeds 4 GB"); + offsets[ty * across + tx] = (uint)(output.Position - start); + counts[ty * across + tx] = (uint)tiles[tx].Length; + output.Write(tiles[tx]); + } + } + + var ifd = new TiffDirectory(); + // Capture metadata first, so the source camera's Make/Model win; UniqueCameraModel still keys the profile. + if (o.Exif is { } exif) ifd.AttachExif(exif); + if (!ifd.Has(TiffTags.Make)) ifd.Ascii(TiffTags.Make, "Titano"); + if (!ifd.Has(TiffTags.Model)) ifd.Ascii(TiffTags.Model, o.UniqueCameraModel); + ifd.Long(TiffTags.NewSubfileType, 0); + ifd.Long(TiffTags.ImageWidth, (uint)w); + ifd.Long(TiffTags.ImageLength, (uint)h); + ifd.Short(TiffTags.BitsPerSample, 16, 16, 16); + ifd.Short(TiffTags.Compression, (ushort)o.Compression); + ifd.Short(TiffTags.PhotometricInterpretation, 34892); + ifd.Short(TiffTags.Orientation, 1); + ifd.Short(TiffTags.SamplesPerPixel, 3); + ifd.Short(TiffTags.PlanarConfiguration, 1); + ifd.Ascii(TiffTags.Software, "Titano"); + ifd.Long(TiffTags.TileWidth, (uint)t); + ifd.Long(TiffTags.TileLength, (uint)t); + ifd.Long(TiffTags.TileOffsets, offsets); + ifd.Long(TiffTags.TileByteCounts, counts); + ifd.Bytes(TiffTags.DngVersion, 1, 4, 0, 0); + ifd.Bytes(TiffTags.DngBackwardVersion, 1, 1, 0, 0); + ifd.Ascii(TiffTags.UniqueCameraModel, o.UniqueCameraModel); + ifd.SRational(TiffTags.ColorMatrix1, Rationals(XyzToLinearSrgb)); + ifd.SRational(TiffTags.ForwardMatrix1, Rationals(LinearSrgbToXyzD50)); + ifd.Short(TiffTags.CalibrationIlluminant1, 21); // D65 + ifd.Rational(TiffTags.AsShotNeutral, (1u, 1u), (1u, 1u), (1u, 1u)); + ifd.SRational(TiffTags.BaselineExposure, (0, 1)); + ifd.Long(TiffTags.WhiteLevel, 65535, 65535, 65535); + TiffWriter.WriteDirectory(output, start, ifd); + } + + /// One t×t tile from a band of rows; pixels beyond the image repeat the edge (better compression). + private static byte[] EncodeTile(ushort[] band, int width, int rows, int x0, int t, DngCompression compression) + { + var tile = new ushort[t * t * 3]; + for (var y = 0; y < t; y++) + { + var src = band.AsSpan(Math.Min(y, rows - 1) * width * 3, width * 3); + var dst = tile.AsSpan(y * t * 3, t * 3); + var valid = Math.Min(t, width - x0); + src.Slice(x0 * 3, valid * 3).CopyTo(dst); + for (var x = valid; x < t; x++) src.Slice((width - 1) * 3, 3).CopyTo(dst[(x * 3)..]); + } + if (compression == DngCompression.LosslessJpeg) return JpegLosslessEncoder.Encode(tile, t, t, 3, 16); + var bytes = new byte[tile.Length * 2]; + for (var i = 0; i < tile.Length; i++) BinaryPrimitives.WriteUInt16LittleEndian(bytes.AsSpan(2 * i), tile[i]); + return bytes; + } + + private static (int, int)[] Rationals(double[] matrix) => matrix.Select(v => ((int)Math.Round(v * 10000), 10000)).ToArray(); +} diff --git a/tests/Titano.Core.Tests/Codecs/LinearDngWriterTests.cs b/tests/Titano.Core.Tests/Codecs/LinearDngWriterTests.cs new file mode 100644 index 00000000..b9d00ecb --- /dev/null +++ b/tests/Titano.Core.Tests/Codecs/LinearDngWriterTests.cs @@ -0,0 +1,124 @@ +using Titano.Core.Codecs.Dng; +using Titano.Core.Codecs.Tiff; +using Titano.Core.Imaging; +using Titano.Core.Metadata.Tiff; +using Titano.Testing; + +namespace Titano.Core.Tests.Codecs; + +public sealed class LinearDngWriterTests +{ + private static ImageBuffer Scene(int w, int h) + { + var image = new ImageBuffer(w, h); + for (var y = 0; y < h; y++) + { + for (var x = 0; x < w; x++) + { + image[0, x, y] = x / (float)(w - 1); + image[1, x, y] = y / (float)(h - 1) * 0.6f; + image[2, x, y] = (x * y % 97) / 96f; + } + } + image[0, 0, 0] = 1.7f; // highlight above white: clipped + return image; + } + + [Theory] + [Case(DngCompression.LosslessJpeg)] + [Case(DngCompression.Uncompressed)] + public void PixelsRoundTripThroughTheTiffReader(DngCompression compression) + { + using var image = Scene(300, 70); + var dng = LinearDngWriter.Write(image, new LinearDngOptions { Compression = compression, TileSize = 128 }); + var reader = TiffReader.Open(new MemoryStream(dng))!; + var raster = TiffImageReader.ReadRaster(reader, reader.ReadChain()[0]); + Assert.Empty(raster.Warnings); + Assert.Equal(34892, raster.Photometric); + Assert.SequenceEqual(PixelConvert.ToInterleaved16(image, 3, TransferFunction.Linear), raster.Samples!); + using var back = TiffImageReader.Decode(dng); + Assert.Approximately(1.0, back[0, 0, 0], 1e-6); + for (var i = 1; i < image.Data.Length; i += 37) + { + Assert.Approximately(Math.Clamp(image.Data[i], 0, 1), back.Data[i], 1.0 / 65535); + } + } + + [Test] + public void TagsDescribeLinearRec709() + { + using var image = Scene(40, 30); + var dng = LinearDngWriter.Write(image); + var r = TiffReader.Open(new MemoryStream(dng))!; + Assert.True(r.LittleEndian); + var ifd = r.ReadChain()[0]; + Assert.SequenceEqual(new uint[] { 1, 4, 0, 0 }, r.GetUInts(ifd, TiffTags.DngVersion)!); + Assert.Equal(0u, r.GetUInt(ifd, TiffTags.NewSubfileType)); + Assert.Equal(34892u, r.GetUInt(ifd, TiffTags.PhotometricInterpretation)); + Assert.Equal(3u, r.GetUInt(ifd, TiffTags.SamplesPerPixel)); + Assert.SequenceEqual(new uint[] { 16, 16, 16 }, r.GetUInts(ifd, TiffTags.BitsPerSample)!); + Assert.Equal(7u, r.GetUInt(ifd, TiffTags.Compression)); + Assert.Equal("Titano", r.GetString(ifd, TiffTags.UniqueCameraModel)); + Assert.Equal(21u, r.GetUInt(ifd, TiffTags.CalibrationIlluminant1)); + Assert.SequenceEqual(new[] { 1.0, 1.0, 1.0 }, r.GetDoubles(ifd, TiffTags.AsShotNeutral)!); + Assert.Equal(0.0, r.GetDouble(ifd, TiffTags.BaselineExposure)); + Assert.SequenceEqual(new uint[] { 65535, 65535, 65535 }, r.GetUInts(ifd, TiffTags.WhiteLevel)!); + Assert.True(ifd.Has(TiffTags.TileWidth) && ifd.Has(TiffTags.TileOffsets) && ifd.Has(TiffTags.TileByteCounts)); + + // ColorMatrix1 maps XYZ to camera space: D65 white must land on the camera neutral (1, 1, 1), + // and its product with sRGB → XYZ(D65) must be the identity (camera space = linear sRGB). + var cm = r.GetDoubles(ifd, TiffTags.ColorMatrix1)!; + Assert.Equal(9, cm.Length); + double[] d65 = [0.95047, 1.0, 1.08883]; + double[] srgbToXyz = [0.4124564, 0.3575761, 0.1804375, 0.2126729, 0.7151522, 0.0721750, 0.0193339, 0.1191920, 0.9503041]; + for (var row = 0; row < 3; row++) + { + Assert.Approximately(1.0, cm[row * 3] * d65[0] + cm[row * 3 + 1] * d65[1] + cm[row * 3 + 2] * d65[2], 2e-3); + for (var col = 0; col < 3; col++) + { + var p = 0.0; + for (var k = 0; k < 3; k++) p += cm[row * 3 + k] * srgbToXyz[k * 3 + col]; + Assert.Approximately(row == col ? 1 : 0, p, 2e-4); + } + } + // ForwardMatrix1 maps the white-balanced neutral to D50 (the DNG SDK's xy 0.3457, 0.3585). + var fm = r.GetDoubles(ifd, TiffTags.ForwardMatrix1)!; + double[] d50 = [0.3457 / 0.3585, 1.0, (1 - 0.3457 - 0.3585) / 0.3585]; + for (var row = 0; row < 3; row++) Assert.Approximately(d50[row], fm[row * 3] + fm[row * 3 + 1] + fm[row * 3 + 2], 3e-4); + } + + [Test] + public void GrayInputExifAndNonSeekableOutput() + { + using var gray = new ImageBuffer(33, 20, 1); + for (var i = 0; i < gray.PlaneLength; i++) gray.Plane(0)[i] = i / (float)gray.PlaneLength; + using var sink = new MemoryStream(); + LinearDngWriter.Write(new ForwardOnlyStream(sink), gray, new LinearDngOptions { Exif = TiffTests.ExifBlock() }); + var dng = sink.ToArray(); + TiffTests.AssertExif(dng); + using var back = TiffImageReader.Decode(dng); + Assert.Equal(3, back.Channels); + Assert.Approximately(gray[0, 20, 10], back[2, 20, 10], 1.0 / 65535); + } + + /// A write-only, non-seekable stream (pipes, network) to exercise the buffering path. + private sealed class ForwardOnlyStream(Stream inner) : Stream + { + public override bool CanRead => false; + public override bool CanSeek => false; + public override bool CanWrite => true; + public override long Length => throw new NotSupportedException(); + + public override long Position + { + get => throw new NotSupportedException(); + set => throw new NotSupportedException(); + } + + public override void Write(byte[] buffer, int offset, int count) => inner.Write(buffer, offset, count); + public override void Flush() => inner.Flush(); + public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException(); + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); + public override void SetLength(long value) => throw new NotSupportedException(); + } +}