using Titano.Core.Codecs.Jpeg;
using Titano.Core.Imaging;
using Titano.Testing;
using static Titano.Core.Tests.Codecs.CodecTestData;
namespace Titano.Core.Tests.Codecs;
/// Encoder → decoder round trips on synthetic content.
public sealed class JpegEncoderTests(TestContext context)
{
private const int W = 160, H = 120;
/// The four synthetic content classes: smooth gradients, colour bars, sensor-like noise, text-like edges.
private static byte[] Content(string kind)
{
var rgb = new byte[W * H * 3];
var rng = new Random(11);
for (var y = 0; y < H; y++)
{
for (var x = 0; x < W; x++)
{
int r, g, b;
switch (kind)
{
case "gradients":
r = x * 255 / (W - 1);
g = y * 255 / (H - 1);
b = (x + y) * 255 / (W + H - 2);
break;
case "bars":
var bar = x / (W / 8);
r = (bar & 4) != 0 ? 235 : 16;
g = (bar & 2) != 0 ? 235 : 16;
b = (bar & 1) != 0 ? 235 : 16;
break;
case "noise":
// Sensor-like: mostly luma noise (σ ≈ 3.7 levels) plus weak chroma noise.
var n = rng.Next(-6, 7);
r = 120 + x / 4 + n + rng.Next(-2, 3);
g = 110 + y / 4 + n + rng.Next(-2, 3);
b = 100 + n + rng.Next(-2, 3);
break;
default:
var ink = (x % 11 is 2 or 3 && y % 16 < 12) || (y % 16 is 5 && x % 11 < 8);
r = g = b = ink ? 24 : 232;
break;
}
var i = (y * W + x) * 3;
rgb[i] = (byte)r;
rgb[i + 1] = (byte)g;
rgb[i + 2] = (byte)b;
}
}
return rgb;
}
private static double RoundTripPsnr(byte[] rgb, JpegEncodeOptions options, int channels = 3)
{
var jpeg = JpegEncoder.Encode(rgb, W, H, channels, options);
var decoded = JpegDecoder.Decode(jpeg);
return Psnr(decoded.Pixels8, rgb);
}
/// PSNR of Rec.601 luma (Y′). 4:2:0 halves chroma resolution by design, so saturated chroma edges
/// (colour bars) lose a quarter of the step under triangle upsampling in any codec (libjpeg: 26.7 dB RGB on
/// the same bars); the codec's own fidelity is measured on Y′.
private static double RoundTripLumaPsnr(byte[] rgb, JpegEncodeOptions options)
{
var decoded = JpegDecoder.Decode(JpegEncoder.Encode(rgb, W, H, 3, options)).Pixels8!;
static double[] Luma(byte[] p)
{
var y = new double[p.Length / 3];
for (var i = 0; i < y.Length; i++) y[i] = 0.299 * p[3 * i] + 0.587 * p[3 * i + 1] + 0.114 * p[3 * i + 2];
return y;
}
return Psnr(Luma(decoded), Luma(rgb), 255);
}
[Theory]
[Case("gradients")]
[Case("bars")]
[Case("noise")]
[Case("text")]
public void HighQuality444Above40Db(string kind)
{
var psnr = RoundTripPsnr(Content(kind), new JpegEncodeOptions { Quality = 95, Subsampling = JpegSubsampling.Yuv444 });
context.Log($"{kind} q95 4:4:4: {psnr:F2} dB");
Assert.GreaterOrEqual(psnr, 40);
}
[Theory]
[Case("gradients")]
[Case("bars")]
[Case("noise")]
[Case("text")]
public void Quality90Yuv420Above34Db(string kind)
{
var options = new JpegEncodeOptions { Quality = 90, Subsampling = JpegSubsampling.Yuv420 };
var psnr = RoundTripLumaPsnr(Content(kind), options);
context.Log($"{kind} q90 4:2:0: Y′ {psnr:F2} dB, RGB {RoundTripPsnr(Content(kind), options):F2} dB");
Assert.GreaterOrEqual(psnr, 34);
}
[Test]
public void PsnrAndSizeGrowWithQuality()
{
var rgb = TestCard(W, H);
var psnr = new List();
var sizes = new List();
foreach (var q in new[] { 5, 20, 40, 60, 75, 85, 95, 100 })
{
var jpeg = JpegEncoder.Encode(rgb, W, H, 3, new JpegEncodeOptions { Quality = q, Subsampling = JpegSubsampling.Yuv422 });
sizes.Add(jpeg.Length);
psnr.Add(Psnr(JpegDecoder.Decode(jpeg).Pixels8, rgb));
}
context.Log("PSNR: " + string.Join(", ", psnr.Select(p => p.ToString("F1"))));
Assert.Monotonic(psnr, strict: true);
Assert.Monotonic(sizes, strict: true);
}
[Test]
public void OptimizedHuffmanIsSmallerAndPixelIdentical()
{
var rgb = TestCard(W, H);
var standard = JpegEncoder.Encode(rgb, W, H, 3, new JpegEncodeOptions { Quality = 85 });
var optimized = JpegEncoder.Encode(rgb, W, H, 3, new JpegEncodeOptions { Quality = 85, OptimizeHuffman = true });
context.Log($"standard {standard.Length} B, optimized {optimized.Length} B");
Assert.Less(optimized.Length, standard.Length);
Assert.BytesEqual(JpegDecoder.Decode(standard).Pixels8, JpegDecoder.Decode(optimized).Pixels8);
}
[Theory]
[Case(1)]
[Case(7)]
[Case(40)]
public void RestartIntervalsDecodeIdentically(int interval)
{
var rgb = TestCard(W, H);
var plain = JpegEncoder.Encode(rgb, W, H, 3, new JpegEncodeOptions { Quality = 80 });
var restart = JpegEncoder.Encode(rgb, W, H, 3, new JpegEncodeOptions { Quality = 80, RestartInterval = interval, OptimizeHuffman = true });
Assert.Equal(interval, JpegDecoder.ReadInfo(restart).RestartInterval);
var decoded = JpegDecoder.Decode(restart);
Assert.Empty(decoded.Warnings);
Assert.BytesEqual(JpegDecoder.Decode(plain).Pixels8, decoded.Pixels8);
}
[Test]
public void App1SegmentsFollowSoiAndReplaceJfif()
{
var exif = "Exif\0\0II*\0\b\0\0\0\0\0\0\0"u8.ToArray();
var xmp = "http://ns.adobe.com/xap/1.0/\0"u8.ToArray();
var jpeg = JpegEncoder.Encode(TestCard(32, 16), 32, 16, 3, new JpegEncodeOptions { App1Segments = [exif, xmp] });
Assert.Equal(0xE1, jpeg[3]);
Assert.BytesEqual(exif, jpeg.AsSpan(6, exif.Length));
var second = 4 + (jpeg[4] << 8 | jpeg[5]);
Assert.Equal(0xE1, jpeg[second + 1]);
Assert.False(jpeg.AsSpan().IndexOf("JFIF"u8) >= 0, "JFIF must be omitted when APP1 is supplied");
Assert.Equal(32, JpegDecoder.Decode(jpeg).Width);
Assert.Throws(() => JpegEncoder.Encode(TestCard(8, 8), 8, 8, 3, new JpegEncodeOptions { App1Segments = [new byte[65534]] }));
}
[Test]
public void GrayBufferEncodesSingleComponent()
{
using var gray = new ImageBuffer(50, 30, 1);
for (var i = 0; i < gray.PlaneLength; i++) gray.Plane(0)[i] = (i % 50) / 49f;
var jpeg = JpegEncoder.Encode(gray, new JpegEncodeOptions { Quality = 95 });
var info = JpegDecoder.ReadInfo(jpeg);
Assert.Equal(1, info.Components);
using var back = JpegDecoder.DecodeToLinear(jpeg);
Assert.Equal(1, back.Channels);
for (var x = 0; x < 50; x += 7) Assert.Approximately(gray[0, x, 15], back[0, x, 15], 0.02);
}
[Test]
public void LinearBufferRoundTripWithDither()
{
using var image = new ImageBuffer(96, 64);
for (var y = 0; y < 64; y++)
{
for (var x = 0; x < 96; x++)
{
image[0, x, y] = x / 95f;
image[1, x, y] = y / 63f * 0.5f;
image[2, x, y] = 0.18f;
}
}
var jpeg = JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 95, Subsampling = JpegSubsampling.Yuv444, Dither = true });
using var back = JpegDecoder.DecodeToLinear(jpeg);
var reference = PixelConvert.ToInterleaved8(image, 3);
var decoded = PixelConvert.ToInterleaved8(back, 3);
var psnr = Psnr(decoded, reference);
context.Log($"linear round trip {psnr:F1} dB");
Assert.Greater(psnr, 40);
}
[Test]
public void TwelveBitExtendedSequentialDecodes()
{
const int w = 40, h = 24;
var samples = new ushort[w * h];
for (var y = 0; y < h; y++)
{
for (var x = 0; x < w; x++) samples[y * w + x] = (ushort)(x * 4095 / (w - 1) ^ (y * 37 % 256));
}
var jpeg = TwelveBitEncoder.EncodeGray(samples, w, h);
var image = JpegDecoder.Decode(jpeg);
Assert.Equal(12, image.BitDepth);
Assert.Equal(JpegProcess.ExtendedSequential, image.Info.Process);
var psnr = Psnr(image.Pixels16, samples, 4095);
context.Log($"12-bit PSNR {psnr:F1} dB");
Assert.Greater(psnr, 50);
using var linear = JpegDecoder.DecodeToLinear(jpeg);
Assert.Approximately(ColorSpace.SrgbToLinear(image.Pixels16![5] / 4095.0), linear[0, 5, 0], 1e-4);
}
/// Minimal SOF1 12-bit gray encoder (quantiser 1, optimal tables) for decoder tests.
private static class TwelveBitEncoder
{
public static byte[] EncodeGray(ushort[] samples, int width, int height)
{
int bw = (width + 7) / 8, bh = (height + 7) / 8;
var blocks = new short[bw * bh][];
for (var by = 0; by < bh; by++)
{
for (var bx = 0; bx < bw; bx++)
{
var coef = new short[64];
for (var v = 0; v < 8; v++)
{
for (var u = 0; u < 8; u++)
{
double sum = 0;
for (var y = 0; y < 8; y++)
{
for (var x = 0; x < 8; x++)
{
var s = samples[Math.Min(by * 8 + y, height - 1) * width + Math.Min(bx * 8 + x, width - 1)] - 2048.0;
sum += s * JpegTables.Basis[u * 8 + x] * JpegTables.Basis[v * 8 + y];
}
}
coef[v * 8 + u] = (short)Math.Round(sum);
}
}
blocks[by * bw + bx] = coef;
}
}
var dcFreq = new long[256];
var acFreq = new long[256];
Walk(blocks, (dc, s) => (dc ? dcFreq : acFreq)[s]++, null);
var dcCode = JpegHuffmanCode.Optimal(dcFreq);
var acCode = JpegHuffmanCode.Optimal(acFreq);
var writer = new JpegBitWriter(1 << 16);
Walk(blocks, (dc, s) => { var c = dc ? dcCode : acCode; writer.Reserve(8); writer.Write(c.Code[s], c.Length[s]); }, (v, s) => writer.Write((uint)((v < 0 ? v - 1 : v) & ((1 << s) - 1)), s));
writer.Flush();
using var ms = new MemoryStream();
ms.Write([0xFF, 0xD8]);
var dqt = new byte[129];
dqt[0] = 0x10;
for (var k = 0; k < 64; k++) dqt[2 + 2 * k] = 1;
JpegEncoder.Segment(ms, 0xDB, dqt);
JpegEncoder.Segment(ms, 0xC1, [12, (byte)(height >> 8), (byte)height, (byte)(width >> 8), (byte)width, 1, 1, 0x11, 0]);
var dht = new MemoryStream();
dht.WriteByte(0x00);
dht.Write(dcCode.Bits);
dht.Write(dcCode.Values);
dht.WriteByte(0x10);
dht.Write(acCode.Bits);
dht.Write(acCode.Values);
JpegEncoder.Segment(ms, 0xC4, dht.ToArray());
JpegEncoder.Segment(ms, 0xDA, [1, 1, 0x00, 0, 63, 0]);
ms.Write(writer.Written);
ms.Write([0xFF, 0xD9]);
return ms.ToArray();
}
private static void Walk(short[][] blocks, Action symbol, Action? bits)
{
var pred = 0;
foreach (var b in blocks)
{
var diff = b[0] - pred;
pred = b[0];
var s = Size(diff);
symbol(true, s);
if (s > 0) bits?.Invoke(diff, s);
var run = 0;
for (var k = 1; k < 64; k++)
{
int v = b[JpegTables.NaturalOrder[k]];
if (v == 0)
{
run++;
continue;
}
for (; run >= 16; run -= 16) symbol(false, 0xF0);
s = Size(v);
symbol(false, run << 4 | s);
bits?.Invoke(v, s);
run = 0;
}
if (run > 0) symbol(false, 0);
}
}
private static int Size(int v) => v == 0 ? 0 : 32 - System.Numerics.BitOperations.LeadingZeroCount((uint)Math.Abs(v));
}
}