CI / Build and test (pull_request) Failing after 2m3s
CI / PostgreSQL 16 integration (pull_request) Skipped
CI / PostgreSQL 17 integration (pull_request) Skipped
CI / Docker image (pull_request) Skipped
CI / Windows tests and installer (pull_request) Skipped
CI / YAML check (pull_request) Successful in 4s
The owner renamed the product and moved the repository to the self-hosted Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control, and asked for Actions and a first automatic release with the server package and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md). - Chronos everywhere: a byte-exact rename of contents and paths, then a per-language review of the forms the old name's ending had dictated. - Gitea instead of GitHub: the update check, licence, issue and support links read ChronosReleasesUrl; the update check takes the highest stable version, offers a pre-release build its final release and reports a repository it cannot see as a failed check. EULA, security policy and Gitea issue forms live at the repository root. - Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release, nightly image and performance gates in the .NET SDK container with git checkout. The release cross-compiles the Windows programs, checks their icon, version and DPI manifest, packs installers and zips, publishes the Gitea release and pushes the server image (REGISTRY_TOKEN). Windows-only tests run in an opt-in job on a Windows runner (WINDOWS_RUNNER). - New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the docker-exec script, which Gitea's service containers do not allow) and pe-check. BREAKING CHANGE: programs, settings, data folders, file types, environment variables and the Docker image use the new name; nothing is migrated from Titano, which never had a release. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
310 lines
13 KiB
C#
310 lines
13 KiB
C#
using Chronos.Core.Codecs.Jpeg;
|
||
using Chronos.Core.Imaging;
|
||
using Chronos.Testing;
|
||
using static Chronos.Core.Tests.Codecs.CodecTestData;
|
||
|
||
namespace Chronos.Core.Tests.Codecs;
|
||
|
||
/// <summary>Encoder → decoder round trips on synthetic content.</summary>
|
||
public sealed class JpegEncoderTests(TestContext context)
|
||
{
|
||
private const int W = 160, H = 120;
|
||
|
||
/// <summary>The four synthetic content classes: smooth gradients, colour bars, sensor-like noise, text-like edges.</summary>
|
||
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);
|
||
}
|
||
|
||
/// <summary>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′.</summary>
|
||
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<double>(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<double>();
|
||
var sizes = new List<double>();
|
||
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<x:xmpmeta/>"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<ArgumentException>(() => 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<ushort>(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);
|
||
}
|
||
|
||
/// <summary>Minimal SOF1 12-bit gray encoder (quantiser 1, optimal tables) for decoder tests.</summary>
|
||
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<bool, int> symbol, Action<int, int>? 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));
|
||
}
|
||
}
|