feat(codecs): add PNG decoder and ImageBuffer PNG encoding
Every colour type and bit depth (1/2/4/8/16), PLTE + tRNS (palette alpha and colour keys), Adam7, all five filters, zlib via ZLibStream; CRC mismatches and truncated data are tolerated with warnings. PngEncoder gains an additive ImageBuffer overload (8/16-bit sRGB with sRGB chunk) and the Palette colour type for decoding. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
3 files changed
+671
-1
No files matched your search
@@ -0,0 +1,359 @@
|
||||
using System.Buffers.Binary;
|
||||
using System.IO.Compression;
|
||||
using Titano.Core.Hashing;
|
||||
using Titano.Core.Imaging;
|
||||
|
||||
namespace Titano.Core.Codecs.Png;
|
||||
|
||||
/// <summary>IHDR facts of a PNG stream.</summary>
|
||||
public sealed record PngInfo(int Width, int Height, int BitDepth, PngColorType ColorType, bool Interlaced);
|
||||
|
||||
/// <summary>Decoded PNG pixels: interleaved, top-down, palette and tRNS expanded.</summary>
|
||||
public sealed class PngImage
|
||||
{
|
||||
internal PngImage(PngInfo info, int channels, byte[]? pixels8, ushort[]? pixels16, IReadOnlyList<string> warnings)
|
||||
{
|
||||
Info = info;
|
||||
Channels = channels;
|
||||
Pixels8 = pixels8;
|
||||
Pixels16 = pixels16;
|
||||
Warnings = warnings;
|
||||
}
|
||||
|
||||
public PngInfo Info { get; }
|
||||
public int Width => Info.Width;
|
||||
public int Height => Info.Height;
|
||||
|
||||
/// <summary>1 = gray, 2 = gray+alpha, 3 = RGB, 4 = RGBA (palette → RGB/RGBA; tRNS adds alpha).</summary>
|
||||
public int Channels { get; }
|
||||
|
||||
/// <summary>8 (<see cref="Pixels8"/>; 1/2/4-bit gray is scaled to 0..255) or 16 (<see cref="Pixels16"/>).</summary>
|
||||
public int BitDepth => Pixels16 is null ? 8 : 16;
|
||||
|
||||
public byte[]? Pixels8 { get; }
|
||||
public ushort[]? Pixels16 { get; }
|
||||
|
||||
/// <summary>Recoverable problems (CRC mismatches, truncated or corrupt image data, unknown critical chunks).</summary>
|
||||
public IReadOnlyList<string> Warnings { get; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// PNG decoder: every colour type and bit depth (1/2/4/8/16), PLTE + tRNS, Adam7, all five filters, zlib through
|
||||
/// <see cref="ZLibStream"/>. CRC mismatches are tolerated with a warning; damaged image data yields the rows decoded so
|
||||
/// far plus a warning. Ancillary colour chunks (gAMA, iCCP, cHRM) are ignored: samples are taken as sRGB.
|
||||
/// </summary>
|
||||
public static class PngDecoder
|
||||
{
|
||||
private static ReadOnlySpan<byte> Signature => [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
|
||||
|
||||
private static readonly (int X, int Y, int Dx, int Dy)[] Adam7 =
|
||||
[(0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2)];
|
||||
|
||||
public static PngInfo ReadInfo(ReadOnlySpan<byte> data)
|
||||
{
|
||||
if (data.Length < 33 || !data.StartsWith(Signature) || !data.Slice(12, 4).SequenceEqual("IHDR"u8))
|
||||
throw new InvalidDataException("PNG: missing signature or IHDR");
|
||||
return ParseHeader(data.Slice(16, 13));
|
||||
}
|
||||
|
||||
/// <param name="maxPixels">Upper bound on width × height, checked before allocation.</param>
|
||||
public static PngImage Decode(ReadOnlySpan<byte> data, long maxPixels = 1L << 28)
|
||||
{
|
||||
var info = ReadInfo(data);
|
||||
if ((long)info.Width * info.Height > maxPixels) throw new InvalidDataException($"PNG: {info.Width}x{info.Height} exceeds the pixel limit");
|
||||
var warnings = new List<string>();
|
||||
byte[]? palette = null;
|
||||
byte[]? trns = null;
|
||||
using var idat = new MemoryStream();
|
||||
var pos = 8;
|
||||
var ended = false;
|
||||
while (pos + 8 <= data.Length)
|
||||
{
|
||||
var length = BinaryPrimitives.ReadUInt32BigEndian(data[pos..]);
|
||||
var type = data.Slice(pos + 4, 4);
|
||||
if (length > int.MaxValue || pos + 12 + (long)length > data.Length)
|
||||
{
|
||||
warnings.Add("PNG: truncated chunk");
|
||||
break;
|
||||
}
|
||||
var body = data.Slice(pos + 8, (int)length);
|
||||
var crc = BinaryPrimitives.ReadUInt32BigEndian(data[(pos + 8 + (int)length)..]);
|
||||
if (Crc32.Compute(data.Slice(pos + 4, 4 + (int)length)) != crc) warnings.Add($"PNG: CRC mismatch in {Name(type)}");
|
||||
pos += 12 + (int)length;
|
||||
if (type.SequenceEqual("IDAT"u8))
|
||||
{
|
||||
idat.Write(body);
|
||||
}
|
||||
else if (type.SequenceEqual("PLTE"u8))
|
||||
{
|
||||
if (body.Length % 3 != 0 || body.Length > 768 || body.Length == 0) throw new InvalidDataException("PNG: bad PLTE");
|
||||
palette = body.ToArray();
|
||||
}
|
||||
else if (type.SequenceEqual("tRNS"u8))
|
||||
{
|
||||
trns = body.ToArray();
|
||||
}
|
||||
else if (type.SequenceEqual("IEND"u8))
|
||||
{
|
||||
ended = true;
|
||||
break;
|
||||
}
|
||||
else if (!type.SequenceEqual("IHDR"u8) && (type[0] & 0x20) == 0)
|
||||
{
|
||||
warnings.Add($"PNG: unknown critical chunk {Name(type)} ignored");
|
||||
}
|
||||
}
|
||||
if (!ended) warnings.Add("PNG: missing IEND");
|
||||
if (idat.Length == 0) throw new InvalidDataException("PNG: no image data");
|
||||
if (info.ColorType == PngColorType.Palette && palette is null) throw new InvalidDataException("PNG: palette image without PLTE");
|
||||
|
||||
var layout = Layout.For(info, palette, trns);
|
||||
idat.Position = 0;
|
||||
using var z = new ZLibStream(idat, CompressionMode.Decompress);
|
||||
return layout.Sixteen ? Decode16(info, layout, z, warnings) : Decode8(info, layout, z, warnings);
|
||||
}
|
||||
|
||||
/// <summary>Decodes into a linear-light buffer (samples are sRGB-encoded; alpha stays linear).</summary>
|
||||
/// <param name="expandGray">Return gray as three identical channels.</param>
|
||||
/// <param name="keepAlpha">Keep alpha as a fourth channel (gray is then expanded).</param>
|
||||
public static ImageBuffer DecodeToLinear(ReadOnlySpan<byte> data, bool expandGray = false, bool keepAlpha = false)
|
||||
{
|
||||
var image = Decode(data);
|
||||
var gray = image.Channels <= 2;
|
||||
var hasAlpha = image.Channels is 2 or 4;
|
||||
var output = keepAlpha && hasAlpha ? 4 : gray && !expandGray ? 1 : 3;
|
||||
return image.Pixels8 is { } p8
|
||||
? PixelConvert.FromInterleaved8(p8, image.Width, image.Height, image.Channels, outputChannels: output)
|
||||
: PixelConvert.FromInterleaved16(image.Pixels16, image.Width, image.Height, image.Channels, outputChannels: output);
|
||||
}
|
||||
|
||||
private static string Name(ReadOnlySpan<byte> type) => string.Create(4, type.ToArray(), (s, t) =>
|
||||
{
|
||||
for (var i = 0; i < 4; i++) s[i] = t[i] is >= 32 and < 127 ? (char)t[i] : '?';
|
||||
});
|
||||
|
||||
private static PngInfo ParseHeader(ReadOnlySpan<byte> h)
|
||||
{
|
||||
var width = BinaryPrimitives.ReadUInt32BigEndian(h);
|
||||
var height = BinaryPrimitives.ReadUInt32BigEndian(h[4..]);
|
||||
int depth = h[8], type = h[9];
|
||||
if (width is 0 or > int.MaxValue || height is 0 or > int.MaxValue) throw new InvalidDataException("PNG: bad dimensions");
|
||||
var valid = type switch
|
||||
{
|
||||
0 => depth is 1 or 2 or 4 or 8 or 16,
|
||||
3 => depth is 1 or 2 or 4 or 8,
|
||||
2 or 4 or 6 => depth is 8 or 16,
|
||||
_ => false,
|
||||
};
|
||||
if (!valid) throw new InvalidDataException($"PNG: invalid colour type {type} / bit depth {depth}");
|
||||
if (h[10] != 0 || h[11] != 0 || h[12] > 1) throw new InvalidDataException("PNG: unsupported compression, filter or interlace method");
|
||||
return new PngInfo((int)width, (int)height, depth, (PngColorType)type, h[12] == 1);
|
||||
}
|
||||
|
||||
/// <summary>Sample geometry of the stored scanlines and of the expanded output.</summary>
|
||||
private sealed class Layout
|
||||
{
|
||||
public int SourceChannels, BitsPerPixel, BytesPerPixel, OutChannels;
|
||||
public bool Sixteen;
|
||||
public byte[]? Palette;
|
||||
public byte[]? PaletteAlpha;
|
||||
|
||||
/// <summary>tRNS colour key in source sample units (gray: 1 value, RGB: 3), or null.</summary>
|
||||
public int[]? Key;
|
||||
|
||||
public static Layout For(PngInfo info, byte[]? palette, byte[]? trns)
|
||||
{
|
||||
var l = new Layout
|
||||
{
|
||||
SourceChannels = info.ColorType switch
|
||||
{
|
||||
PngColorType.Gray or PngColorType.Palette => 1,
|
||||
PngColorType.GrayAlpha => 2,
|
||||
PngColorType.Rgb => 3,
|
||||
_ => 4,
|
||||
},
|
||||
Sixteen = info.BitDepth == 16,
|
||||
};
|
||||
l.BitsPerPixel = l.SourceChannels * info.BitDepth;
|
||||
l.BytesPerPixel = Math.Max(1, l.BitsPerPixel / 8);
|
||||
l.OutChannels = l.SourceChannels;
|
||||
switch (info.ColorType)
|
||||
{
|
||||
case PngColorType.Palette:
|
||||
l.Palette = palette;
|
||||
l.OutChannels = 3;
|
||||
if (trns is { Length: > 0 })
|
||||
{
|
||||
l.PaletteAlpha = new byte[256];
|
||||
Array.Fill(l.PaletteAlpha, (byte)255);
|
||||
trns.AsSpan(0, Math.Min(trns.Length, 256)).CopyTo(l.PaletteAlpha);
|
||||
l.OutChannels = 4;
|
||||
}
|
||||
break;
|
||||
case PngColorType.Gray when trns is { Length: >= 2 }:
|
||||
l.Key = [trns[0] << 8 | trns[1]];
|
||||
l.OutChannels = 2;
|
||||
break;
|
||||
case PngColorType.Rgb when trns is { Length: >= 6 }:
|
||||
l.Key = [trns[0] << 8 | trns[1], trns[2] << 8 | trns[3], trns[4] << 8 | trns[5]];
|
||||
l.OutChannels = 4;
|
||||
break;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
}
|
||||
|
||||
private static PngImage Decode8(PngInfo info, Layout l, Stream z, List<string> warnings)
|
||||
{
|
||||
var pixels = new byte[checked((long)info.Width * info.Height * l.OutChannels)];
|
||||
var row = new byte[info.Width * l.OutChannels];
|
||||
Inflate(info, l, z, warnings, (raw, y, x0, dx, count) =>
|
||||
{
|
||||
Expand8(raw, info.BitDepth, count, l, row);
|
||||
for (int i = 0, x = x0; i < count; i++, x += dx)
|
||||
{
|
||||
row.AsSpan(i * l.OutChannels, l.OutChannels).CopyTo(pixels.AsSpan((int)(((long)y * info.Width + x) * l.OutChannels)));
|
||||
}
|
||||
});
|
||||
return new PngImage(info, l.OutChannels, pixels, null, warnings);
|
||||
}
|
||||
|
||||
private static PngImage Decode16(PngInfo info, Layout l, Stream z, List<string> warnings)
|
||||
{
|
||||
var pixels = new ushort[checked((long)info.Width * info.Height * l.OutChannels)];
|
||||
Inflate(info, l, z, warnings, (raw, y, x0, dx, count) =>
|
||||
{
|
||||
for (int i = 0, x = x0; i < count; i++, x += dx)
|
||||
{
|
||||
var dst = pixels.AsSpan((int)(((long)y * info.Width + x) * l.OutChannels), l.OutChannels);
|
||||
var transparent = l.Key is not null;
|
||||
for (var c = 0; c < l.SourceChannels; c++)
|
||||
{
|
||||
dst[c] = BinaryPrimitives.ReadUInt16BigEndian(raw[((i * l.SourceChannels + c) * 2)..]);
|
||||
if (l.Key is not null && dst[c] != l.Key[c]) transparent = false;
|
||||
}
|
||||
if (l.Key is not null) dst[l.SourceChannels] = transparent ? (ushort)0 : ushort.MaxValue;
|
||||
}
|
||||
});
|
||||
return new PngImage(info, l.OutChannels, null, pixels, warnings);
|
||||
}
|
||||
|
||||
private delegate void RowHandler(ReadOnlySpan<byte> raw, int y, int x0, int dx, int count);
|
||||
|
||||
/// <summary>Streams every (pass,) row out of zlib, unfilters it and hands the raw samples to <paramref name="handle"/>.</summary>
|
||||
private static void Inflate(PngInfo info, Layout l, Stream z, List<string> warnings, RowHandler handle)
|
||||
{
|
||||
var passes = info.Interlaced ? Adam7 : [(0, 0, 1, 1)];
|
||||
var maxRow = (int)(((long)info.Width * l.BitsPerPixel + 7) / 8);
|
||||
var line = new byte[maxRow + 1];
|
||||
var prior = new byte[maxRow];
|
||||
try
|
||||
{
|
||||
foreach (var (px, py, dx, dy) in passes)
|
||||
{
|
||||
if (px >= info.Width || py >= info.Height) continue;
|
||||
var count = (info.Width - px + dx - 1) / dx;
|
||||
var rowBytes = (int)(((long)count * l.BitsPerPixel + 7) / 8);
|
||||
Array.Clear(prior);
|
||||
for (var y = py; y < info.Height; y += dy)
|
||||
{
|
||||
var buffer = line.AsSpan(0, rowBytes + 1);
|
||||
if (z.ReadAtLeast(buffer, buffer.Length, throwOnEndOfStream: false) < buffer.Length)
|
||||
{
|
||||
warnings.Add("PNG: image data truncated");
|
||||
return;
|
||||
}
|
||||
if (buffer[0] > 4)
|
||||
{
|
||||
warnings.Add($"PNG: invalid filter type {buffer[0]}");
|
||||
return;
|
||||
}
|
||||
var row = buffer[1..];
|
||||
Unfilter(buffer[0], row, prior.AsSpan(0, rowBytes), l.BytesPerPixel);
|
||||
handle(row, y, px, dx, count);
|
||||
row.CopyTo(prior);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (InvalidDataException ex)
|
||||
{
|
||||
warnings.Add("PNG: corrupt image data: " + ex.Message);
|
||||
}
|
||||
}
|
||||
|
||||
private static void Unfilter(int filter, Span<byte> row, ReadOnlySpan<byte> prior, int bpp)
|
||||
{
|
||||
switch (filter)
|
||||
{
|
||||
case 1:
|
||||
for (var i = bpp; i < row.Length; i++) row[i] += row[i - bpp];
|
||||
break;
|
||||
case 2:
|
||||
for (var i = 0; i < row.Length; i++) row[i] += prior[i];
|
||||
break;
|
||||
case 3:
|
||||
for (var i = 0; i < bpp && i < row.Length; i++) row[i] += (byte)(prior[i] >> 1);
|
||||
for (var i = bpp; i < row.Length; i++) row[i] += (byte)((row[i - bpp] + prior[i]) >> 1);
|
||||
break;
|
||||
case 4:
|
||||
for (var i = 0; i < bpp && i < row.Length; i++) row[i] += prior[i];
|
||||
for (var i = bpp; i < row.Length; i++) row[i] += (byte)PngEncoder.Paeth(row[i - bpp], prior[i], prior[i - bpp]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Expands one row of ≤ 8-bit samples (sub-byte gray, palette, tRNS key) to 8-bit output channels.</summary>
|
||||
private static void Expand8(ReadOnlySpan<byte> raw, int depth, int count, Layout l, Span<byte> dst)
|
||||
{
|
||||
var oc = l.OutChannels;
|
||||
if (depth == 8 && l.Palette is null && l.Key is null)
|
||||
{
|
||||
raw[..(count * oc)].CopyTo(dst);
|
||||
return;
|
||||
}
|
||||
if (depth == 8 && l.Key is not null)
|
||||
{
|
||||
var sc = l.SourceChannels;
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
var opaque = false;
|
||||
for (var c = 0; c < sc; c++)
|
||||
{
|
||||
var v = raw[i * sc + c];
|
||||
dst[i * oc + c] = v;
|
||||
if (v != l.Key[c]) opaque = true;
|
||||
}
|
||||
dst[i * oc + sc] = opaque ? (byte)255 : (byte)0;
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Sub-byte or palette: one sample per pixel, MSB first.
|
||||
var mask = (1 << depth) - 1;
|
||||
var scale = l.Palette is null ? 255 / mask : 1;
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
var bit = i * depth;
|
||||
var v = (raw[bit >> 3] >> (8 - depth - (bit & 7))) & mask;
|
||||
if (l.Palette is { } pal)
|
||||
{
|
||||
var o = dst.Slice(i * oc, oc);
|
||||
if (3 * v + 2 < pal.Length)
|
||||
{
|
||||
o[0] = pal[3 * v];
|
||||
o[1] = pal[3 * v + 1];
|
||||
o[2] = pal[3 * v + 2];
|
||||
}
|
||||
else
|
||||
{
|
||||
o[..3].Clear(); // out-of-range index: black, as libpng
|
||||
}
|
||||
if (oc == 4) o[3] = l.PaletteAlpha![v];
|
||||
}
|
||||
else
|
||||
{
|
||||
dst[i * oc] = (byte)(v * scale);
|
||||
if (l.Key is not null) dst[i * oc + 1] = v == l.Key[0] ? (byte)0 : (byte)255;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,16 @@
|
||||
using System.Buffers.Binary;
|
||||
using System.IO.Compression;
|
||||
using Titano.Core.Hashing;
|
||||
using Titano.Core.Imaging;
|
||||
|
||||
namespace Titano.Core.Codecs.Png;
|
||||
|
||||
/// <summary>PNG colour types written by <see cref="PngEncoder"/>.</summary>
|
||||
/// <summary>PNG colour types (<see cref="Palette"/> is decoded but never written by <see cref="PngEncoder"/>).</summary>
|
||||
public enum PngColorType : byte
|
||||
{
|
||||
Gray = 0,
|
||||
Rgb = 2,
|
||||
Palette = 3,
|
||||
GrayAlpha = 4,
|
||||
Rgba = 6,
|
||||
}
|
||||
@@ -29,6 +31,7 @@ public static class PngEncoder
|
||||
public static void Encode(Stream output, ReadOnlySpan<byte> pixels, int width, int height, PngColorType colorType, int bitDepth = 8, CompressionLevel level = CompressionLevel.SmallestSize, IEnumerable<(string Type, byte[] Data)>? extraChunks = null)
|
||||
{
|
||||
if (bitDepth is not (8 or 16)) throw new ArgumentOutOfRangeException(nameof(bitDepth));
|
||||
if (colorType == PngColorType.Palette) throw new ArgumentException("Palette images are not written", nameof(colorType));
|
||||
var channels = colorType switch
|
||||
{
|
||||
PngColorType.Gray => 1,
|
||||
@@ -60,6 +63,36 @@ public static class PngEncoder
|
||||
WriteChunk(output, "IEND", []);
|
||||
}
|
||||
|
||||
/// <summary>Encodes a linear-light buffer as sRGB-encoded PNG (1 channel → gray, 3 → RGB, 4 → RGBA with linear
|
||||
/// alpha) and tags it with an sRGB chunk.</summary>
|
||||
/// <param name="bitDepth">8 or 16 bits per sample.</param>
|
||||
public static byte[] Encode(ImageBuffer image, int bitDepth = 8, CompressionLevel level = CompressionLevel.SmallestSize)
|
||||
{
|
||||
using var ms = new MemoryStream();
|
||||
Encode(ms, image, bitDepth, level);
|
||||
return ms.ToArray();
|
||||
}
|
||||
|
||||
public static void Encode(Stream output, ImageBuffer image, int bitDepth = 8, CompressionLevel level = CompressionLevel.SmallestSize, IEnumerable<(string Type, byte[] Data)>? extraChunks = null)
|
||||
{
|
||||
if (bitDepth is not (8 or 16)) throw new ArgumentOutOfRangeException(nameof(bitDepth));
|
||||
var channels = image.Channels;
|
||||
var colorType = channels switch { 1 => PngColorType.Gray, 3 => PngColorType.Rgb, _ => PngColorType.Rgba };
|
||||
byte[] pixels;
|
||||
if (bitDepth == 8)
|
||||
{
|
||||
pixels = PixelConvert.ToInterleaved8(image, channels);
|
||||
}
|
||||
else
|
||||
{
|
||||
var words = PixelConvert.ToInterleaved16(image, channels);
|
||||
pixels = new byte[words.Length * 2];
|
||||
for (var i = 0; i < words.Length; i++) BinaryPrimitives.WriteUInt16BigEndian(pixels.AsSpan(2 * i), words[i]);
|
||||
}
|
||||
IEnumerable<(string Type, byte[] Data)> chunks = [("sRGB", [0]), .. extraChunks ?? []];
|
||||
Encode(output, pixels, image.Width, image.Height, colorType, bitDepth, level, chunks);
|
||||
}
|
||||
|
||||
/// <summary>Filters every row (adaptive, minimum sum of absolute differences) and deflates the result.</summary>
|
||||
public static byte[] Compress(ReadOnlySpan<byte> pixels, int height, int stride, int bpp, CompressionLevel level)
|
||||
{
|
||||
|
||||
@@ -0,0 +1,278 @@
|
||||
using System.Buffers.Binary;
|
||||
using System.IO.Compression;
|
||||
using Titano.Core.Codecs.Png;
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Testing;
|
||||
using static Titano.Core.Tests.Codecs.CodecTestData;
|
||||
|
||||
namespace Titano.Core.Tests.Codecs;
|
||||
|
||||
public sealed class PngTests(TestContext context)
|
||||
{
|
||||
[Theory]
|
||||
[Case("png/adam7.png", false)]
|
||||
[Case("png/rgb16.png", true)]
|
||||
[Case("png/adam7-16.png", true)]
|
||||
public void RgbFixturesMatchSource(string name, bool sixteen)
|
||||
{
|
||||
var image = PngDecoder.Decode(Fixture(name));
|
||||
Assert.Equal(3, image.Channels);
|
||||
Assert.Empty(image.Warnings);
|
||||
if (sixteen) Assert.SequenceEqual(ReadPnm(Fixture("src16.ppm")).Words, image.Pixels16!);
|
||||
else Assert.SequenceEqual(ReadPnm(Fixture("src.ppm")).Bytes, image.Pixels8!);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case("gray1", 1)]
|
||||
[Case("gray2", 1)]
|
||||
[Case("gray4", 1)]
|
||||
[Case("gray8", 1)]
|
||||
[Case("graya", 2)]
|
||||
[Case("palette4", 3)]
|
||||
[Case("palette-adam7", 3)]
|
||||
[Case("palette-trns", 4)]
|
||||
[Case("rgba", 4)]
|
||||
public void LibpngFixturesMatchReference(string name, int channels)
|
||||
{
|
||||
var image = PngDecoder.Decode(Fixture($"png/{name}.png"));
|
||||
var reference = ReadPnm(Fixture($"png/{name}.pam"));
|
||||
Assert.Equal(channels, image.Channels);
|
||||
Assert.Empty(image.Warnings);
|
||||
var pixels = image.Pixels8!;
|
||||
for (var i = 0; i < image.Width * image.Height; i++)
|
||||
{
|
||||
for (var c = 0; c < channels; c++)
|
||||
{
|
||||
// ImageMagick expands gray to RGB in PAM; compare against its first channel.
|
||||
var refChannel = reference.Channels == channels ? c : c == channels - 1 && channels == 2 ? reference.Channels - 1 : 0;
|
||||
if (pixels[i * channels + c] != reference.Samples[i * reference.Channels + refChannel])
|
||||
Assert.Fail($"{name}: pixel {i} channel {c}: {pixels[i * channels + c]} vs {reference.Samples[i * reference.Channels + refChannel]}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(PngColorType.Gray, 8)]
|
||||
[Case(PngColorType.Gray, 16)]
|
||||
[Case(PngColorType.GrayAlpha, 8)]
|
||||
[Case(PngColorType.GrayAlpha, 16)]
|
||||
[Case(PngColorType.Rgb, 8)]
|
||||
[Case(PngColorType.Rgb, 16)]
|
||||
[Case(PngColorType.Rgba, 8)]
|
||||
[Case(PngColorType.Rgba, 16)]
|
||||
public void EncoderRoundTrips(PngColorType type, int depth)
|
||||
{
|
||||
const int w = 37, h = 21;
|
||||
var channels = type switch { PngColorType.Gray => 1, PngColorType.GrayAlpha => 2, PngColorType.Rgb => 3, _ => 4 };
|
||||
var bytes = new byte[w * h * channels * depth / 8];
|
||||
new Random(depth * 10 + channels).NextBytes(bytes.AsSpan(bytes.Length / 2));
|
||||
for (var i = 0; i < bytes.Length / 2; i++) bytes[i] = (byte)(i * 7);
|
||||
var image = PngDecoder.Decode(PngEncoder.Encode(bytes, w, h, type, depth));
|
||||
Assert.Equal(channels, image.Channels);
|
||||
if (depth == 8)
|
||||
{
|
||||
Assert.SequenceEqual(bytes, image.Pixels8!);
|
||||
}
|
||||
else
|
||||
{
|
||||
var words = new ushort[bytes.Length / 2];
|
||||
for (var i = 0; i < words.Length; i++) words[i] = BinaryPrimitives.ReadUInt16BigEndian(bytes.AsSpan(2 * i));
|
||||
Assert.SequenceEqual(words, image.Pixels16!);
|
||||
}
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(0)]
|
||||
[Case(1)]
|
||||
[Case(2)]
|
||||
[Case(3)]
|
||||
[Case(4)]
|
||||
public void EveryFilterTypeDecodes(int filter)
|
||||
{
|
||||
const int w = 23, h = 9;
|
||||
var rgb = TestCard(w, h);
|
||||
var png = RawPng(w, h, PngColorType.Rgb, 8, rgb, filter);
|
||||
Assert.SequenceEqual(rgb, PngDecoder.Decode(png).Pixels8!);
|
||||
var rgba16 = new byte[w * h * 8];
|
||||
new Random(filter).NextBytes(rgba16);
|
||||
var wide = PngDecoder.Decode(RawPng(w, h, PngColorType.Rgba, 16, rgba16, filter, interlaced: true));
|
||||
Assert.Equal((ushort)(rgba16[8 * 5] << 8 | rgba16[8 * 5 + 1]), wide.Pixels16![4 * 5]);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(1)]
|
||||
[Case(2)]
|
||||
[Case(4)]
|
||||
public void SubBytePaletteWithTransparency(int depth)
|
||||
{
|
||||
const int w = 13, h = 7;
|
||||
var colours = 1 << depth;
|
||||
var indices = new byte[w * h];
|
||||
for (var i = 0; i < indices.Length; i++) indices[i] = (byte)(i * 5 % colours);
|
||||
var packed = Pack(indices, w, h, depth);
|
||||
var plte = new byte[colours * 3];
|
||||
for (var i = 0; i < plte.Length; i++) plte[i] = (byte)(i * 37);
|
||||
var trns = new byte[] { 0, 128 };
|
||||
var png = RawPng(w, h, PngColorType.Palette, depth, packed, 4, interlaced: depth == 2, ("PLTE", plte), ("tRNS", trns));
|
||||
var image = PngDecoder.Decode(png);
|
||||
Assert.Equal(4, image.Channels);
|
||||
for (var i = 0; i < indices.Length; i++)
|
||||
{
|
||||
int idx = indices[i];
|
||||
Assert.Equal(plte[3 * idx + 1], image.Pixels8![4 * i + 1]);
|
||||
Assert.Equal(idx < trns.Length ? trns[idx] : (byte)255, image.Pixels8[4 * i + 3]);
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ColourKeyTransparency()
|
||||
{
|
||||
var gray = PngDecoder.Decode(RawPng(4, 1, PngColorType.Gray, 4, [0x0F, 0x3F], 0, false, ("tRNS", [0, 3])));
|
||||
Assert.SequenceEqual(new byte[] { 0, 255, 255, 255, 51, 0, 255, 255 }, gray.Pixels8!);
|
||||
var rgb16 = new byte[12];
|
||||
rgb16[1] = 9;
|
||||
var keyed = PngDecoder.Decode(RawPng(2, 1, PngColorType.Rgb, 16, rgb16, 1, false, ("tRNS", [0, 0, 0, 0, 0, 0])));
|
||||
Assert.Equal(4, keyed.Channels);
|
||||
Assert.Equal(ushort.MaxValue, keyed.Pixels16![3]);
|
||||
Assert.Equal((ushort)0, keyed.Pixels16[7]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CrcMismatchIsToleratedWithWarning()
|
||||
{
|
||||
var png = PngEncoder.Encode(TestCard(8, 8), 8, 8, PngColorType.Rgb);
|
||||
png[^13] ^= 0xFF; // last byte of the IDAT CRC (IEND is the final 12 bytes)
|
||||
var image = PngDecoder.Decode(png);
|
||||
Assert.SequenceEqual(TestCard(8, 8), image.Pixels8!);
|
||||
Assert.Contains("CRC", string.Join(";", image.Warnings));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ImageBufferRoundTripsAtSixteenBits()
|
||||
{
|
||||
using var image = new ImageBuffer(33, 17, 4);
|
||||
for (var c = 0; c < 4; c++)
|
||||
{
|
||||
var plane = image.Plane(c);
|
||||
for (var i = 0; i < plane.Length; i++) plane[i] = (i * (c + 1) % 97) / 96f;
|
||||
}
|
||||
var png = PngEncoder.Encode(image, 16);
|
||||
Assert.True(png.AsSpan().IndexOf("sRGB"u8) > 0, "sRGB chunk");
|
||||
using var back = PngDecoder.DecodeToLinear(png, keepAlpha: true);
|
||||
Assert.Equal(4, back.Channels);
|
||||
for (var i = 0; i < image.Data.Length; i += 13) Assert.Approximately(image.Data[i], back.Data[i], 2e-4);
|
||||
using var eight = PngDecoder.DecodeToLinear(PngEncoder.Encode(image));
|
||||
Assert.Equal(3, eight.Channels);
|
||||
Assert.Approximately(image[1, 5, 5], eight[1, 5, 5], 0.01);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case("png/adam7.png")]
|
||||
[Case("png/palette-trns.png")]
|
||||
[Case("png/gray2.png")]
|
||||
[Case("png/adam7-16.png")]
|
||||
public void FuzzedInputOnlyThrowsInvalidData(string name)
|
||||
{
|
||||
int ok = 0, rejected = 0;
|
||||
foreach (var input in Corruptions(Fixture(name), 150, seed: name.Length))
|
||||
{
|
||||
try
|
||||
{
|
||||
var image = PngDecoder.Decode(input);
|
||||
Assert.True(image.Width > 0);
|
||||
ok++;
|
||||
}
|
||||
catch (InvalidDataException)
|
||||
{
|
||||
rejected++;
|
||||
}
|
||||
}
|
||||
context.Log($"{name}: {ok} decoded, {rejected} rejected");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void StructuralErrorsAreRejected()
|
||||
{
|
||||
Assert.Throws<InvalidDataException>(() => PngDecoder.Decode([]));
|
||||
Assert.Throws<InvalidDataException>(() => PngDecoder.Decode(Fixture("jpeg/b420.jpg")));
|
||||
var palette = Fixture("png/palette4.png");
|
||||
var plte = palette.AsSpan().IndexOf("PLTE"u8);
|
||||
palette[plte] = (byte)'X'; // drop the palette (and make an unknown critical chunk)
|
||||
Assert.Throws<InvalidDataException>(() => PngDecoder.Decode(palette));
|
||||
Assert.Throws<ArgumentException>(() => PngEncoder.Encode(new byte[4], 2, 2, PngColorType.Palette));
|
||||
}
|
||||
|
||||
/// <summary>Builds a PNG with every row filtered by <paramref name="filter"/> (test-side writer).</summary>
|
||||
private static byte[] RawPng(int w, int h, PngColorType type, int depth, byte[] rows, int filter, bool interlaced = false, params (string Type, byte[] Data)[] chunks)
|
||||
{
|
||||
var channels = type switch { PngColorType.Gray or PngColorType.Palette => 1, PngColorType.GrayAlpha => 2, PngColorType.Rgb => 3, _ => 4 };
|
||||
var bits = channels * depth;
|
||||
var bpp = Math.Max(1, bits / 8);
|
||||
var stride = (w * bits + 7) / 8;
|
||||
var passes = interlaced
|
||||
? new[] { (0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2) }
|
||||
: [(0, 0, 1, 1)];
|
||||
using var raw = new MemoryStream();
|
||||
foreach (var (px, py, dx, dy) in passes)
|
||||
{
|
||||
if (px >= w || py >= h) continue;
|
||||
var count = (w - px + dx - 1) / dx;
|
||||
var rowBytes = (count * bits + 7) / 8;
|
||||
var prev = new byte[rowBytes];
|
||||
for (var y = py; y < h; y += dy)
|
||||
{
|
||||
// Gather this pass's pixels (bit-exact copy of their samples).
|
||||
var row = new byte[rowBytes];
|
||||
for (int i = 0, x = px; i < count; i++, x += dx)
|
||||
{
|
||||
for (var b = 0; b < bits; b++)
|
||||
{
|
||||
var src = y * stride * 8 + x * bits + b;
|
||||
if ((rows[src >> 3] >> (7 - (src & 7)) & 1) != 0) row[(i * bits + b) >> 3] |= (byte)(0x80 >> ((i * bits + b) & 7));
|
||||
}
|
||||
}
|
||||
raw.WriteByte((byte)filter);
|
||||
for (var i = 0; i < rowBytes; i++)
|
||||
{
|
||||
int a = i >= bpp ? row[i - bpp] : 0, b = prev[i], c = i >= bpp ? prev[i - bpp] : 0;
|
||||
var predicted = filter switch { 0 => 0, 1 => a, 2 => b, 3 => (a + b) >> 1, _ => PngEncoder.Paeth(a, b, c) };
|
||||
raw.WriteByte((byte)(row[i] - predicted));
|
||||
}
|
||||
prev = row;
|
||||
}
|
||||
}
|
||||
using var z = new MemoryStream();
|
||||
using (var deflate = new ZLibStream(z, CompressionLevel.Fastest, leaveOpen: true)) deflate.Write(raw.ToArray());
|
||||
using var png = new MemoryStream();
|
||||
png.Write([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
|
||||
var ihdr = new byte[13];
|
||||
BinaryPrimitives.WriteInt32BigEndian(ihdr, w);
|
||||
BinaryPrimitives.WriteInt32BigEndian(ihdr.AsSpan(4), h);
|
||||
ihdr[8] = (byte)depth;
|
||||
ihdr[9] = (byte)type;
|
||||
ihdr[12] = (byte)(interlaced ? 1 : 0);
|
||||
PngEncoder.WriteChunk(png, "IHDR", ihdr);
|
||||
foreach (var (t, d) in chunks) PngEncoder.WriteChunk(png, t, d);
|
||||
var compressed = z.ToArray();
|
||||
var half = compressed.Length / 2;
|
||||
PngEncoder.WriteChunk(png, "IDAT", compressed.AsSpan(0, half));
|
||||
PngEncoder.WriteChunk(png, "IDAT", compressed.AsSpan(half));
|
||||
PngEncoder.WriteChunk(png, "IEND", []);
|
||||
return png.ToArray();
|
||||
}
|
||||
|
||||
private static byte[] Pack(byte[] values, int w, int h, int depth)
|
||||
{
|
||||
var stride = (w * depth + 7) / 8;
|
||||
var packed = new byte[stride * h];
|
||||
for (var y = 0; y < h; y++)
|
||||
{
|
||||
for (var x = 0; x < w; x++)
|
||||
{
|
||||
var bit = x * depth;
|
||||
packed[y * stride + (bit >> 3)] |= (byte)(values[y * w + x] << (8 - depth - (bit & 7)));
|
||||
}
|
||||
}
|
||||
return packed;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user