feat(codecs): add managed JPEG decoder and pixel conversions

Baseline, extended 12-bit, progressive and lossless (SOF3) Huffman
decoding; 1/3/4 components with Adobe CMYK/YCCK; all integral sampling
factors with libjpeg fancy upsampling; restart resynchronisation;
DCT-domain scaling. Full-size blocks use a port of libjpeg's ISLOW IDCT,
so output is bit-identical to djpeg on the cjpeg fixtures.

PixelConvert maps interleaved 8/16-bit samples to linear ImageBuffers and
back, gray/RGB, Exif orientation and clamping.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-02 09:37:15 +00:00
1 parent 800843d2ae
commit 64e4fb3df6
70 files changed
+2618

No files matched your search

@@ -0,0 +1,74 @@
using Titano.Core.Imaging;
namespace Titano.Core.Codecs.Jpeg;
/// <summary>
/// Managed JPEG decoder: baseline, extended (12-bit), progressive and lossless Huffman streams; 1, 3 or 4 components
/// (CMYK/YCCK via Adobe APP14); any integral sampling factors; restart intervals with resynchronisation on corrupt
/// data; DCT-domain scaling for thumbnails. Exif orientation is not applied. Malformed headers throw
/// <see cref="InvalidDataException"/>; damaged entropy-coded data yields a partial image plus warnings.
/// </summary>
public static class JpegDecoder
{
private static readonly float[]?[] LinearLuts = new float[17][];
/// <summary>Reads the frame header only (no pixel decoding).</summary>
public static JpegInfo ReadInfo(ReadOnlySpan<byte> data)
{
var parser = new JpegParser(JpegDecodeOptions.Default);
parser.Parse(data, headerOnly: true);
return parser.Info();
}
/// <summary>Decodes to interleaved gray or RGB samples (8-bit, or 16-bit containers for higher precisions).</summary>
public static JpegImage Decode(ReadOnlySpan<byte> data, JpegDecodeOptions? options = null)
{
var parser = Parse(data, options);
if (parser.Frame!.Process == JpegProcess.Lossless) return LosslessToImage(parser);
return new JpegRenderer(parser).RenderInterleaved(parser.Info());
}
/// <summary>Decodes into a linear-light <see cref="ImageBuffer"/> (samples are taken as sRGB-encoded).</summary>
/// <param name="expandGray">Return gray images as three identical channels instead of one.</param>
public static ImageBuffer DecodeToLinear(ReadOnlySpan<byte> data, JpegDecodeOptions? options = null, bool expandGray = false)
{
var parser = Parse(data, options);
if (parser.Frame!.Process == JpegProcess.Lossless)
{
var image = LosslessToImage(parser);
var channels = image.Components == 1 && expandGray ? 3 : image.Components;
return image.Pixels8 is { } p8
? PixelConvert.FromInterleaved8(p8, image.Width, image.Height, image.Components, outputChannels: channels)
: PixelConvert.FromInterleaved16(image.Pixels16, image.Width, image.Height, image.Components, maxValue: (1 << image.BitDepth) - 1, outputChannels: channels);
}
return new JpegRenderer(parser).RenderLinear(expandGray);
}
private static JpegParser Parse(ReadOnlySpan<byte> data, JpegDecodeOptions? options)
{
var parser = new JpegParser(options ?? JpegDecodeOptions.Default);
parser.Parse(data);
return parser;
}
private static JpegImage LosslessToImage(JpegParser parser)
{
var raw = JpegLosslessDecoder.Finish(parser);
if (raw.Components is not (1 or 3)) throw new InvalidDataException($"JPEG: {raw.Components}-component lossless images have no colour interpretation");
if (raw.Precision > 8)
return new JpegImage(parser.Info(), raw.Width, raw.Height, raw.Components, raw.Precision, null, raw.Samples, [.. parser.Warnings]);
var bytes = new byte[raw.Samples.Length];
for (var i = 0; i < bytes.Length; i++) bytes[i] = (byte)raw.Samples[i];
return new JpegImage(parser.Info(), raw.Width, raw.Height, raw.Components, 8, bytes, null, [.. parser.Warnings]);
}
/// <summary>sRGB-decoding table for codes 0..2^precision−1.</summary>
internal static float[] LinearLut(int precision)
{
if (LinearLuts[precision] is { } cached) return cached;
var size = 1 << precision;
var lut = new float[size];
for (var i = 0; i < size; i++) lut[i] = (float)ColorSpace.SrgbToLinear(i / (double)(size - 1));
return LinearLuts[precision] = lut;
}
}
+241
View File
@@ -0,0 +1,241 @@
using System.Runtime.CompilerServices;
namespace Titano.Core.Codecs.Jpeg;
/// <summary>Canonical Huffman decoding table with a 9-bit lookahead (and a combined run/value table for AC).</summary>
internal sealed class JpegHuffmanTable
{
public const int FastBits = 9;
/// <summary><c>(length &lt;&lt; 8) | symbol</c> for codes of ≤ <see cref="FastBits"/> bits; 0 = longer code.</summary>
public readonly ushort[] Fast = new ushort[1 << FastBits];
/// <summary>Exclusive upper bound of each code length's codes, left-aligned to 16 bits.</summary>
public readonly int[] MaxCode = new int[18];
/// <summary>Symbol index = (code &gt;&gt; (16 − length)) + Delta[length].</summary>
public readonly int[] Delta = new int[17];
public readonly byte[] Values = new byte[256];
/// <summary>For AC tables: <c>(value &lt;&lt; 16) | (run &lt;&lt; 8) | totalBits</c> when code and magnitude fit in the lookahead.</summary>
public readonly int[] FastAc = new int[1 << FastBits];
/// <summary>Builds a table from the 16 code-length counts and the symbols (DHT layout).</summary>
/// <exception cref="InvalidDataException">The lengths oversubscribe the code space.</exception>
public JpegHuffmanTable(ReadOnlySpan<byte> counts, ReadOnlySpan<byte> values)
{
int code = 0, k = 0;
for (var len = 1; len <= 16; len++)
{
Delta[len] = k - code;
for (var i = 0; i < counts[len - 1]; i++, code++, k++)
{
if (len > FastBits) continue;
var first = code << (FastBits - len);
Fast.AsSpan(first, 1 << (FastBits - len)).Fill((ushort)(len << 8 | values[k]));
}
if (code > 1 << len) throw new InvalidDataException("JPEG: Huffman table oversubscribed");
MaxCode[len] = code << (16 - len);
code <<= 1;
}
MaxCode[17] = int.MaxValue;
values[..k].CopyTo(Values);
BuildFastAc();
}
private void BuildFastAc()
{
for (var i = 0; i < Fast.Length; i++)
{
int e = Fast[i];
if (e == 0) continue;
var len = e >> 8;
var rs = e & 0xFF;
int run = rs >> 4, s = rs & 15;
if (s == 0 || len + s > FastBits) continue;
var m = (i >> (FastBits - len - s)) & ((1 << s) - 1);
var v = m < 1 << (s - 1) ? m - (1 << s) + 1 : m;
FastAc[i] = v << 16 | run << 8 | (len + s);
}
}
}
/// <summary>Thrown inside a scan when entropy-coded data is corrupt; the scan decoder resynchronises.</summary>
internal sealed class JpegEntropyException(string message) : Exception(message);
/// <summary>
/// MSB-first bit reader over entropy-coded JPEG data: removes 0xFF00 stuffing, stops at markers and then
/// feeds zero bits, counting them so that consumption past the real data is detectable (<see cref="Overrun"/>).
/// </summary>
internal ref struct JpegBitReader
{
private readonly ReadOnlySpan<byte> _data;
private int _pos;
private ulong _bits;
private int _count;
private int _padBits;
private int _marker;
private int _markerPos;
public JpegBitReader(ReadOnlySpan<byte> data, int start)
{
_data = data;
_pos = start;
}
/// <summary>Marker code that stopped the reader (0 = none, -1 = end of data).</summary>
public readonly int Marker => _marker;
/// <summary>True once bits beyond the entropy-coded segment have been consumed.</summary>
public readonly bool Overrun => _padBits > _count;
/// <summary>Where marker parsing continues after the scan.</summary>
public readonly int Position => _marker > 0 ? _markerPos : _pos;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Ensure(int n)
{
if (_count < n) Fill();
}
/// <summary>Next <paramref name="n"/> bits (1..32) without consuming; call <see cref="Ensure"/> first.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public readonly int Peek(int n) => (int)(_bits >> (64 - n));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Consume(int n)
{
_bits <<= n;
_count -= n;
}
/// <summary>Reads 1..16 bits.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int ReadBits(int n)
{
if (_count < n) Fill();
var v = (int)(_bits >> (64 - n));
_bits <<= n;
_count -= n;
return v;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int ReadBit()
{
if (_count < 1) Fill();
var v = (int)(_bits >> 63);
_bits <<= 1;
_count--;
return v;
}
/// <summary>Reads an <paramref name="s"/>-bit magnitude (1..16) and sign-extends it (T.81 F.2.2.1 EXTEND).</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int Receive(int s)
{
var v = ReadBits(s);
return v + ((((v >> (s - 1)) & 1) - 1) & (1 - (1 << s)));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int Decode(JpegHuffmanTable t)
{
if (_count < 16) Fill();
int e = t.Fast[(int)(_bits >> (64 - JpegHuffmanTable.FastBits))];
if (e != 0)
{
var len = e >> 8;
_bits <<= len;
_count -= len;
return e & 0xFF;
}
return DecodeSlow(t);
}
private int DecodeSlow(JpegHuffmanTable t)
{
var code = (int)(_bits >> 48);
for (var len = JpegHuffmanTable.FastBits + 1; len <= 16; len++)
{
if (code < t.MaxCode[len])
{
Consume(len);
return t.Values[(code >> (16 - len)) + t.Delta[len]];
}
}
throw new JpegEntropyException("JPEG: invalid Huffman code");
}
[MethodImpl(MethodImplOptions.NoInlining)]
public void Fill()
{
while (_count <= 56)
{
if (_marker != 0 || _pos >= _data.Length)
{
if (_marker == 0) _marker = -1;
_padBits += 8;
_count += 8;
continue;
}
int b = _data[_pos];
if (b == 0xFF)
{
var p = _pos + 1;
while (p < _data.Length && _data[p] == 0xFF) p++;
if (p >= _data.Length)
{
_pos = p;
continue;
}
if (_data[p] != 0)
{
_marker = _data[p];
_markerPos = p - 1;
continue;
}
_pos = p + 1;
}
else
{
_pos++;
}
_bits |= (ulong)(uint)b << (56 - _count);
_count += 8;
}
}
/// <summary>Discards buffered bits and locates the next marker (for restart processing). Returns its code
/// (-1 when the data ends) without consuming it; <see cref="AcceptMarker"/> steps over it.</summary>
public int FindMarker()
{
_bits = 0;
_count = 0;
_padBits = 0;
if (_marker > 0) return _marker;
var p = _pos;
while (p + 1 < _data.Length)
{
if (_data[p] == 0xFF && _data[p + 1] is not (0x00 or 0xFF))
{
_marker = _data[p + 1];
_markerPos = p;
return _marker;
}
p++;
}
_pos = _data.Length;
_marker = -1;
return -1;
}
/// <summary>Consumes the marker found by <see cref="FindMarker"/> and resumes reading after it.</summary>
public void AcceptMarker()
{
if (_marker <= 0) return;
_pos = _markerPos + 2;
_marker = 0;
}
}
+169
View File
@@ -0,0 +1,169 @@
namespace Titano.Core.Codecs.Jpeg;
/// <summary>
/// Inverse DCT. Full-size blocks use libjpeg's accurate integer algorithm (jidctint ISLOW: Loeffler–Ligtenberg–
/// Moschytz with 13-bit constants), so output is bit-identical to libjpeg/djpeg. Reduced sizes (4, 2, 1) evaluate
/// the low-frequency n×n coefficients on an n-point grid in float (DCT-domain scaling for thumbnails).
/// </summary>
internal static class JpegIdct
{
private const int ConstBits = 13;
private const int Fix0298631336 = 2446, Fix0390180644 = 3196, Fix0541196100 = 4433, Fix0765366865 = 6270;
private const int Fix0899976223 = 7373, Fix1175875602 = 9633, Fix1501321110 = 12299, Fix1847759065 = 15137;
private const int Fix1961570560 = 16069, Fix2053119869 = 16819, Fix2562915447 = 20995, Fix3072711026 = 25172;
private static readonly float[] Basis4 = JpegTables.BuildBasis(4);
private static readonly float[] Basis2 = JpegTables.BuildBasis(2);
/// <summary>Transforms one block into n·n samples, level-shifted and clamped to 0..2^precision−1.</summary>
/// <param name="coefficients">64 quantised coefficients, natural order.</param>
/// <param name="quant">64 dequantisation factors, natural order.</param>
/// <param name="size">Output block size: 8, 4, 2 or 1.</param>
/// <param name="precision">Sample precision (8 or 12).</param>
public static void Transform(ReadOnlySpan<short> coefficients, ReadOnlySpan<int> quant, int size, int precision, Span<int> output)
{
var max = (1 << precision) - 1;
var center = 1 << (precision - 1);
if (size == 8)
{
Islow(coefficients, quant, precision == 8 ? 2 : 1, center, max, output);
return;
}
if (size == 1)
{
output[0] = Math.Clamp((int)MathF.Round(coefficients[0] * quant[0] * 0.125f) + center, 0, max);
return;
}
Reduced(coefficients, quant, size, size == 4 ? Basis4 : Basis2, center, max, output);
}
/// <summary>Port of libjpeg-turbo jpeg_idct_islow (columns, then rows; PASS1_BITS 2 for 8-bit, 1 for 12-bit).</summary>
private static void Islow(ReadOnlySpan<short> c, ReadOnlySpan<int> q, int pass1Bits, int center, int max, Span<int> output)
{
Span<int> ws = stackalloc int[64];
_ = c[63];
_ = q[63];
for (var col = 0; col < 8; col++)
{
if (c[8 + col] == 0 && c[16 + col] == 0 && c[24 + col] == 0 && c[32 + col] == 0 &&
c[40 + col] == 0 && c[48 + col] == 0 && c[56 + col] == 0)
{
var dc = c[col] * q[col] << pass1Bits;
for (var r = 0; r < 8; r++) ws[r * 8 + col] = dc;
continue;
}
var shift = ConstBits - pass1Bits;
Butterfly(
c[col] * q[col], c[8 + col] * q[8 + col], c[16 + col] * q[16 + col], c[24 + col] * q[24 + col],
c[32 + col] * q[32 + col], c[40 + col] * q[40 + col], c[48 + col] * q[48 + col], c[56 + col] * q[56 + col],
out var o0, out var o1, out var o2, out var o3, out var o4, out var o5, out var o6, out var o7);
var round = 1 << (shift - 1);
ws[col] = (o0 + round) >> shift;
ws[8 + col] = (o1 + round) >> shift;
ws[16 + col] = (o2 + round) >> shift;
ws[24 + col] = (o3 + round) >> shift;
ws[32 + col] = (o4 + round) >> shift;
ws[40 + col] = (o5 + round) >> shift;
ws[48 + col] = (o6 + round) >> shift;
ws[56 + col] = (o7 + round) >> shift;
}
for (var row = 0; row < 8; row++)
{
var w = ws.Slice(row * 8, 8);
var o = output.Slice(row * 8, 8);
if (w[1] == 0 && w[2] == 0 && w[3] == 0 && w[4] == 0 && w[5] == 0 && w[6] == 0 && w[7] == 0)
{
var dcShift = pass1Bits + 3;
o.Fill(Math.Clamp(((w[0] + (1 << (dcShift - 1))) >> dcShift) + center, 0, max));
continue;
}
var shift = ConstBits + pass1Bits + 3;
var round = 1 << (shift - 1);
Butterfly(w[0], w[1], w[2], w[3], w[4], w[5], w[6], w[7],
out var o0, out var o1, out var o2, out var o3, out var o4, out var o5, out var o6, out var o7);
o[0] = Math.Clamp(((o0 + round) >> shift) + center, 0, max);
o[1] = Math.Clamp(((o1 + round) >> shift) + center, 0, max);
o[2] = Math.Clamp(((o2 + round) >> shift) + center, 0, max);
o[3] = Math.Clamp(((o3 + round) >> shift) + center, 0, max);
o[4] = Math.Clamp(((o4 + round) >> shift) + center, 0, max);
o[5] = Math.Clamp(((o5 + round) >> shift) + center, 0, max);
o[6] = Math.Clamp(((o6 + round) >> shift) + center, 0, max);
o[7] = Math.Clamp(((o7 + round) >> shift) + center, 0, max);
}
}
/// <summary>One 8-point ISLOW pass; outputs are scaled by 2^13 (CONST_BITS) before descaling.</summary>
private static void Butterfly(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7,
out int o0, out int o1, out int o2, out int o3, out int o4, out int o5, out int o6, out int o7)
{
// Even part: the rotator is sqrt(2)·c(−6).
var z1 = (i2 + i6) * Fix0541196100;
var tmp2 = z1 - i6 * Fix1847759065;
var tmp3 = z1 + i2 * Fix0765366865;
var tmp0 = (i0 + i4) << ConstBits;
var tmp1 = (i0 - i4) << ConstBits;
int tmp10 = tmp0 + tmp3, tmp13 = tmp0 - tmp3, tmp11 = tmp1 + tmp2, tmp12 = tmp1 - tmp2;
// Odd part (figure 8 of the LL&M paper).
tmp0 = i7;
tmp1 = i5;
tmp2 = i3;
tmp3 = i1;
z1 = tmp0 + tmp3;
var z2 = tmp1 + tmp2;
var z3 = tmp0 + tmp2;
var z4 = tmp1 + tmp3;
var z5 = (z3 + z4) * Fix1175875602;
tmp0 *= Fix0298631336;
tmp1 *= Fix2053119869;
tmp2 *= Fix3072711026;
tmp3 *= Fix1501321110;
z1 *= -Fix0899976223;
z2 *= -Fix2562915447;
z3 = z3 * -Fix1961570560 + z5;
z4 = z4 * -Fix0390180644 + z5;
tmp0 += z1 + z3;
tmp1 += z2 + z4;
tmp2 += z2 + z3;
tmp3 += z1 + z4;
o0 = tmp10 + tmp3;
o7 = tmp10 - tmp3;
o1 = tmp11 + tmp2;
o6 = tmp11 - tmp2;
o2 = tmp12 + tmp1;
o5 = tmp12 - tmp1;
o3 = tmp13 + tmp0;
o4 = tmp13 - tmp0;
}
/// <summary>n-point IDCT of the low-frequency n×n coefficients, evaluated at the centres of n output samples.</summary>
private static void Reduced(ReadOnlySpan<short> coefficients, ReadOnlySpan<int> quant, int n, float[] basis, int center, int max, Span<int> output)
{
Span<float> g = stackalloc float[n * n];
Span<float> f = stackalloc float[n];
g.Clear();
for (var v = 0; v < n; v++)
{
var row = g.Slice(v * n, n);
for (var u = 0; u < n; u++)
{
int coef = coefficients[v * 8 + u];
if (coef == 0) continue;
var value = (float)(coef * quant[v * 8 + u]);
for (var x = 0; x < n; x++) row[x] += value * basis[u * n + x];
}
}
for (var y = 0; y < n; y++)
{
f.Clear();
for (var v = 0; v < n; v++)
{
var w = basis[v * n + y];
var row = g.Slice(v * n, n);
for (var x = 0; x < n; x++) f[x] += w * row[x];
}
for (var x = 0; x < n; x++) output[y * n + x] = Math.Clamp((int)MathF.Round(f[x]) + center, 0, max);
}
}
}
@@ -0,0 +1,136 @@
namespace Titano.Core.Codecs.Jpeg;
/// <summary>
/// Lossless JPEG (SOF3, ITU T.81 Annex H) as used by DNG raw tiles and CR2: predictors 1–7, point transform,
/// 2–16 bit precision, one or more components (interleaved or in separate scans), restart intervals.
/// </summary>
public static class JpegLosslessDecoder
{
/// <summary>Decodes a lossless stream to interleaved samples with the frame's own width and component count
/// (DNG tiles often encode e.g. two components at half the tile width; callers re-map the sample order).</summary>
/// <exception cref="InvalidDataException">The stream is malformed or not lossless.</exception>
public static JpegLosslessImage Decode(ReadOnlySpan<byte> data)
{
var parser = new JpegParser(JpegDecodeOptions.Default);
parser.Parse(data);
if (parser.Frame!.Process != JpegProcess.Lossless) throw new InvalidDataException("JPEG: not a lossless (SOF3) stream");
return Finish(parser);
}
/// <summary>Applies each component's point transform and packages the samples.</summary>
internal static JpegLosslessImage Finish(JpegParser parser)
{
var f = parser.Frame!;
var n = f.Components.Length;
var samples = parser.LosslessSamples ?? new ushort[checked(f.Width * f.Height * n)];
foreach (var c in f.Components)
{
if (c.PointTransform == 0) continue;
for (var i = c.Index; i < samples.Length; i += n) samples[i] = (ushort)(samples[i] << c.PointTransform);
c.PointTransform = 0;
}
parser.LosslessSamples = samples;
return new JpegLosslessImage(samples, f.Width, f.Height, n, f.Precision);
}
internal static int DecodeScan(JpegParser parser, ReadOnlySpan<byte> data, int pos, JpegScan scan)
{
var f = parser.Frame!;
int width = f.Width, nf = f.Components.Length, stride = width * nf;
var samples = parser.LosslessSamples ??= new ushort[checked(stride * f.Height)];
var comps = scan.Components;
var tables = scan.DcTables;
var ns = comps.Length;
var index = new int[ns];
for (var i = 0; i < ns; i++)
{
index[i] = comps[i].Index;
comps[i].PointTransform = scan.Al;
}
var predictor = scan.Ss;
var initial = 1 << (f.Precision - scan.Al - 1);
var interval = parser.RestartInterval;
var total = (long)width * f.Height;
var reader = new JpegBitReader(data, pos);
long mcu = 0;
int x = 0, y = 0, restartRow = 0, expectedRst = 0;
var first = true;
while (mcu < total)
{
var end = interval > 0 ? Math.Min(total, mcu + interval) : total;
try
{
for (; mcu < end; mcu++)
{
var at = y * stride + x * nf;
for (var i = 0; i < ns; i++)
{
var s = reader.Decode(tables[i]!);
var diff = s switch
{
0 => 0,
16 => 32768,
> 16 => throw new JpegEntropyException("JPEG: bad lossless difference magnitude"),
_ => reader.Receive(s),
};
var idx = at + index[i];
int pred;
if (first) pred = initial;
else if (y == restartRow) pred = samples[idx - nf];
else if (x == 0) pred = samples[idx - stride];
else pred = Predict(predictor, samples[idx - nf], samples[idx - stride], samples[idx - stride - nf]);
samples[idx] = (ushort)(pred + diff);
}
first = false;
if (++x == width)
{
x = 0;
y++;
if (reader.Overrun) throw new JpegEntropyException("JPEG: premature end of entropy-coded data");
}
}
if (reader.Overrun) throw new JpegEntropyException("JPEG: premature end of entropy-coded data");
}
catch (JpegEntropyException ex)
{
parser.Warn(ex.Message);
if (interval == 0) break;
mcu = end;
}
if (mcu >= total || interval == 0) break;
var marker = reader.FindMarker();
if (marker is < JpegTables.Rst0 or > JpegTables.Rst0 + 7)
{
parser.Warn("JPEG: restart marker missing; scan truncated");
break;
}
var found = marker - JpegTables.Rst0;
if (found != expectedRst)
{
var lost = (found - expectedRst) & 7;
parser.Warn($"JPEG: {lost} restart interval(s) lost");
mcu += (long)lost * interval;
}
reader.AcceptMarker();
expectedRst = (found + 1) & 7;
x = (int)(mcu % width);
y = (int)(mcu / width);
restartRow = y;
first = true;
}
return reader.Position;
}
private static int Predict(int predictor, int ra, int rb, int rc) => predictor switch
{
1 => ra,
2 => rb,
3 => rc,
4 => ra + rb - rc,
5 => ra + ((rb - rc) >> 1),
6 => rb + ((ra - rc) >> 1),
_ => (ra + rb) >> 1,
};
}
+400
View File
@@ -0,0 +1,400 @@
namespace Titano.Core.Codecs.Jpeg;
/// <summary>One frame component and its coefficient (DCT) storage.</summary>
internal sealed class JpegComponent
{
public int Id, Index, H, V, QuantTable;
/// <summary>Component size in samples: ceil(X·H/Hmax) × ceil(Y·V/Vmax).</summary>
public int Width, Height;
/// <summary>Blocks covering the component (non-interleaved scan extent).</summary>
public int WidthInBlocks, HeightInBlocks;
/// <summary>Allocated block grid, padded to whole MCUs.</summary>
public int BlocksPerLine, BlocksPerColumn;
/// <summary>Quantised coefficients, 64 per block in natural order, blocks row-major.</summary>
public short[]? Coefficients;
/// <summary>Quantisation table latched when the component's first scan starts (natural order).</summary>
public ushort[]? Quant;
/// <summary>Point transform of the lossless scan that carried this component.</summary>
public int PointTransform;
public int DcPred;
}
/// <summary>Frame header (SOFn) with derived MCU geometry.</summary>
internal sealed class JpegFrame
{
public required JpegProcess Process { get; init; }
public required int Precision { get; init; }
public required int Width { get; init; }
public required int Height { get; init; }
public required JpegComponent[] Components { get; init; }
public int HMax { get; init; }
public int VMax { get; init; }
public int McusX { get; init; }
public int McusY { get; init; }
}
/// <summary>Scan header (SOS) resolved against the frame.</summary>
internal sealed class JpegScan
{
public required JpegComponent[] Components { get; init; }
public required JpegHuffmanTable?[] DcTables { get; init; }
public required JpegHuffmanTable?[] AcTables { get; init; }
public int Ss { get; init; }
public int Se { get; init; }
public int Ah { get; init; }
public int Al { get; init; }
}
/// <summary>
/// Marker-level JPEG parser: tables, frame and scan headers; dispatches entropy-coded segments to the DCT or
/// lossless scan decoders. Structural errors throw <see cref="InvalidDataException"/>; once a scan has been
/// decoded, later errors only end parsing with a warning so that partial images survive.
/// </summary>
internal sealed class JpegParser(JpegDecodeOptions options)
{
private readonly ushort[]?[] _quant = new ushort[4][];
private readonly JpegHuffmanTable?[] _dc = new JpegHuffmanTable[4];
private readonly JpegHuffmanTable?[] _ac = new JpegHuffmanTable[4];
private readonly List<string> _warnings = [];
private static JpegHuffmanTable? _stdDcLuma, _stdDcChroma, _stdAcLuma, _stdAcChroma;
public JpegDecodeOptions Options { get; } = options;
public JpegFrame? Frame { get; private set; }
public int RestartInterval { get; private set; }
public int AdobeTransform { get; private set; } = -1;
public bool Jfif { get; private set; }
public int ScansDecoded { get; private set; }
public IReadOnlyList<string> Warnings => _warnings;
/// <summary>Interleaved samples of a lossless frame (point transform not yet applied).</summary>
public ushort[]? LosslessSamples { get; set; }
public void Warn(string message)
{
if (_warnings.Count < 64) _warnings.Add(message);
}
/// <summary>Parses a full stream. With <paramref name="headerOnly"/> it stops at the first scan header.</summary>
public void Parse(ReadOnlySpan<byte> data, bool headerOnly = false)
{
if (Options.Tables is { Length: > 0 } tables) ParseCore(tables, tablesOnly: true, headerOnly: false);
try
{
ParseCore(data, tablesOnly: false, headerOnly);
}
catch (InvalidDataException ex) when (ScansDecoded > 0)
{
Warn(ex.Message);
}
if (Frame is null) throw new InvalidDataException("JPEG: no frame header");
if (!headerOnly && ScansDecoded == 0) throw new InvalidDataException("JPEG: no scan data");
}
public JpegInfo Info()
{
var f = Frame ?? throw new InvalidDataException("JPEG: no frame header");
return new JpegInfo(
f.Width, f.Height, f.Components.Length, f.Precision, f.Process, ColorSpace(),
f.Components.Select(c => (c.H, c.V)).ToArray(), RestartInterval);
}
/// <summary>Colour space after applying the option override and libjpeg's marker/component-id heuristics.</summary>
public JpegColorSpace ColorSpace()
{
var f = Frame!;
var n = f.Components.Length;
if (n == 1) return JpegColorSpace.Gray;
if (f.Process == JpegProcess.Lossless && Options.ColorTransform == JpegColorTransform.Auto)
return n switch { 3 => JpegColorSpace.Rgb, 4 => JpegColorSpace.Cmyk, _ => JpegColorSpace.Other };
var transformed = Options.ColorTransform switch
{
JpegColorTransform.None => false,
JpegColorTransform.YCbCr => true,
_ => n == 3
? Jfif || (AdobeTransform < 0 ? !(f.Components[0].Id == 'R' && f.Components[1].Id == 'G' && f.Components[2].Id == 'B') : AdobeTransform != 0)
: AdobeTransform == 2,
};
return n switch
{
3 => transformed ? JpegColorSpace.YCbCr : JpegColorSpace.Rgb,
4 => transformed ? JpegColorSpace.Ycck : JpegColorSpace.Cmyk,
_ => JpegColorSpace.Other,
};
}
private void ParseCore(ReadOnlySpan<byte> data, bool tablesOnly, bool headerOnly)
{
if (data.Length < 4 || data[0] != 0xFF || data[1] != JpegTables.Soi) throw new InvalidDataException("JPEG: missing SOI marker");
var pos = 2;
while (true)
{
var marker = NextMarker(data, ref pos);
if (marker < 0)
{
if (!tablesOnly) Warn("JPEG: missing EOI marker");
return;
}
if (marker == JpegTables.Eoi) return;
if (marker is JpegTables.Soi or (>= JpegTables.Rst0 and <= JpegTables.Rst0 + 7) or 0x01) continue;
if (pos + 2 > data.Length) throw new InvalidDataException("JPEG: truncated marker segment");
var length = data[pos] << 8 | data[pos + 1];
if (length < 2 || pos + length > data.Length) throw new InvalidDataException($"JPEG: bad length for marker 0x{marker:X2}");
var segment = data.Slice(pos + 2, length - 2);
pos += length;
switch (marker)
{
case JpegTables.Dqt:
ParseDqt(segment);
break;
case JpegTables.Dht:
ParseDht(segment);
break;
case JpegTables.Dri:
if (segment.Length < 2) throw new InvalidDataException("JPEG: bad DRI");
RestartInterval = segment[0] << 8 | segment[1];
break;
case JpegTables.App0:
if (segment.StartsWith("JFIF\0"u8)) Jfif = true;
break;
case JpegTables.App14:
if (segment.Length >= 12 && segment.StartsWith("Adobe"u8)) AdobeTransform = segment[11];
break;
case >= JpegTables.Sof0 and <= JpegTables.Sof3:
if (tablesOnly) throw new InvalidDataException("JPEG: frame header in a tables-only stream");
if (Frame is not null) throw new InvalidDataException("JPEG: more than one frame");
ParseSof(marker, segment);
break;
case JpegTables.Sos:
if (tablesOnly || Frame is null) throw new InvalidDataException("JPEG: scan without frame header");
if (headerOnly) return;
pos = DecodeScan(data, segment, pos);
ScansDecoded++;
break;
case JpegTables.Dac:
throw new InvalidDataException("JPEG: arithmetic coding is not supported");
case >= 0xC5 and <= 0xCF:
throw new InvalidDataException($"JPEG: unsupported coding process (SOF 0x{marker:X2})");
}
}
}
/// <summary>Finds the next marker at or after <paramref name="pos"/>, skipping garbage; returns its code or -1.</summary>
private int NextMarker(ReadOnlySpan<byte> data, ref int pos)
{
var start = pos;
while (pos + 1 < data.Length)
{
if (data[pos] != 0xFF)
{
pos++;
continue;
}
int m = data[pos + 1];
if (m == 0xFF)
{
pos++;
continue;
}
if (m == 0)
{
pos += 2;
continue;
}
if (pos != start) Warn($"JPEG: {pos - start} extraneous bytes before marker 0x{m:X2}");
pos += 2;
return m;
}
pos = data.Length;
return -1;
}
private void ParseDqt(ReadOnlySpan<byte> s)
{
while (s.Length > 0)
{
int pq = s[0] >> 4, tq = s[0] & 15;
var size = pq == 0 ? 64 : 128;
if (pq > 1 || tq > 3 || s.Length < 1 + size) throw new InvalidDataException("JPEG: bad DQT");
var table = new ushort[64];
for (var k = 0; k < 64; k++)
{
table[JpegTables.NaturalOrder[k]] = pq == 0 ? s[1 + k] : (ushort)(s[1 + 2 * k] << 8 | s[2 + 2 * k]);
}
_quant[tq] = table;
s = s[(1 + size)..];
}
}
private void ParseDht(ReadOnlySpan<byte> s)
{
while (s.Length > 0)
{
if (s.Length < 17) throw new InvalidDataException("JPEG: bad DHT");
int tc = s[0] >> 4, th = s[0] & 15;
if (tc > 1 || th > 3) throw new InvalidDataException("JPEG: bad DHT class/id");
var counts = s.Slice(1, 16);
var total = 0;
foreach (var c in counts) total += c;
if (total > 256 || s.Length < 17 + total) throw new InvalidDataException("JPEG: bad DHT counts");
var table = new JpegHuffmanTable(counts, s.Slice(17, total));
(tc == 0 ? _dc : _ac)[th] = table;
s = s[(17 + total)..];
}
}
private void ParseSof(int marker, ReadOnlySpan<byte> s)
{
if (s.Length < 6) throw new InvalidDataException("JPEG: bad SOF");
var process = marker switch
{
JpegTables.Sof0 => JpegProcess.Baseline,
JpegTables.Sof1 => JpegProcess.ExtendedSequential,
JpegTables.Sof2 => JpegProcess.Progressive,
_ => JpegProcess.Lossless,
};
int precision = s[0], height = s[1] << 8 | s[2], width = s[3] << 8 | s[4], n = s[5];
if (process == JpegProcess.Lossless ? precision is < 2 or > 16 : precision is not (8 or 12))
throw new InvalidDataException($"JPEG: unsupported precision {precision}");
if (width == 0 || height == 0) throw new InvalidDataException("JPEG: zero image size (DNL is not supported)");
if ((long)width * height > Options.MaxPixels) throw new InvalidDataException($"JPEG: {width}x{height} exceeds the pixel limit");
if (n is < 1 or > 4 || s.Length < 6 + 3 * n) throw new InvalidDataException("JPEG: bad component count");
var components = new JpegComponent[n];
int hMax = 1, vMax = 1;
for (var i = 0; i < n; i++)
{
var c = s.Slice(6 + 3 * i, 3);
int h = c[1] >> 4, v = c[1] & 15;
if (h is < 1 or > 4 || v is < 1 or > 4 || c[2] > 3) throw new InvalidDataException("JPEG: bad sampling factors");
components[i] = new JpegComponent { Id = c[0], Index = i, H = h, V = v, QuantTable = c[2] };
hMax = Math.Max(hMax, h);
vMax = Math.Max(vMax, v);
}
if (n == 1)
{
// A single component is always coded non-interleaved: its own factors are irrelevant.
components[0].H = components[0].V = hMax = vMax = 1;
}
foreach (var c in components)
{
if (hMax % c.H != 0 || vMax % c.V != 0) throw new InvalidDataException("JPEG: fractional sampling ratios are not supported");
if (process == JpegProcess.Lossless && (c.H != 1 || c.V != 1))
throw new InvalidDataException("JPEG: subsampled lossless streams are not supported");
}
var unit = process == JpegProcess.Lossless ? 1 : 8;
var mcusX = DivUp(width, unit * hMax);
var mcusY = DivUp(height, unit * vMax);
foreach (var c in components)
{
c.Width = DivUp(width * c.H, hMax);
c.Height = DivUp(height * c.V, vMax);
c.WidthInBlocks = DivUp(c.Width, 8);
c.HeightInBlocks = DivUp(c.Height, 8);
c.BlocksPerLine = mcusX * c.H;
c.BlocksPerColumn = mcusY * c.V;
}
Frame = new JpegFrame
{
Process = process, Precision = precision, Width = width, Height = height, Components = components,
HMax = hMax, VMax = vMax, McusX = mcusX, McusY = mcusY,
};
}
private int DecodeScan(ReadOnlySpan<byte> data, ReadOnlySpan<byte> s, int pos)
{
var frame = Frame!;
if (s.Length < 1) throw new InvalidDataException("JPEG: bad SOS");
int n = s[0];
if (n is < 1 or > 4 || s.Length < 4 + 2 * n) throw new InvalidDataException("JPEG: bad SOS component count");
var comps = new JpegComponent[n];
var dc = new JpegHuffmanTable?[n];
var ac = new JpegHuffmanTable?[n];
var tdTa = new int[n];
for (var i = 0; i < n; i++)
{
int id = s[1 + 2 * i];
JpegComponent? match = null;
foreach (var c in frame.Components)
{
if (c.Id == id && Array.IndexOf(comps, c) < 0)
{
match = c;
break;
}
}
comps[i] = match ?? throw new InvalidDataException($"JPEG: scan references unknown component {id}");
tdTa[i] = s[2 + 2 * i];
}
var p = 1 + 2 * n;
int ss = s[p], se = s[p + 1], ah = s[p + 2] >> 4, al = s[p + 2] & 15;
if (frame.Process == JpegProcess.Lossless)
{
if (ss is < 1 or > 7) throw new InvalidDataException($"JPEG: bad lossless predictor {ss}");
if (al >= frame.Precision) throw new InvalidDataException("JPEG: bad point transform");
for (var i = 0; i < n; i++) dc[i] = _dc[tdTa[i] >> 4 & 3] ?? throw new InvalidDataException("JPEG: missing Huffman table");
var losslessScan = new JpegScan { Components = comps, DcTables = dc, AcTables = ac, Ss = ss, Al = al };
return JpegLosslessDecoder.DecodeScan(this, data, pos, losslessScan);
}
var progressive = frame.Process == JpegProcess.Progressive;
if (progressive)
{
if (ss > se || se > 63 || (ss == 0 && se != 0) || (ss > 0 && n != 1) || al > 13 || ah > 13)
throw new InvalidDataException("JPEG: bad progressive scan parameters");
}
else
{
ss = 0;
se = 63;
ah = al = 0;
}
if (n > 1)
{
var blocks = 0;
foreach (var c in comps) blocks += c.H * c.V;
if (blocks > 10) throw new InvalidDataException("JPEG: too many blocks per MCU");
}
var needDc = ss == 0 && ah == 0;
var needAc = se > 0;
for (var i = 0; i < n; i++)
{
int td = tdTa[i] >> 4, ta = tdTa[i] & 15;
if (td > 3 || ta > 3) throw new InvalidDataException("JPEG: bad Huffman table selector");
if (needDc) dc[i] = _dc[td] ?? StandardTable(dc: true, td);
if (needAc) ac[i] = _ac[ta] ?? StandardTable(dc: false, ta);
var c = comps[i];
if (c.Quant is null)
{
c.Quant = _quant[c.QuantTable] is { } q ? (ushort[])q.Clone() : throw new InvalidDataException("JPEG: missing quantisation table");
}
c.Coefficients ??= new short[checked(c.BlocksPerLine * c.BlocksPerColumn * 64)];
}
var scan = new JpegScan { Components = comps, DcTables = dc, AcTables = ac, Ss = ss, Se = se, Ah = ah, Al = al };
return JpegScanDecoder.Decode(this, data, pos, scan);
}
/// <summary>Quantisation table for a component that never appeared in a scan (rendered flat).</summary>
public ushort[] QuantFor(JpegComponent c) => c.Quant ?? _quant[c.QuantTable] ?? new ushort[64];
/// <summary>Annex K tables for streams that omit DHT (Motion-JPEG), as libjpeg does.</summary>
private static JpegHuffmanTable StandardTable(bool dc, int id)
{
if (id > 1) throw new InvalidDataException("JPEG: missing Huffman table");
return (dc, id) switch
{
(true, 0) => _stdDcLuma ??= new JpegHuffmanTable(JpegTables.DcLumaBits, JpegTables.DcLumaValues),
(true, _) => _stdDcChroma ??= new JpegHuffmanTable(JpegTables.DcChromaBits, JpegTables.DcChromaValues),
(false, 0) => _stdAcLuma ??= new JpegHuffmanTable(JpegTables.AcLumaBits, JpegTables.AcLumaValues),
_ => _stdAcChroma ??= new JpegHuffmanTable(JpegTables.AcChromaBits, JpegTables.AcChromaValues),
};
}
internal static int DivUp(int a, int b) => (int)(((long)a + b - 1) / b);
}
+378
View File
@@ -0,0 +1,378 @@
using System.Buffers;
using System.Numerics;
using Titano.Core.Imaging;
namespace Titano.Core.Codecs.Jpeg;
/// <summary>
/// Turns decoded coefficients into pixels: (A) parallel IDCT of every block into per-component sample planes,
/// (B) parallel bands of rows doing chroma upsampling (libjpeg "fancy" triangle filters for 2× factors,
/// replication otherwise) and colour conversion (libjpeg's fixed-point YCbCr tables, CMYK/YCCK → RGB).
/// </summary>
internal sealed class JpegRenderer
{
private const int BandRows = 16;
private readonly JpegParser _parser;
private readonly JpegFrame _frame;
private readonly int _n;
private readonly bool _fancy;
private readonly int _max;
private readonly JpegColorSpace _colorSpace;
private readonly bool _invertedCmyk;
private readonly ParallelOptions _parallel;
private readonly byte[]?[] _planes8;
private readonly ushort[]?[] _planes16;
private readonly int[] _stride, _validW, _validH, _hf, _vf;
public JpegRenderer(JpegParser parser)
{
_parser = parser;
_frame = parser.Frame!;
var options = parser.Options;
_n = BlockSize(_frame, options.MaxLongEdge);
_fancy = options.FancyUpsampling && _n > 1;
_max = (1 << _frame.Precision) - 1;
_colorSpace = parser.ColorSpace();
_invertedCmyk = parser.AdobeTransform >= 0 || _colorSpace == JpegColorSpace.Ycck;
_parallel = new ParallelOptions { MaxDegreeOfParallelism = options.MaxDegreeOfParallelism };
Width = JpegParser.DivUp(_frame.Width * _n, 8);
Height = JpegParser.DivUp(_frame.Height * _n, 8);
Channels = _colorSpace == JpegColorSpace.Gray ? 1 : 3;
if (_colorSpace == JpegColorSpace.Other) throw new InvalidDataException("JPEG: component count has no colour interpretation");
var count = _frame.Components.Length;
_planes8 = new byte[count][];
_planes16 = new ushort[count][];
_stride = new int[count];
_validW = new int[count];
_validH = new int[count];
_hf = new int[count];
_vf = new int[count];
for (var i = 0; i < count; i++)
{
var c = _frame.Components[i];
_hf[i] = _frame.HMax / c.H;
_vf[i] = _frame.VMax / c.V;
_validW[i] = JpegParser.DivUp(_frame.Width * c.H * _n, _frame.HMax * 8);
_validH[i] = JpegParser.DivUp(_frame.Height * c.V * _n, _frame.VMax * 8);
}
}
public int Width { get; }
public int Height { get; }
/// <summary>Output channels: 1 for gray, 3 otherwise.</summary>
public int Channels { get; }
/// <summary>IDCT output size per block (8 = full size, 4/2/1 = DCT-domain scaling) for a requested long edge.</summary>
public static int BlockSize(JpegFrame frame, int maxLongEdge)
{
if (maxLongEdge <= 0) return 8;
var longEdge = Math.Max(frame.Width, frame.Height);
foreach (var n in (ReadOnlySpan<int>)[1, 2, 4])
{
if (JpegParser.DivUp(longEdge * n, 8) >= maxLongEdge) return n;
}
return 8;
}
public JpegImage RenderInterleaved(JpegInfo info)
{
RunIdct();
var length = checked(Width * Height * Channels);
if (_frame.Precision <= 8)
{
var pixels = new byte[length];
Render((y, rows) =>
{
var dst = pixels.AsSpan(y * Width * Channels, Width * Channels);
for (var c = 0; c < Channels; c++)
{
var src = rows[c];
for (var x = 0; x < Width; x++) dst[x * Channels + c] = (byte)src[x];
}
});
return new JpegImage(info, Width, Height, Channels, 8, pixels, null, [.. _parser.Warnings]);
}
var pixels16 = new ushort[length];
Render((y, rows) =>
{
var dst = pixels16.AsSpan(y * Width * Channels, Width * Channels);
for (var c = 0; c < Channels; c++)
{
var src = rows[c];
for (var x = 0; x < Width; x++) dst[x * Channels + c] = (ushort)src[x];
}
});
return new JpegImage(info, Width, Height, Channels, _frame.Precision, null, pixels16, [.. _parser.Warnings]);
}
/// <summary>Renders straight into linear-light float planes (sRGB transfer removed by table lookup).</summary>
public ImageBuffer RenderLinear(bool expandGray)
{
RunIdct();
var lut = _frame.Precision == 8 ? null : JpegDecoder.LinearLut(_frame.Precision);
var outChannels = Channels == 1 && !expandGray ? 1 : 3;
var image = new ImageBuffer(Width, Height, outChannels, clear: false);
var storage = image.Storage;
var plane = image.PlaneLength;
Render((y, rows) =>
{
for (var c = 0; c < outChannels; c++)
{
var src = rows[Channels == 1 ? 0 : c];
var dst = storage.AsSpan(c * plane + y * Width, Width);
if (lut is null)
{
for (var x = 0; x < dst.Length; x++) dst[x] = ColorSpace.Linear8((byte)src[x]);
}
else
{
for (var x = 0; x < dst.Length; x++) dst[x] = lut[src[x]];
}
}
});
return image;
}
private void RunIdct()
{
var comps = _frame.Components;
var center = 1 << (_frame.Precision - 1);
var jobs = new List<(int Component, int BlockRow)>();
for (var i = 0; i < comps.Length; i++)
{
var c = comps[i];
_stride[i] = c.BlocksPerLine * _n;
var length = checked(_stride[i] * c.BlocksPerColumn * _n);
if (_frame.Precision <= 8) _planes8[i] = new byte[length];
else _planes16[i] = new ushort[length];
var blockRows = JpegParser.DivUp(_validH[i], _n);
for (var by = 0; by < blockRows; by++) jobs.Add((i, by));
}
var quant = new int[comps.Length][];
for (var i = 0; i < comps.Length; i++) quant[i] = Array.ConvertAll(_parser.QuantFor(comps[i]), q => (int)q);
Parallel.For(0, jobs.Count, _parallel, () => new int[64], (j, _, block) =>
{
var (i, by) = jobs[j];
var c = comps[i];
var stride = _stride[i];
var rowOffset = by * _n * stride;
if (c.Coefficients is not { } coefficients)
{
// Component never scanned: flat mid-grey, like zero coefficients.
if (_planes8[i] is { } flat8) flat8.AsSpan(rowOffset, _n * stride).Fill((byte)center);
else _planes16[i].AsSpan(rowOffset, _n * stride).Fill((ushort)center);
return block;
}
var blocks = JpegParser.DivUp(_validW[i], _n);
for (var bx = 0; bx < blocks; bx++)
{
JpegIdct.Transform(coefficients.AsSpan((by * c.BlocksPerLine + bx) * 64, 64), quant[i], _n, _frame.Precision, block);
var at = rowOffset + bx * _n;
for (var y = 0; y < _n; y++, at += stride)
{
var src = block.AsSpan(y * _n, _n);
if (_planes8[i] is { } p8)
{
var dst = p8.AsSpan(at, _n);
for (var x = 0; x < _n; x++) dst[x] = (byte)src[x];
}
else
{
var dst = _planes16[i].AsSpan(at, _n);
for (var x = 0; x < _n; x++) dst[x] = (ushort)src[x];
}
}
}
return block;
}, _ => { });
foreach (var c in comps) c.Coefficients = null;
}
private delegate void RowSink(int y, int[][] rows);
private void Render(RowSink sink)
{
var bands = JpegParser.DivUp(Height, BandRows);
var count = _frame.Components.Length;
var ycc = _colorSpace is JpegColorSpace.YCbCr or JpegColorSpace.Ycck ? YccTables.For(_frame.Precision) : null;
Parallel.For(0, bands, _parallel, band =>
{
var rows = new int[count][];
for (var c = 0; c < count; c++) rows[c] = ArrayPool<int>.Shared.Rent(Width + 1);
try
{
var end = Math.Min(Height, (band + 1) * BandRows);
for (var y = band * BandRows; y < end; y++)
{
for (var c = 0; c < count; c++)
{
if (_planes8[c] is { } p8) Upsample(p8, c, y, rows[c]);
else Upsample(_planes16[c]!, c, y, rows[c]);
}
ConvertColor(rows, ycc);
sink(y, rows);
}
}
finally
{
foreach (var r in rows) ArrayPool<int>.Shared.Return(r);
}
});
}
/// <summary>Writes one output row of component <paramref name="c"/> at full output width. <paramref name="dst"/>
/// holds at least <c>Width + 1</c> values, enough for the 2·w samples a 2× upsampler produces.</summary>
private void Upsample<T>(T[] plane, int c, int y, int[] dst) where T : unmanaged, IBinaryInteger<T>
{
int hf = _hf[c], vf = _vf[c], stride = _stride[c], w = _validW[c], h = _validH[c];
var cy = Math.Min(y / vf, h - 1);
var near = plane.AsSpan(cy * stride, w);
var width = Width;
if (hf == 1 && vf == 1)
{
for (var x = 0; x < width; x++) dst[x] = int.CreateTruncating(near[x]);
return;
}
if (_fancy && vf == 2 && hf <= 2)
{
var upper = (y & 1) == 0;
var far = plane.AsSpan(Math.Clamp(upper ? cy - 1 : cy + 1, 0, h - 1) * stride, w);
if (hf == 1)
{
var bias = upper ? 1 : 2;
for (var x = 0; x < width; x++) dst[x] = (3 * int.CreateTruncating(near[x]) + int.CreateTruncating(far[x]) + bias) >> 2;
return;
}
if (w > 2)
{
H2V2(near, far, w, dst);
return;
}
}
if (_fancy && hf == 2 && vf == 1 && w > 2)
{
H2V1(near, w, dst);
return;
}
for (var x = 0; x < width; x++) dst[x] = int.CreateTruncating(near[x / hf]);
}
/// <summary>libjpeg h2v1_fancy_upsample: 3/4·nearer + 1/4·further, alternating rounding bias.</summary>
private static void H2V1<T>(ReadOnlySpan<T> s, int w, Span<int> o) where T : unmanaged, IBinaryInteger<T>
{
var first = int.CreateTruncating(s[0]);
o[0] = first;
o[1] = (3 * first + int.CreateTruncating(s[1]) + 2) >> 2;
for (var i = 1; i < w - 1; i++)
{
var v = 3 * int.CreateTruncating(s[i]);
o[2 * i] = (v + int.CreateTruncating(s[i - 1]) + 1) >> 2;
o[2 * i + 1] = (v + int.CreateTruncating(s[i + 1]) + 2) >> 2;
}
var last = int.CreateTruncating(s[w - 1]);
o[2 * w - 2] = (3 * last + int.CreateTruncating(s[w - 2]) + 1) >> 2;
o[2 * w - 1] = last;
}
/// <summary>libjpeg h2v2_fancy_upsample: triangle filter in both directions (9/3/3/1 weights).</summary>
private static void H2V2<T>(ReadOnlySpan<T> near, ReadOnlySpan<T> far, int w, Span<int> o) where T : unmanaged, IBinaryInteger<T>
{
var thisSum = 3 * int.CreateTruncating(near[0]) + int.CreateTruncating(far[0]);
var nextSum = 3 * int.CreateTruncating(near[1]) + int.CreateTruncating(far[1]);
o[0] = (thisSum * 4 + 8) >> 4;
o[1] = (thisSum * 3 + nextSum + 7) >> 4;
var lastSum = thisSum;
thisSum = nextSum;
for (var i = 1; i < w - 1; i++)
{
nextSum = 3 * int.CreateTruncating(near[i + 1]) + int.CreateTruncating(far[i + 1]);
o[2 * i] = (thisSum * 3 + lastSum + 8) >> 4;
o[2 * i + 1] = (thisSum * 3 + nextSum + 7) >> 4;
lastSum = thisSum;
thisSum = nextSum;
}
o[2 * w - 2] = (thisSum * 3 + lastSum + 8) >> 4;
o[2 * w - 1] = (thisSum * 4 + 7) >> 4;
}
private void ConvertColor(int[][] rows, YccTables? ycc)
{
var w = Width;
var max = _max;
switch (_colorSpace)
{
case JpegColorSpace.YCbCr:
YccToRgb(rows, ycc!, w, max);
break;
case JpegColorSpace.Cmyk or JpegColorSpace.Ycck:
{
if (_colorSpace == JpegColorSpace.Ycck)
{
YccToRgb(rows, ycc!, w, max);
for (var c = 0; c < 3; c++)
{
var r = rows[c];
for (var x = 0; x < w; x++) r[x] = max - r[x];
}
}
var k = rows[3];
var half = max / 2;
for (var c = 0; c < 3; c++)
{
var r = rows[c];
for (var x = 0; x < w; x++)
{
r[x] = _invertedCmyk ? (r[x] * k[x] + half) / max : ((max - r[x]) * (max - k[x]) + half) / max;
}
}
break;
}
}
}
private static void YccToRgb(int[][] rows, YccTables t, int w, int max)
{
int[] y = rows[0], cb = rows[1], cr = rows[2];
for (var x = 0; x < w; x++)
{
int yy = y[x], b = cb[x], r = cr[x];
y[x] = Math.Clamp(yy + t.CrR[r], 0, max);
cb[x] = Math.Clamp(yy + ((t.CbG[b] + t.CrG[r]) >> 16), 0, max);
cr[x] = Math.Clamp(yy + t.CbB[b], 0, max);
}
}
/// <summary>libjpeg's fixed-point (16 fractional bits) YCbCr → RGB tables for a sample precision.</summary>
private sealed class YccTables
{
private static readonly YccTables?[] Cache = new YccTables?[17];
public readonly int[] CrR, CbB, CrG, CbG;
private YccTables(int precision)
{
var size = 1 << precision;
var center = size / 2;
CrR = new int[size];
CbB = new int[size];
CrG = new int[size];
CbG = new int[size];
const int half = 1 << 15;
for (var i = 0; i < size; i++)
{
var x = i - center;
CrR[i] = (Fix(1.40200) * x + half) >> 16;
CbB[i] = (Fix(1.77200) * x + half) >> 16;
CrG[i] = -Fix(0.71414) * x;
CbG[i] = -Fix(0.34414) * x + half;
}
}
public static YccTables For(int precision) => Cache[precision] ??= new YccTables(precision);
private static int Fix(double v) => (int)(v * 65536 + 0.5);
}
}
@@ -0,0 +1,260 @@
namespace Titano.Core.Codecs.Jpeg;
/// <summary>
/// Entropy decoding of DCT scans into the components' coefficient arrays: sequential (baseline/extended) and the
/// four progressive scan kinds (DC first/refine, AC first/refine). Corrupt intervals are skipped by resynchronising
/// on the next RSTn marker; without restart markers the rest of the scan is abandoned with a warning.
/// </summary>
internal static class JpegScanDecoder
{
private enum Kind
{
Sequential,
DcFirst,
DcRefine,
AcFirst,
AcRefine,
}
public static int Decode(JpegParser parser, ReadOnlySpan<byte> data, int pos, JpegScan scan)
{
var frame = parser.Frame!;
var comps = scan.Components;
var kind = frame.Process != JpegProcess.Progressive ? Kind.Sequential
: scan.Ss == 0 ? (scan.Ah == 0 ? Kind.DcFirst : Kind.DcRefine)
: (scan.Ah == 0 ? Kind.AcFirst : Kind.AcRefine);
var single = comps.Length == 1;
var mcusX = single ? comps[0].WidthInBlocks : frame.McusX;
var mcusY = single ? comps[0].HeightInBlocks : frame.McusY;
var total = (long)mcusX * mcusY;
var interval = parser.RestartInterval;
var reader = new JpegBitReader(data, pos);
var state = new ScanState(scan);
var expectedRst = 0;
foreach (var c in comps) c.DcPred = 0;
long mcu = 0;
while (mcu < total)
{
var end = interval > 0 ? Math.Min(total, mcu + interval) : total;
try
{
for (; mcu < end; mcu++)
{
if (single)
{
var c = comps[0];
var bx = (int)(mcu % mcusX);
var by = (int)(mcu / mcusX);
DecodeBlock(ref reader, kind, c, (by * c.BlocksPerLine + bx) * 64, 0, ref state);
}
else
{
var mx = (int)(mcu % mcusX);
var my = (int)(mcu / mcusX);
for (var i = 0; i < comps.Length; i++)
{
var c = comps[i];
for (var v = 0; v < c.V; v++)
{
var row = (my * c.V + v) * c.BlocksPerLine + mx * c.H;
for (var h = 0; h < c.H; h++) DecodeBlock(ref reader, kind, c, (row + h) * 64, i, ref state);
}
}
}
if (reader.Overrun) throw new JpegEntropyException("JPEG: premature end of entropy-coded data");
}
}
catch (JpegEntropyException ex)
{
parser.Warn(ex.Message);
if (interval == 0) break;
mcu = end;
}
if (mcu >= total || interval == 0) break;
var marker = reader.FindMarker();
if (marker is < JpegTables.Rst0 or > JpegTables.Rst0 + 7)
{
parser.Warn("JPEG: restart marker missing; scan truncated");
break;
}
var found = marker - JpegTables.Rst0;
if (found != expectedRst)
{
// Intervals between the expected and the found marker were lost: leave their blocks untouched.
var lost = (found - expectedRst) & 7;
parser.Warn($"JPEG: {lost} restart interval(s) lost");
mcu += (long)lost * interval;
}
reader.AcceptMarker();
expectedRst = (found + 1) & 7;
state.EobRun = 0;
foreach (var c in comps) c.DcPred = 0;
}
return reader.Position;
}
private struct ScanState(JpegScan scan)
{
public readonly JpegScan Scan = scan;
public int EobRun;
}
private static void DecodeBlock(ref JpegBitReader r, Kind kind, JpegComponent c, int offset, int index, ref ScanState state)
{
var block = c.Coefficients.AsSpan(offset, 64);
var scan = state.Scan;
switch (kind)
{
case Kind.Sequential:
DecodeSequential(ref r, block, scan.DcTables[index]!, scan.AcTables[index]!, ref c.DcPred);
break;
case Kind.DcFirst:
{
var t = r.Decode(scan.DcTables[index]!);
if (t > 16) throw new JpegEntropyException("JPEG: bad DC magnitude");
c.DcPred += t == 0 ? 0 : r.Receive(t);
block[0] = (short)(c.DcPred * (1 << scan.Al));
break;
}
case Kind.DcRefine:
if (r.ReadBit() != 0) block[0] |= (short)(1 << scan.Al);
break;
case Kind.AcFirst:
DecodeAcFirst(ref r, block, scan.AcTables[index]!, scan.Ss, scan.Se, scan.Al, ref state.EobRun);
break;
default:
DecodeAcRefine(ref r, block, scan.AcTables[index]!, scan.Ss, scan.Se, scan.Al, ref state.EobRun);
break;
}
}
private static void DecodeSequential(ref JpegBitReader r, Span<short> block, JpegHuffmanTable dc, JpegHuffmanTable ac, ref int pred)
{
var t = r.Decode(dc);
if (t > 16) throw new JpegEntropyException("JPEG: bad DC magnitude");
pred += t == 0 ? 0 : r.Receive(t);
block[0] = (short)pred;
var order = JpegTables.NaturalOrder;
var fastAc = ac.FastAc;
var k = 1;
while (k < 64)
{
r.Ensure(16);
var fast = fastAc[r.Peek(JpegHuffmanTable.FastBits)];
if (fast != 0)
{
k += (fast >> 8) & 15;
r.Consume(fast & 0xFF);
if (k > 63) throw new JpegEntropyException("JPEG: coefficient index out of range");
block[order[k++]] = (short)(fast >> 16);
continue;
}
var rs = r.Decode(ac);
int run = rs >> 4, s = rs & 15;
if (s == 0)
{
if (run != 15) break;
k += 16;
continue;
}
k += run;
if (k > 63) throw new JpegEntropyException("JPEG: coefficient index out of range");
block[order[k++]] = (short)r.Receive(s);
}
}
private static void DecodeAcFirst(ref JpegBitReader r, Span<short> block, JpegHuffmanTable ac, int ss, int se, int al, ref int eobRun)
{
if (eobRun > 0)
{
eobRun--;
return;
}
var order = JpegTables.NaturalOrder;
for (var k = ss; k <= se;)
{
var rs = r.Decode(ac);
int run = rs >> 4, s = rs & 15;
if (s == 0)
{
if (run < 15)
{
eobRun = (1 << run) - 1;
if (run > 0) eobRun += r.ReadBits(run);
return;
}
k += 16;
continue;
}
k += run;
if (k > 63) throw new JpegEntropyException("JPEG: coefficient index out of range");
block[order[k++]] = (short)(r.Receive(s) * (1 << al));
}
}
/// <summary>AC successive-approximation refinement (T.81 G.1.2.3), following libjpeg's decode_mcu_AC_refine.</summary>
private static void DecodeAcRefine(ref JpegBitReader r, Span<short> block, JpegHuffmanTable ac, int ss, int se, int al, ref int eobRun)
{
var order = JpegTables.NaturalOrder;
var p1 = (short)(1 << al);
var m1 = (short)(-1 << al);
var k = ss;
if (eobRun == 0)
{
for (; k <= se; k++)
{
var rs = r.Decode(ac);
int run = rs >> 4, s = rs & 15;
short value = 0;
if (s != 0)
{
if (s != 1) throw new JpegEntropyException("JPEG: bad refinement magnitude");
value = r.ReadBit() != 0 ? p1 : m1;
}
else if (run != 15)
{
eobRun = 1 << run;
if (run > 0) eobRun += r.ReadBits(run);
break;
}
// Skip `run` still-zero coefficients, refining the non-zero ones passed on the way.
for (; k <= se; k++)
{
ref var coef = ref block[order[k]];
if (coef != 0)
{
RefineBit(ref r, ref coef, p1, m1);
}
else
{
if (run == 0) break;
run--;
}
}
if (value != 0)
{
if (k > se) throw new JpegEntropyException("JPEG: refinement beyond spectral band");
block[order[k]] = value;
}
}
}
if (eobRun > 0)
{
for (; k <= se; k++)
{
ref var coef = ref block[order[k]];
if (coef != 0) RefineBit(ref r, ref coef, p1, m1);
}
eobRun--;
}
}
private static void RefineBit(ref JpegBitReader r, ref short coef, short p1, short m1)
{
if (r.ReadBit() == 0 || (coef & p1) != 0) return;
coef += coef >= 0 ? p1 : m1;
}
}
+96
View File
@@ -0,0 +1,96 @@
namespace Titano.Core.Codecs.Jpeg;
/// <summary>Constants shared by the JPEG encoder and decoders (ITU T.81 Annex K).</summary>
internal static class JpegTables
{
public const byte Soi = 0xD8, Eoi = 0xD9, Sos = 0xDA, Dqt = 0xDB, Dnl = 0xDC, Dri = 0xDD, Dht = 0xC4, Dac = 0xCC;
public const byte Sof0 = 0xC0, Sof1 = 0xC1, Sof2 = 0xC2, Sof3 = 0xC3, Rst0 = 0xD0, App0 = 0xE0, App1 = 0xE1, App14 = 0xEE, Com = 0xFE;
/// <summary>Natural (row-major) index of the coefficient at each zig-zag position.</summary>
public static ReadOnlySpan<byte> NaturalOrder =>
[
0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
];
/// <summary>Annex K.1 luminance quantisation table, natural order.</summary>
public static ReadOnlySpan<byte> LumaQuant =>
[
16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 60, 55,
14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62,
18, 22, 37, 56, 68, 109, 103, 77,
24, 35, 55, 64, 81, 104, 113, 92,
49, 64, 78, 87, 103, 121, 120, 101,
72, 92, 95, 98, 112, 100, 103, 99,
];
/// <summary>Annex K.1 chrominance quantisation table, natural order.</summary>
public static ReadOnlySpan<byte> ChromaQuant =>
[
17, 18, 24, 47, 99, 99, 99, 99,
18, 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
];
public static ReadOnlySpan<byte> DcLumaBits => [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
public static ReadOnlySpan<byte> DcLumaValues => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
public static ReadOnlySpan<byte> DcChromaBits => [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
public static ReadOnlySpan<byte> DcChromaValues => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
public static ReadOnlySpan<byte> AcLumaBits => [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d];
public static ReadOnlySpan<byte> AcLumaValues =>
[
0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa,
];
public static ReadOnlySpan<byte> AcChromaBits => [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77];
public static ReadOnlySpan<byte> AcChromaValues =>
[
0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa,
];
/// <summary>Orthonormal 8-point DCT basis: <c>Basis[u * 8 + x] = c(u)/2 · cos((2x+1)uπ/16)</c>.</summary>
public static readonly float[] Basis = BuildBasis(8);
/// <summary>DCT basis of an n-point reduced IDCT evaluated with 8-point normalisation (DCT-domain scaling).</summary>
public static float[] BuildBasis(int n)
{
var b = new float[n * n];
for (var u = 0; u < n; u++)
{
var cu = u == 0 ? Math.Sqrt(0.5) : 1.0;
for (var x = 0; x < n; x++) b[u * n + x] = (float)(cu / 2 * Math.Cos((2 * x + 1) * u * Math.PI / (2 * n)));
}
return b;
}
}
+153
View File
@@ -0,0 +1,153 @@
namespace Titano.Core.Codecs.Jpeg;
/// <summary>JPEG coding process declared by the SOF marker.</summary>
public enum JpegProcess
{
/// <summary>SOF0: baseline sequential DCT, 8-bit, at most two Huffman tables per class.</summary>
Baseline,
/// <summary>SOF1: extended sequential DCT (8 or 12-bit).</summary>
ExtendedSequential,
/// <summary>SOF2: progressive DCT (spectral selection and successive approximation).</summary>
Progressive,
/// <summary>SOF3: lossless predictive coding (2–16 bit).</summary>
Lossless,
}
/// <summary>Colour space of the encoded components.</summary>
public enum JpegColorSpace
{
Gray,
YCbCr,
Rgb,
Cmyk,
Ycck,
/// <summary>No defined colour interpretation (e.g. two-component lossless raw tiles).</summary>
Other,
}
/// <summary>Overrides the colour interpretation of a 3- or 4-component stream (TIFF knows it out of band).</summary>
public enum JpegColorTransform
{
/// <summary>JFIF/Adobe markers and component ids decide (libjpeg rules).</summary>
Auto,
/// <summary>Components are stored as-is (RGB or CMYK).</summary>
None,
/// <summary>Components are YCbCr (or YCCK for four components).</summary>
YCbCr,
}
/// <summary>Frame facts from the headers, available without decoding pixels.</summary>
/// <param name="Width">Full image width in pixels.</param>
/// <param name="Height">Full image height in pixels.</param>
/// <param name="Components">Number of encoded components (1–4).</param>
/// <param name="Precision">Sample precision in bits (8 or 12 for DCT, 2–16 for lossless).</param>
/// <param name="Process">Coding process.</param>
/// <param name="ColorSpace">Colour space the decoder will assume.</param>
/// <param name="Sampling">Horizontal and vertical sampling factors per component.</param>
/// <param name="RestartInterval">Restart interval in MCUs declared before the first scan (0 = none).</param>
public sealed record JpegInfo(
int Width,
int Height,
int Components,
int Precision,
JpegProcess Process,
JpegColorSpace ColorSpace,
IReadOnlyList<(int H, int V)> Sampling,
int RestartInterval)
{
/// <summary>Chroma subsampling in J:a:b notation for three-component images ("4:2:0"), otherwise a factor list.</summary>
public string SamplingNotation
{
get
{
if (Sampling.Count == 3 && Sampling[1] == Sampling[2] && Sampling[1] == (1, 1))
{
return Sampling[0] switch
{
(1, 1) => "4:4:4",
(2, 1) => "4:2:2",
(2, 2) => "4:2:0",
(1, 2) => "4:4:0",
(4, 1) => "4:1:1",
(4, 2) => "4:1:0",
_ => Factors(),
};
}
return Factors();
}
}
private string Factors() => string.Join(",", Sampling.Select(s => $"{s.H}x{s.V}"));
}
/// <summary>Options for <see cref="JpegDecoder"/>.</summary>
public sealed record JpegDecodeOptions
{
/// <summary>Default options: full size, fancy upsampling, automatic colour transform.</summary>
public static JpegDecodeOptions Default { get; } = new();
/// <summary>When &gt; 0, decode with the smallest DCT-domain reduction (1/2, 1/4, 1/8) whose long edge is still
/// ≥ this value. 0 decodes at full size. Ignored for lossless streams.</summary>
public int MaxLongEdge { get; init; }
/// <summary>Triangle-filter chroma upsampling (libjpeg "fancy"); false replicates chroma samples.</summary>
public bool FancyUpsampling { get; init; } = true;
/// <summary>Colour interpretation override (TIFF photometric).</summary>
public JpegColorTransform ColorTransform { get; init; } = JpegColorTransform.Auto;
/// <summary>Abbreviated table-specification stream (TIFF JPEGTables) parsed before the image stream.</summary>
public byte[]? Tables { get; init; }
/// <summary>Upper bound on width × height; larger frames are rejected before any allocation.</summary>
public long MaxPixels { get; init; } = 1L << 28;
/// <summary>Worker limit for the IDCT and colour stages (-1 = all cores, 1 = single-threaded).</summary>
public int MaxDegreeOfParallelism { get; init; } = -1;
}
/// <summary>Decoded JPEG pixels, interleaved, top-down, Exif orientation not applied.</summary>
public sealed class JpegImage
{
internal JpegImage(JpegInfo info, int width, int height, int components, int bitDepth, byte[]? pixels8, ushort[]? pixels16, IReadOnlyList<string> warnings)
{
Info = info;
Width = width;
Height = height;
Components = components;
BitDepth = bitDepth;
Pixels8 = pixels8;
Pixels16 = pixels16;
Warnings = warnings;
}
/// <summary>Header facts of the source stream (full-size dimensions).</summary>
public JpegInfo Info { get; }
/// <summary>Output width (smaller than <see cref="JpegInfo.Width"/> when DCT scaling was used).</summary>
public int Width { get; }
public int Height { get; }
/// <summary>Output channels: 1 (gray) or 3 (RGB; CMYK/YCCK are converted).</summary>
public int Components { get; }
/// <summary>Significant bits per sample: 8 → <see cref="Pixels8"/>; more → <see cref="Pixels16"/> with values 0..2^BitDepth−1.</summary>
public int BitDepth { get; }
public byte[]? Pixels8 { get; }
public ushort[]? Pixels16 { get; }
/// <summary>Recoverable problems (corrupt entropy data, missing restart markers, truncation).</summary>
public IReadOnlyList<string> Warnings { get; }
}
/// <summary>Raw samples of a lossless (SOF3) stream as encoded: interleaved, <see cref="Width"/> as in the frame header.</summary>
public readonly record struct JpegLosslessImage(ushort[] Samples, int Width, int Height, int Components, int Precision);
+390
View File
@@ -0,0 +1,390 @@
using System.Numerics;
using System.Runtime.CompilerServices;
namespace Titano.Core.Imaging;
/// <summary>How integer samples relate to light: sRGB-encoded (display referred) or proportional to linear light.</summary>
public enum TransferFunction
{
Srgb,
Linear,
}
/// <summary>
/// Conversions between interleaved integer pixels and planar linear-light <see cref="ImageBuffer"/>s, gray ↔ RGB,
/// Exif orientation, and clamping. Interleaved layouts: 1 = gray, 2 = gray+alpha, 3 = RGB, 4 = RGBA. Alpha is
/// never transfer-encoded. Row loops are parallel for large images.
/// </summary>
public static class PixelConvert
{
private const int ParallelThreshold = 1 << 16;
/// <summary>8×8 Bayer thresholds in code units, centred on zero (ordered dither).</summary>
private static readonly float[] Bayer = BuildBayer();
/// <summary>Interleaved 8-bit samples → linear buffer.</summary>
/// <param name="outputChannels">0 = natural (1/2 → 1, 3 → 3, 4 → 3); 3 expands gray; 4 keeps alpha.</param>
public static ImageBuffer FromInterleaved8(ReadOnlySpan<byte> pixels, int width, int height, int channels, TransferFunction transfer = TransferFunction.Srgb, int outputChannels = 0)
{
var outCh = OutputChannels(channels, outputChannels);
CheckLength(pixels.Length, width, height, channels);
var lut = new float[256];
for (var i = 0; i < 256; i++) lut[i] = transfer == TransferFunction.Srgb ? ColorSpace.Linear8((byte)i) : i / 255f;
var image = new ImageBuffer(width, height, outCh, clear: false);
unsafe
{
fixed (byte* p = pixels)
{
var ptr = (nint)p;
ForRows(height, width, y =>
{
var row = new ReadOnlySpan<byte>((byte*)ptr + (long)y * width * channels, width * channels);
Scatter(row, image, y, channels, lut, 1f / 255f);
});
}
}
return image;
}
/// <summary>Interleaved 16-bit container samples (values 0..<paramref name="maxValue"/>) → linear buffer.</summary>
public static ImageBuffer FromInterleaved16(ReadOnlySpan<ushort> pixels, int width, int height, int channels, TransferFunction transfer = TransferFunction.Srgb, int maxValue = 65535, int outputChannels = 0)
{
if (maxValue is < 1 or > 65535) throw new ArgumentOutOfRangeException(nameof(maxValue));
var outCh = OutputChannels(channels, outputChannels);
CheckLength(pixels.Length, width, height, channels);
var lut = new float[maxValue + 1];
for (var i = 0; i <= maxValue; i++)
{
lut[i] = transfer == TransferFunction.Linear ? i / (float)maxValue
: maxValue == 65535 ? ColorSpace.Linear16((ushort)i) : (float)ColorSpace.SrgbToLinear(i / (double)maxValue);
}
var alphaScale = 1f / maxValue;
var image = new ImageBuffer(width, height, outCh, clear: false);
unsafe
{
fixed (ushort* p = pixels)
{
var ptr = (nint)p;
ForRows(height, width, y =>
{
var row = new ReadOnlySpan<ushort>((ushort*)ptr + (long)y * width * channels, width * channels);
Scatter(row, image, y, channels, lut, alphaScale);
});
}
}
return image;
}
/// <summary>Linear buffer → interleaved 8-bit samples with <paramref name="channels"/> per pixel
/// (1 from RGB takes Rec.709 luminance; missing alpha is opaque).</summary>
/// <param name="dither">Add 8×8 ordered dither before rounding (breaks banding in smooth gradients).</param>
public static void ToInterleaved8(ImageBuffer image, Span<byte> destination, int channels, TransferFunction transfer = TransferFunction.Srgb, bool dither = false)
{
CheckLength(destination.Length, image.Width, image.Height, channels);
unsafe
{
fixed (byte* p = destination)
{
var ptr = (nint)p;
ForRows(image.Height, image.Width, y =>
{
var row = new Span<byte>((byte*)ptr + (long)y * image.Width * channels, image.Width * channels);
EncodeRow8(image, y, row, channels, transfer, dither);
});
}
}
}
/// <summary>Allocating overload of <see cref="ToInterleaved8(ImageBuffer, Span{byte}, int, TransferFunction, bool)"/>.</summary>
public static byte[] ToInterleaved8(ImageBuffer image, int channels, TransferFunction transfer = TransferFunction.Srgb, bool dither = false)
{
var result = new byte[checked(image.Width * image.Height * channels)];
ToInterleaved8(image, result, channels, transfer, dither);
return result;
}
/// <summary>Linear buffer → interleaved 16-bit samples (0..65535).</summary>
public static void ToInterleaved16(ImageBuffer image, Span<ushort> destination, int channels, TransferFunction transfer = TransferFunction.Srgb)
{
CheckLength(destination.Length, image.Width, image.Height, channels);
unsafe
{
fixed (ushort* p = destination)
{
var ptr = (nint)p;
ForRows(image.Height, image.Width, y =>
{
var row = new Span<ushort>((ushort*)ptr + (long)y * image.Width * channels, image.Width * channels);
EncodeRow16(image, y, row, channels, transfer);
});
}
}
}
/// <summary>Allocating overload of <see cref="ToInterleaved16(ImageBuffer, Span{ushort}, int, TransferFunction)"/>.</summary>
public static ushort[] ToInterleaved16(ImageBuffer image, int channels, TransferFunction transfer = TransferFunction.Srgb)
{
var result = new ushort[checked(image.Width * image.Height * channels)];
ToInterleaved16(image, result, channels, transfer);
return result;
}
/// <summary>Encodes row <paramref name="y"/> into interleaved 8-bit samples (codec edge helper).</summary>
internal static void EncodeRow8(ImageBuffer image, int y, Span<byte> row, int channels, TransferFunction transfer, bool dither)
{
var w = image.Width;
Span<float> offsets = stackalloc float[8];
if (dither)
{
for (var i = 0; i < 8; i++) offsets[i] = 0.5f + Bayer[(y & 7) * 8 + i];
}
else
{
offsets.Fill(0.5f);
}
var srgb = transfer == TransferFunction.Srgb;
var colour = channels is 1 or 2 ? 1 : 3;
for (var c = 0; c < channels; c++)
{
if (c == colour)
{
var a = image.Channels == 4 ? image.Row(3, y) : default;
for (var x = 0; x < w; x++) row[x * channels + c] = a.IsEmpty ? (byte)255 : (byte)(Math.Clamp(a[x], 0f, 1f) * 255f + 0.5f);
continue;
}
var src = SourceRow(image, y, c, colour, out var luminance);
for (var x = 0; x < w; x++)
{
var v = luminance is null ? src[x] : luminance[x];
var e = srgb ? ColorSpace.EncodeFast(v) : Math.Clamp(v, 0f, 1f);
row[x * channels + c] = (byte)Math.Clamp(e * 255f + offsets[x & 7], 0f, 255f);
}
}
}
/// <summary>Encodes row <paramref name="y"/> into interleaved 16-bit samples (codec edge helper).</summary>
internal static void EncodeRow16(ImageBuffer image, int y, Span<ushort> row, int channels, TransferFunction transfer)
{
var w = image.Width;
var srgb = transfer == TransferFunction.Srgb;
var colour = channels is 1 or 2 ? 1 : 3;
for (var c = 0; c < channels; c++)
{
if (c == colour)
{
var a = image.Channels == 4 ? image.Row(3, y) : default;
for (var x = 0; x < w; x++) row[x * channels + c] = a.IsEmpty ? (ushort)65535 : (ushort)(Math.Clamp(a[x], 0f, 1f) * 65535f + 0.5f);
continue;
}
var src = SourceRow(image, y, c, colour, out var luminance);
for (var x = 0; x < w; x++)
{
var v = luminance is null ? src[x] : luminance[x];
row[x * channels + c] = srgb ? ColorSpace.Encode16(v) : (ushort)(Math.Clamp(v, 0f, 1f) * 65535f + 0.5f);
}
}
}
/// <summary>Single-channel buffer replicated into three channels.</summary>
public static ImageBuffer GrayToRgb(ImageBuffer gray)
{
if (gray.Channels != 1) throw new ArgumentException("Expected one channel", nameof(gray));
var rgb = new ImageBuffer(gray.Width, gray.Height, 3, clear: false);
for (var c = 0; c < 3; c++) gray.Plane(0).CopyTo(rgb.Plane(c));
return rgb;
}
/// <summary>Rec.709 luminance of an RGB(A) buffer.</summary>
public static ImageBuffer RgbToGray(ImageBuffer rgb)
{
if (rgb.Channels < 3) throw new ArgumentException("Expected RGB", nameof(rgb));
var gray = new ImageBuffer(rgb.Width, rgb.Height, 1, clear: false);
var r = rgb.Plane(0);
var g = rgb.Plane(1);
var b = rgb.Plane(2);
var d = gray.Plane(0);
var i = 0;
if (Vector.IsHardwareAccelerated)
{
var wr = new Vector<float>(ColorSpace.LumaR);
var wg = new Vector<float>(ColorSpace.LumaG);
var wb = new Vector<float>(ColorSpace.LumaB);
for (; i <= d.Length - Vector<float>.Count; i += Vector<float>.Count)
{
(new Vector<float>(r[i..]) * wr + new Vector<float>(g[i..]) * wg + new Vector<float>(b[i..]) * wb).CopyTo(d[i..]);
}
}
for (; i < d.Length; i++) d[i] = ColorSpace.Luminance(r[i], g[i], b[i]);
return gray;
}
/// <summary>Clamps every value into [<paramref name="min"/>, <paramref name="max"/>] (NaN becomes <paramref name="min"/>).</summary>
public static void Clamp(Span<float> values, float min = 0f, float max = 1f)
{
var i = 0;
if (Vector.IsHardwareAccelerated)
{
var lo = new Vector<float>(min);
var hi = new Vector<float>(max);
for (; i <= values.Length - Vector<float>.Count; i += Vector<float>.Count)
{
var v = new Vector<float>(values[i..]);
// Max(v, lo) with v as the first operand maps NaN to lo on x86 (maxps returns the second operand).
Vector.Min(Vector.ConditionalSelect(Vector.Equals(v, v), Vector.Max(v, lo), lo), hi).CopyTo(values[i..]);
}
}
for (; i < values.Length; i++)
{
var v = values[i];
values[i] = float.IsNaN(v) ? min : Math.Clamp(v, min, max);
}
}
/// <summary>Size after applying an Exif orientation (5–8 swap width and height).</summary>
public static (int Width, int Height) OrientedSize(int width, int height, int orientation) =>
orientation is >= 5 and <= 8 ? (height, width) : (width, height);
/// <summary>Applies an Exif orientation (1–8) into a new buffer; other values are treated as 1 (copy).</summary>
public static ImageBuffer ApplyOrientation(ImageBuffer source, int orientation)
{
int w = source.Width, h = source.Height;
var (ow, oh) = OrientedSize(w, h, orientation);
var result = new ImageBuffer(ow, oh, source.Channels, clear: false);
if (orientation is < 2 or > 8)
{
source.CopyTo(result);
return result;
}
for (var c = 0; c < source.Channels; c++)
{
var src = source.Storage.AsMemory(c * source.PlaneLength, source.PlaneLength);
var dst = result.Storage.AsMemory(c * result.PlaneLength, result.PlaneLength);
if (orientation <= 4)
{
ForRows(oh, ow, y =>
{
var sy = orientation is 3 or 4 ? h - 1 - y : y;
var s = src.Span.Slice(sy * w, w);
var d = dst.Span.Slice(y * ow, ow);
s.CopyTo(d);
if (orientation is 2 or 3) d.Reverse();
});
continue;
}
// Transposing orientations: copy in 32×32 tiles so both sides stay cache-friendly.
const int tile = 32;
var tilesY = (oh + tile - 1) / tile;
ForRows(tilesY, ow * tile, ty =>
{
var s = src.Span;
var d = dst.Span;
var y1 = Math.Min(oh, (ty + 1) * tile);
for (var x0 = 0; x0 < ow; x0 += tile)
{
var x1 = Math.Min(ow, x0 + tile);
for (var y = ty * tile; y < y1; y++)
{
for (var x = x0; x < x1; x++)
{
var (sx, sy) = orientation switch
{
5 => (y, x),
6 => (y, h - 1 - x),
7 => (w - 1 - y, h - 1 - x),
_ => (w - 1 - y, x),
};
d[y * ow + x] = s[sy * w + sx];
}
}
}
});
}
return result;
}
private static ReadOnlySpan<float> SourceRow(ImageBuffer image, int y, int c, int colourChannels, out float[]? luminance)
{
luminance = null;
if (image.Channels == 1) return image.Row(0, y);
if (colourChannels == 3) return image.Row(c, y);
var r = image.Row(0, y);
var g = image.Row(1, y);
var b = image.Row(2, y);
luminance = new float[image.Width];
for (var x = 0; x < luminance.Length; x++) luminance[x] = ColorSpace.Luminance(r[x], g[x], b[x]);
return default;
}
/// <summary>De-interleaves one row: colour through <paramref name="lut"/> (indices clamped to its range), alpha scaled.</summary>
private static void Scatter<T>(ReadOnlySpan<T> row, ImageBuffer image, int y, int channels, float[] lut, float alphaScale)
where T : unmanaged, IBinaryInteger<T>
{
var w = image.Width;
var top = lut.Length - 1;
var colour = channels is 1 or 2 ? 1 : 3;
for (var c = 0; c < image.Channels; c++)
{
var dst = image.Row(c, y);
if (c == 3)
{
if (channels is 2 or 4)
{
var a = channels - 1;
for (var x = 0; x < w; x++) dst[x] = Math.Min(int.CreateTruncating(row[x * channels + a]), top) * alphaScale;
}
else
{
dst.Fill(1f);
}
continue;
}
var s = colour == 1 ? 0 : c;
for (var x = 0; x < w; x++) dst[x] = lut[Math.Min(int.CreateTruncating(row[x * channels + s]), top)];
}
}
private static int OutputChannels(int channels, int requested)
{
if (channels is < 1 or > 4) throw new ArgumentOutOfRangeException(nameof(channels));
if (requested is not (0 or 1 or 3 or 4)) throw new ArgumentOutOfRangeException(nameof(requested));
if (requested == 1 && channels > 2) throw new ArgumentException("Use RgbToGray to reduce colour to one channel", nameof(requested));
return requested != 0 ? requested : channels <= 2 ? 1 : 3;
}
private static void CheckLength(int length, int width, int height, int channels)
{
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(width);
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(height);
if (channels is < 1 or > 4) throw new ArgumentOutOfRangeException(nameof(channels));
if (length < (long)width * height * channels) throw new ArgumentException("Pixel buffer too small");
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void ForRows(int rows, int rowWork, Action<int> body)
{
if ((long)rows * rowWork < ParallelThreshold)
{
for (var y = 0; y < rows; y++) body(y);
}
else
{
Parallel.For(0, rows, body);
}
}
private static float[] BuildBayer()
{
// Recursive Bayer matrix: interleave bits of (x ^ y) and y, least significant coordinate bits first.
var m = new float[64];
for (var y = 0; y < 8; y++)
{
for (var x = 0; x < 8; x++)
{
var v = 0;
for (var bit = 0; bit < 3; bit++) v = v << 2 | (((x ^ y) >> bit) & 1) << 1 | ((y >> bit) & 1);
m[y * 8 + x] = (v + 0.5f) / 64f - 0.5f;
}
}
return m;
}
}
@@ -0,0 +1,167 @@
using System.Text;
using Titano.Testing;
namespace Titano.Core.Tests.Codecs;
/// <summary>Shared fixtures, synthetic images and image metrics for codec tests.</summary>
internal static class CodecTestData
{
public static byte[] Fixture(string relativePath) =>
File.ReadAllBytes(Path.Combine(TestContext.FixturesDirectory, "codecs", relativePath));
/// <summary>Netpbm P5/P6/P7 (PAM) reader for reference images; samples are big-endian when maxval &gt; 255.</summary>
public static Pnm ReadPnm(byte[] data)
{
var pos = 0;
string Token()
{
while (pos < data.Length && (char.IsWhiteSpace((char)data[pos]) || data[pos] == '#'))
{
if (data[pos] == '#') while (pos < data.Length && data[pos] != '\n') pos++;
else pos++;
}
var start = pos;
while (pos < data.Length && !char.IsWhiteSpace((char)data[pos])) pos++;
return Encoding.ASCII.GetString(data, start, pos - start);
}
var magic = Token();
int width, height, channels, maxVal;
if (magic == "P7")
{
width = height = channels = maxVal = 0;
for (var t = Token(); t != "ENDHDR"; t = Token())
{
switch (t)
{
case "WIDTH": width = int.Parse(Token()); break;
case "HEIGHT": height = int.Parse(Token()); break;
case "DEPTH": channels = int.Parse(Token()); break;
case "MAXVAL": maxVal = int.Parse(Token()); break;
case "TUPLTYPE": Token(); break;
}
}
}
else
{
channels = magic switch { "P5" => 1, "P6" => 3, _ => throw new InvalidDataException(magic) };
width = int.Parse(Token());
height = int.Parse(Token());
maxVal = int.Parse(Token());
}
pos++;
var samples = new int[width * height * channels];
for (var i = 0; i < samples.Length; i++)
{
samples[i] = maxVal > 255 ? data[pos + 2 * i] << 8 | data[pos + 2 * i + 1] : data[pos + i];
}
return new Pnm(width, height, channels, maxVal, samples);
}
public sealed record Pnm(int Width, int Height, int Channels, int MaxVal, int[] Samples)
{
public byte[] Bytes => Samples.Select(s => (byte)s).ToArray();
public ushort[] Words => Samples.Select(s => (ushort)s).ToArray();
}
/// <summary>Deterministic RGB test card: smooth gradients, saturated colour bars, seeded noise and
/// text-like one-pixel strokes (the four content classes codecs struggle with).</summary>
public static byte[] TestCard(int width, int height, int seed = 1)
{
var rng = new Random(seed);
var rgb = new byte[width * height * 3];
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var band = y * 4 / height;
int r, g, b;
switch (band)
{
case 0:
r = x * 255 / Math.Max(1, width - 1);
g = y * 4 * 255 / Math.Max(1, height - 1) / 4 * 4 % 256;
b = 255 - r;
break;
case 1:
var bar = x * 8 / width;
r = (bar & 4) != 0 ? 230 : 25;
g = (bar & 2) != 0 ? 230 : 25;
b = (bar & 1) != 0 ? 230 : 25;
break;
case 2:
r = rng.Next(256);
g = rng.Next(256);
b = rng.Next(256);
break;
default:
var stroke = x % 7 == 0 || y % 9 == 0 || (x + y) % 13 == 0;
r = g = b = stroke ? 20 : 235;
break;
}
var i = (y * width + x) * 3;
rgb[i] = (byte)r;
rgb[i + 1] = (byte)g;
rgb[i + 2] = (byte)b;
}
}
return rgb;
}
/// <summary>Smooth photographic-like content (low-frequency gradients); compresses like real photos.</summary>
public static byte[] SmoothImage(int width, int height)
{
var rgb = new byte[width * height * 3];
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
double u = x / (double)width, v = y / (double)height;
var i = (y * width + x) * 3;
rgb[i] = (byte)(127.5 + 120 * Math.Sin(6.1 * u + 2.3 * v));
rgb[i + 1] = (byte)(127.5 + 120 * Math.Cos(4.7 * u * v + 3.1 * v));
rgb[i + 2] = (byte)(127.5 + 120 * Math.Sin(9.3 * v - 1.7 * u + 0.5));
}
}
return rgb;
}
public static double Psnr(ReadOnlySpan<byte> a, ReadOnlySpan<byte> b) => Psnr(a, b, 255);
public static double Psnr<T>(ReadOnlySpan<T> a, ReadOnlySpan<T> b, double peak) where T : struct, IConvertible
{
Assert.Equal(a.Length, b.Length, "sample count");
double sum = 0;
for (var i = 0; i < a.Length; i++)
{
var d = a[i].ToDouble(null) - b[i].ToDouble(null);
sum += d * d;
}
var mse = sum / a.Length;
return mse == 0 ? 99 : 10 * Math.Log10(peak * peak / mse);
}
public static int MaxAbsDiff(ReadOnlySpan<byte> a, ReadOnlySpan<int> b)
{
Assert.Equal(a.Length, b.Length, "sample count");
var max = 0;
for (var i = 0; i < a.Length; i++) max = Math.Max(max, Math.Abs(a[i] - b[i]));
return max;
}
/// <summary>Seeded corruption: the input truncated at <paramref name="cases"/> points plus single-byte flips.</summary>
public static IEnumerable<byte[]> Corruptions(byte[] valid, int cases, int seed)
{
var rng = new Random(seed);
for (var i = 0; i < cases; i++)
{
yield return valid.AsSpan(0, rng.Next(valid.Length)).ToArray();
var flipped = (byte[])valid.Clone();
var flips = 1 + rng.Next(4);
for (var f = 0; f < flips; f++) flipped[rng.Next(flipped.Length)] ^= (byte)(1 << rng.Next(8));
yield return flipped;
var garbage = (byte[])valid.Clone();
garbage[rng.Next(garbage.Length)] = (byte)rng.Next(256);
yield return garbage;
}
}
}
@@ -0,0 +1,79 @@
using Titano.Core.Codecs.Jpeg;
using Titano.Testing;
using static Titano.Core.Tests.Codecs.CodecTestData;
namespace Titano.Core.Tests.Codecs;
/// <summary>Decoder output against libjpeg-turbo's djpeg (accurate integer IDCT) on cjpeg-produced fixtures.</summary>
public sealed class JpegDecoderTests(TestContext context)
{
[Theory]
[Case("b444", "4:4:4")]
[Case("b422", "4:2:2")]
[Case("b420", "4:2:0")]
[Case("b440", "4:4:0")]
[Case("b411", "4:1:1")]
[Case("p420", "4:2:0")]
[Case("p444", "4:4:4")]
[Case("r420", "4:2:0")]
[Case("r444", "4:4:4")]
public void MatchesDjpeg(string name, string sampling)
{
var data = Fixture($"jpeg/{name}.jpg");
var reference = ReadPnm(Fixture($"jpeg/{name}.ppm"));
var image = JpegDecoder.Decode(data);
Assert.Equal(reference.Width, image.Width);
Assert.Equal(reference.Height, image.Height);
Assert.Equal(3, image.Components);
Assert.Equal(sampling, image.Info.SamplingNotation);
Assert.Empty(image.Warnings);
var diff = MaxAbsDiff(image.Pixels8, reference.Samples);
context.Log($"{name}: max |diff| = {diff}");
Assert.LessOrEqual(diff, 2);
}
[Theory]
[Case("gray")]
[Case("pgray")]
public void GrayMatchesDjpeg(string name)
{
var image = JpegDecoder.Decode(Fixture($"jpeg/{name}.jpg"));
var reference = ReadPnm(Fixture($"jpeg/{name}.pgm"));
Assert.Equal(1, image.Components);
Assert.Equal(JpegColorSpace.Gray, image.Info.ColorSpace);
Assert.LessOrEqual(MaxAbsDiff(image.Pixels8, reference.Samples), 2);
}
[Test]
public void ReplicatedUpsamplingMatchesDjpegNoSmooth()
{
var image = JpegDecoder.Decode(Fixture("jpeg/b420.jpg"), new JpegDecodeOptions { FancyUpsampling = false });
Assert.LessOrEqual(MaxAbsDiff(image.Pixels8, ReadPnm(Fixture("jpeg/b420-nosmooth.ppm")).Samples), 2);
}
[Test]
public void ReadInfoParsesHeadersOnly()
{
var info = JpegDecoder.ReadInfo(Fixture("jpeg/p420.jpg"));
Assert.Equal(61, info.Width);
Assert.Equal(45, info.Height);
Assert.Equal(JpegProcess.Progressive, info.Process);
Assert.Equal(JpegColorSpace.YCbCr, info.ColorSpace);
Assert.Equal(8, info.Precision);
var restart = JpegDecoder.ReadInfo(Fixture("jpeg/r444.jpg"));
Assert.Equal(5, restart.RestartInterval);
}
[Test]
public void AdobeYcckIsConvertedToRgb()
{
var image = JpegDecoder.Decode(Fixture("jpeg/cmyk.jpg"));
Assert.Equal(JpegColorSpace.Ycck, image.Info.ColorSpace);
Assert.Equal(4, image.Info.Components);
Assert.Equal(3, image.Components);
var source = ReadPnm(Fixture("src.ppm"));
var psnr = Psnr(image.Pixels8, source.Bytes);
context.Log($"YCCK round trip PSNR {psnr:F1} dB");
Assert.Greater(psnr, 30);
}
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.1 KiB

Binary file not shown.
Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.2 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.6 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.7 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 3.4 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 5.6 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.5 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 1.9 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 1.4 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.3 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 3.2 KiB

Binary file not shown.
+75
View File
@@ -0,0 +1,75 @@
#!/usr/bin/env bash
# Regenerates the codec reference fixtures (dev-only tools: python3, libjpeg-turbo-progs, imagemagick, libtiff-tools).
# Every output is < 50 KB. Run from this directory: ./make-fixtures.sh
set -euo pipefail
cd "$(dirname "$0")"
mkdir -p jpeg png tiff
# 61x45 source (odd size exercises MCU/tile padding): gradients, colour bars, seeded noise and hard edges.
python3 - <<'EOF'
import random
W, H = 61, 45
random.seed(7)
px8, px16 = [], []
for y in range(H):
for x in range(W):
if y < 15:
r, g, b = x / (W - 1), y / 14, 1 - x / (W - 1)
elif y < 30:
bar = (x * 8) // W
r, g, b = (bar >> 2) & 1, (bar >> 1) & 1, bar & 1
r, g, b = 0.1 + 0.8 * r, 0.1 + 0.8 * g, 0.1 + 0.8 * b
else:
n = random.random()
edge = 1.0 if ((x // 3) + (y // 3)) % 2 == 0 else 0.0
r, g, b = 0.6 * edge + 0.4 * n, 0.5 * n, 0.8 * edge
px8 += [round(v * 255) for v in (r, g, b)]
px16 += [round(v * 65535) for v in (r, g, b)]
with open("src.ppm", "wb") as f:
f.write(b"P6\n%d %d\n255\n" % (W, H)); f.write(bytes(px8))
with open("src16.ppm", "wb") as f:
f.write(b"P6\n%d %d\n65535\n" % (W, H))
f.write(b"".join(v.to_bytes(2, "big") for v in px16))
EOF
# JPEG: cjpeg encodes, djpeg (accurate integer IDCT, fancy upsampling) provides the reference pixels.
for s in "444:1x1" "422:2x1" "420:2x2" "440:1x2" "411:4x1"; do
name=${s%%:*}; f=${s##*:}
cjpeg -quality 88 -sample "$f" src.ppm > "jpeg/b$name.jpg"
djpeg -ppm "jpeg/b$name.jpg" > "jpeg/b$name.ppm"
done
djpeg -nosmooth -ppm jpeg/b420.jpg > jpeg/b420-nosmooth.ppm
cjpeg -quality 85 -sample 2x2 -progressive src.ppm > jpeg/p420.jpg && djpeg -ppm jpeg/p420.jpg > jpeg/p420.ppm
cjpeg -quality 92 -sample 1x1 -progressive src.ppm > jpeg/p444.jpg && djpeg -ppm jpeg/p444.jpg > jpeg/p444.ppm
cjpeg -quality 90 -sample 2x2 -restart 1 src.ppm > jpeg/r420.jpg && djpeg -ppm jpeg/r420.jpg > jpeg/r420.ppm
cjpeg -quality 90 -sample 1x1 -restart 5B -optimize src.ppm > jpeg/r444.jpg && djpeg -ppm jpeg/r444.jpg > jpeg/r444.ppm
cjpeg -quality 90 -grayscale src.ppm > jpeg/gray.jpg && djpeg -pnm jpeg/gray.jpg > jpeg/gray.pgm
cjpeg -quality 90 -grayscale -progressive src.ppm > jpeg/pgray.jpg && djpeg -pnm jpeg/pgray.jpg > jpeg/pgray.pgm
convert src.ppm -quality 95 -colorspace CMYK jpeg/cmyk.jpg
# PNG: ImageMagick/libpng writers; pixels compare against src.ppm / src16.ppm.
convert src.ppm -interlace PNG png24:png/adam7.png
convert src16.ppm -define png:bit-depth=16 png48:png/rgb16.png
convert src16.ppm -interlace PNG -define png:bit-depth=16 png48:png/adam7-16.png
convert src.ppm -colorspace Gray -define png:color-type=0 -define png:bit-depth=8 png/gray8.png
convert src.ppm -colorspace Gray -depth 4 -define png:color-type=0 -define png:bit-depth=4 png/gray4.png
convert src.ppm -colorspace Gray -depth 2 -define png:color-type=0 -define png:bit-depth=2 png/gray2.png
convert src.ppm -colorspace Gray -threshold 50% -define png:color-type=0 -define png:bit-depth=1 png/gray1.png
convert src.ppm -colors 16 -transparent "$(convert src.ppm -colors 16 -format '%[pixel:p{0,40}]' info:)" png8:png/palette-trns.png
convert src.ppm -colors 16 -interlace PNG png8:png/palette-adam7.png
convert src.ppm -colors 12 -define png:color-type=3 -define png:bit-depth=4 png/palette4.png
convert src.ppm \( src.ppm -colorspace Gray \) -alpha off -compose CopyOpacity -composite png32:png/rgba.png
convert src.ppm -colorspace Gray \( src.ppm -channel R -separate \) -alpha off -compose CopyOpacity -composite -define png:color-type=4 png/graya.png
for f in gray1 gray2 gray4 gray8 graya palette-trns palette-adam7 palette4 rgba; do convert "png/$f.png" -depth 8 "png/$f.pam"; done
# TIFF: ImageMagick/libtiff writers in every supported layout and compression.
convert src.ppm -compress LZW -define tiff:predictor=2 tiff/lzw-pred.tif
convert src.ppm -compress RLE tiff/packbits.tif
convert src.ppm -compress None -define tiff:rows-per-strip=7 tiff/none-strips.tif
convert src16.ppm -depth 16 -compress Zip -define tiff:predictor=2 tiff/deflate16-pred.tif
convert src.ppm -compress LZW -define tiff:tile-geometry=16x16 tiff/lzw-tiled.tif
tiffcp -p separate -c zip src.ppm.tmp.tif tiff/planar-zip.tif 2>/dev/null || { convert src.ppm -compress None tiff/_tmp.tif; tiffcp -p separate -c zip tiff/_tmp.tif tiff/planar-zip.tif; rm tiff/_tmp.tif; }
convert src.ppm -compress None tiff/_tmp.tif && tiffcp -c jpeg:90 -r 16 tiff/_tmp.tif tiff/jpeg-ycbcr.tif && tiffcp -c jpeg:r:90 -r 16 tiff/_tmp.tif tiff/jpeg-rgb.tif && rm tiff/_tmp.tif
convert src16.ppm -define quantum:format=floating-point -depth 32 -compress Zip -define tiff:predictor=3 tiff/float32-pred3.tif
convert src.ppm -colorspace Gray -define tiff:photometric=min-is-white -compress None tiff/gray-miniswhite.tif
ls -l jpeg png tiff
Binary file not shown.

After

Width:  |  Height:  |  Size: 5.1 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.7 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 241 B

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 308 B

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 685 B

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 1.2 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.1 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 920 B

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 727 B

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 691 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 4.7 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 3.5 KiB

BIN
View File
Binary file not shown.
BIN
View File
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.