Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
478 lines
19 KiB
C#
478 lines
19 KiB
C#
using System.Numerics;
|
||
using System.Runtime.CompilerServices;
|
||
using System.Runtime.InteropServices;
|
||
using System.Runtime.Intrinsics;
|
||
using Titano.Core.Imaging;
|
||
|
||
namespace Titano.Core.Codecs.Jpeg;
|
||
|
||
/// <summary>Chroma subsampling written by <see cref="JpegEncoder"/>.</summary>
|
||
public enum JpegSubsampling
|
||
{
|
||
Yuv444,
|
||
Yuv422,
|
||
Yuv420,
|
||
}
|
||
|
||
/// <summary>Options for <see cref="JpegEncoder"/>.</summary>
|
||
public sealed record JpegEncodeOptions
|
||
{
|
||
public static JpegEncodeOptions Default { get; } = new();
|
||
|
||
/// <summary>IJG quality 1–100 (scales the Annex K tables).</summary>
|
||
public int Quality { get; init; } = 90;
|
||
|
||
public JpegSubsampling Subsampling { get; init; } = JpegSubsampling.Yuv420;
|
||
|
||
/// <summary>Two-pass encoding with Huffman tables built from the image's statistics (smaller files).</summary>
|
||
public bool OptimizeHuffman { get; init; }
|
||
|
||
/// <summary>Restart interval in MCUs (0 = none).</summary>
|
||
public int RestartInterval { get; init; }
|
||
|
||
/// <summary>APP1 payloads written after SOI, each including its identifier (e.g. "Exif\0\0" + TIFF, or the XMP
|
||
/// namespace + packet); at most 65533 bytes each. When present the JFIF APP0 segment is omitted (Exif layout).</summary>
|
||
public IReadOnlyList<byte[]>? App1Segments { get; init; }
|
||
|
||
/// <summary>Ordered dither when quantising linear float input to 8-bit sRGB.</summary>
|
||
public bool Dither { get; init; }
|
||
|
||
/// <summary>Worker limit for colour conversion and forward DCT (-1 = all cores).</summary>
|
||
public int MaxDegreeOfParallelism { get; init; } = -1;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Baseline JPEG encoder (8-bit, Huffman, 1 or 3 components). Colour conversion and float forward DCT run in
|
||
/// parallel per MCU row; entropy coding is sequential.
|
||
/// </summary>
|
||
public static class JpegEncoder
|
||
{
|
||
private static readonly float[] BasisT = Transpose(JpegTables.Basis);
|
||
|
||
/// <summary>Encodes a linear-light buffer (1 channel → gray JPEG, 3/4 → YCbCr; alpha is dropped).</summary>
|
||
public static byte[] Encode(ImageBuffer image, JpegEncodeOptions? options = null)
|
||
{
|
||
using var ms = new MemoryStream();
|
||
Encode(ms, image, options);
|
||
return ms.ToArray();
|
||
}
|
||
|
||
public static void Encode(Stream output, ImageBuffer image, JpegEncodeOptions? options = null)
|
||
{
|
||
var o = options ?? JpegEncodeOptions.Default;
|
||
var channels = image.Channels == 1 ? 1 : 3;
|
||
EncodeCore(output, image.Width, image.Height, channels, (y, row) => PixelConvert.EncodeRow8(image, y, row, channels, TransferFunction.Srgb, o.Dither), o);
|
||
}
|
||
|
||
/// <summary>Encodes interleaved 8-bit sRGB pixels: 1 = gray, 3 = RGB, 4 = RGBA (alpha ignored).</summary>
|
||
public static byte[] Encode(ReadOnlySpan<byte> pixels, int width, int height, int channels, JpegEncodeOptions? options = null)
|
||
{
|
||
using var ms = new MemoryStream();
|
||
Encode(ms, pixels, width, height, channels, options);
|
||
return ms.ToArray();
|
||
}
|
||
|
||
public static unsafe void Encode(Stream output, ReadOnlySpan<byte> pixels, int width, int height, int channels, JpegEncodeOptions? options = null)
|
||
{
|
||
if (channels is not (1 or 3 or 4)) throw new ArgumentOutOfRangeException(nameof(channels));
|
||
if (pixels.Length < (long)width * height * channels) throw new ArgumentException("Pixel buffer too small", nameof(pixels));
|
||
var outChannels = channels == 1 ? 1 : 3;
|
||
fixed (byte* p = pixels)
|
||
{
|
||
var ptr = (nint)p;
|
||
EncodeCore(output, width, height, outChannels, (y, row) =>
|
||
{
|
||
var src = new ReadOnlySpan<byte>((byte*)ptr + (long)y * width * channels, width * channels);
|
||
if (channels == outChannels)
|
||
{
|
||
src.CopyTo(row);
|
||
return;
|
||
}
|
||
for (var x = 0; x < width; x++)
|
||
{
|
||
row[3 * x] = src[4 * x];
|
||
row[3 * x + 1] = src[4 * x + 1];
|
||
row[3 * x + 2] = src[4 * x + 2];
|
||
}
|
||
}, options ?? JpegEncodeOptions.Default);
|
||
}
|
||
}
|
||
|
||
/// <summary>IJG quality scaling of a base table (jcparam.c), clamped to baseline 1..255.</summary>
|
||
internal static int[] ScaleTable(ReadOnlySpan<byte> table, int quality)
|
||
{
|
||
quality = Math.Clamp(quality, 1, 100);
|
||
var scale = quality < 50 ? 5000 / quality : 200 - quality * 2;
|
||
var result = new int[64];
|
||
for (var i = 0; i < 64; i++) result[i] = Math.Clamp((table[i] * scale + 50) / 100, 1, 255);
|
||
return result;
|
||
}
|
||
|
||
private delegate void RowReader(int y, Span<byte> row);
|
||
|
||
private sealed class Plan
|
||
{
|
||
public required int Width, Height, Components, HY, VY, McusX, McusY;
|
||
public required int[][] Quant;
|
||
public required short[][] Coefficients;
|
||
|
||
public int BlocksPerLine(int c) => c == 0 ? McusX * HY : McusX;
|
||
}
|
||
|
||
private static void EncodeCore(Stream output, int width, int height, int components, RowReader read, JpegEncodeOptions o)
|
||
{
|
||
if (width is < 1 or > 65535 || height is < 1 or > 65535) throw new ArgumentOutOfRangeException(nameof(width), "JPEG dimensions are 1..65535");
|
||
if (o.RestartInterval is < 0 or > 65535) throw new ArgumentOutOfRangeException(nameof(o), "Restart interval is 0..65535");
|
||
var (hy, vy) = components == 1 ? (1, 1) : o.Subsampling switch
|
||
{
|
||
JpegSubsampling.Yuv444 => (1, 1),
|
||
JpegSubsampling.Yuv422 => (2, 1),
|
||
_ => (2, 2),
|
||
};
|
||
var mcusX = JpegParser.DivUp(width, 8 * hy);
|
||
var mcusY = JpegParser.DivUp(height, 8 * vy);
|
||
var plan = new Plan
|
||
{
|
||
Width = width, Height = height, Components = components, HY = hy, VY = vy, McusX = mcusX, McusY = mcusY,
|
||
Quant = [ScaleTable(JpegTables.LumaQuant, o.Quality), ScaleTable(JpegTables.ChromaQuant, o.Quality)],
|
||
Coefficients = new short[components][],
|
||
};
|
||
plan.Coefficients[0] = new short[checked(mcusX * hy * mcusY * vy * 64)];
|
||
for (var c = 1; c < components; c++) plan.Coefficients[c] = new short[checked(mcusX * mcusY * 64)];
|
||
|
||
Transform(plan, read, o.MaxDegreeOfParallelism);
|
||
|
||
JpegHuffmanCode dcY, acY, dcC, acC;
|
||
if (o.OptimizeHuffman)
|
||
{
|
||
var freq = new long[4][];
|
||
for (var i = 0; i < 4; i++) freq[i] = new long[256];
|
||
Entropy(plan, o.RestartInterval, null, freq, null);
|
||
dcY = JpegHuffmanCode.Optimal(freq[0]);
|
||
acY = JpegHuffmanCode.Optimal(freq[1]);
|
||
dcC = components > 1 ? JpegHuffmanCode.Optimal(freq[2]) : dcY;
|
||
acC = components > 1 ? JpegHuffmanCode.Optimal(freq[3]) : acY;
|
||
}
|
||
else
|
||
{
|
||
dcY = new JpegHuffmanCode(JpegTables.DcLumaBits, JpegTables.DcLumaValues);
|
||
acY = new JpegHuffmanCode(JpegTables.AcLumaBits, JpegTables.AcLumaValues);
|
||
dcC = new JpegHuffmanCode(JpegTables.DcChromaBits, JpegTables.DcChromaValues);
|
||
acC = new JpegHuffmanCode(JpegTables.AcChromaBits, JpegTables.AcChromaValues);
|
||
}
|
||
|
||
var writer = new JpegBitWriter((int)Math.Min(1 << 30, (long)width * height * components / 4));
|
||
Entropy(plan, o.RestartInterval, writer, null, [dcY, acY, dcC, acC]);
|
||
WriteHeaders(output, plan, o, dcY, acY, dcC, acC);
|
||
output.Write(writer.Written);
|
||
output.Write([0xFF, JpegTables.Eoi]);
|
||
}
|
||
|
||
/// <summary>Colour conversion, chroma downsampling (box average), forward DCT and quantisation per MCU row.</summary>
|
||
private static void Transform(Plan p, RowReader read, int parallelism)
|
||
{
|
||
int hy = p.HY, vy = p.VY, mcuH = 8 * vy, paddedW = p.McusX * 8 * hy, nc = p.Components;
|
||
var recip = new float[2][];
|
||
for (var t = 0; t < 2; t++)
|
||
{
|
||
recip[t] = new float[64];
|
||
for (var i = 0; i < 64; i++) recip[t][i] = 1f / p.Quant[t][i];
|
||
}
|
||
Parallel.For(0, p.McusY, new ParallelOptions { MaxDegreeOfParallelism = parallelism }, my =>
|
||
{
|
||
var rgb = new byte[p.Width * nc];
|
||
var planes = new float[nc][];
|
||
for (var c = 0; c < nc; c++) planes[c] = new float[paddedW * mcuH];
|
||
for (var r = 0; r < mcuH; r++)
|
||
{
|
||
var y = Math.Min(my * mcuH + r, p.Height - 1);
|
||
read(y, rgb);
|
||
var row = r * paddedW;
|
||
if (nc == 1)
|
||
{
|
||
var g = planes[0];
|
||
for (var x = 0; x < p.Width; x++) g[row + x] = rgb[x] - 128f;
|
||
}
|
||
else
|
||
{
|
||
float[] yp = planes[0], cb = planes[1], cr = planes[2];
|
||
for (var x = 0; x < p.Width; x++)
|
||
{
|
||
float rr = rgb[3 * x], gg = rgb[3 * x + 1], bb = rgb[3 * x + 2];
|
||
yp[row + x] = 0.299f * rr + 0.587f * gg + 0.114f * bb - 128f;
|
||
cb[row + x] = -0.168736f * rr - 0.331264f * gg + 0.5f * bb;
|
||
cr[row + x] = 0.5f * rr - 0.418688f * gg - 0.081312f * bb;
|
||
}
|
||
}
|
||
for (var c = 0; c < nc; c++)
|
||
{
|
||
var plane = planes[c];
|
||
plane.AsSpan(row + p.Width, paddedW - p.Width).Fill(plane[row + p.Width - 1]);
|
||
}
|
||
}
|
||
|
||
Span<float> block = stackalloc float[64];
|
||
Span<float> coef = stackalloc float[64];
|
||
var bpl = p.BlocksPerLine(0);
|
||
for (var by = 0; by < vy; by++)
|
||
{
|
||
for (var bx = 0; bx < bpl; bx++)
|
||
{
|
||
for (var r = 0; r < 8; r++) planes[0].AsSpan((by * 8 + r) * paddedW + bx * 8, 8).CopyTo(block.Slice(r * 8, 8));
|
||
ForwardDct(block, coef);
|
||
Quantize(coef, recip[0], p.Coefficients[0].AsSpan(((my * vy + by) * bpl + bx) * 64, 64));
|
||
}
|
||
}
|
||
var area = 1f / (hy * vy);
|
||
for (var c = 1; c < nc; c++)
|
||
{
|
||
var plane = planes[c];
|
||
for (var bx = 0; bx < p.McusX; bx++)
|
||
{
|
||
for (var r = 0; r < 8; r++)
|
||
{
|
||
for (var i = 0; i < 8; i++)
|
||
{
|
||
var sum = 0f;
|
||
var x0 = (bx * 8 + i) * hy;
|
||
for (var dy = 0; dy < vy; dy++)
|
||
{
|
||
var at = (r * vy + dy) * paddedW + x0;
|
||
for (var dx = 0; dx < hy; dx++) sum += plane[at + dx];
|
||
}
|
||
block[r * 8 + i] = sum * area;
|
||
}
|
||
}
|
||
ForwardDct(block, coef);
|
||
Quantize(coef, recip[1], p.Coefficients[c].AsSpan((my * p.McusX + bx) * 64, 64));
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
/// <summary>F = B·f·Bᵀ with the orthonormal basis (DC = 8 × mean), Vector256 rows when available.</summary>
|
||
private static void ForwardDct(ReadOnlySpan<float> f, Span<float> output)
|
||
{
|
||
var basis = JpegTables.Basis;
|
||
if (Vector256.IsHardwareAccelerated)
|
||
{
|
||
ref var bt = ref MemoryMarshal.GetArrayDataReference(BasisT);
|
||
Span<Vector256<float>> t = stackalloc Vector256<float>[8];
|
||
for (var y = 0; y < 8; y++)
|
||
{
|
||
var acc = Vector256<float>.Zero;
|
||
for (var x = 0; x < 8; x++) acc += Vector256.Create(f[y * 8 + x]) * Vector256.LoadUnsafe(ref bt, (nuint)(x * 8));
|
||
t[y] = acc;
|
||
}
|
||
for (var v = 0; v < 8; v++)
|
||
{
|
||
var acc = Vector256<float>.Zero;
|
||
for (var y = 0; y < 8; y++) acc += Vector256.Create(basis[v * 8 + y]) * t[y];
|
||
acc.CopyTo(output.Slice(v * 8, 8));
|
||
}
|
||
return;
|
||
}
|
||
Span<float> tmp = stackalloc float[64];
|
||
for (var y = 0; y < 8; y++)
|
||
{
|
||
for (var u = 0; u < 8; u++)
|
||
{
|
||
var s = 0f;
|
||
for (var x = 0; x < 8; x++) s += f[y * 8 + x] * basis[u * 8 + x];
|
||
tmp[y * 8 + u] = s;
|
||
}
|
||
}
|
||
for (var v = 0; v < 8; v++)
|
||
{
|
||
for (var u = 0; u < 8; u++)
|
||
{
|
||
var s = 0f;
|
||
for (var y = 0; y < 8; y++) s += basis[v * 8 + y] * tmp[y * 8 + u];
|
||
output[v * 8 + u] = s;
|
||
}
|
||
}
|
||
}
|
||
|
||
private static void Quantize(ReadOnlySpan<float> coef, float[] recip, Span<short> destination)
|
||
{
|
||
destination[0] = (short)Math.Clamp(MathF.Round(coef[0] * recip[0]), -1024f, 1023f);
|
||
for (var i = 1; i < 64; i++) destination[i] = (short)Math.Clamp(MathF.Round(coef[i] * recip[i]), -1023f, 1023f);
|
||
}
|
||
|
||
/// <summary>Walks every MCU in order: counts symbol frequencies (<paramref name="freq"/>) or emits codes.</summary>
|
||
private static void Entropy(Plan p, int restartInterval, JpegBitWriter? writer, long[][]? freq, JpegHuffmanCode[]? codes)
|
||
{
|
||
var preds = new int[p.Components];
|
||
var total = p.McusX * p.McusY;
|
||
var rst = 0;
|
||
for (var mcu = 0; mcu < total; mcu++)
|
||
{
|
||
if (restartInterval > 0 && mcu > 0 && mcu % restartInterval == 0)
|
||
{
|
||
Array.Clear(preds);
|
||
if (writer is not null)
|
||
{
|
||
writer.Flush();
|
||
writer.WriteMarker((byte)(JpegTables.Rst0 + rst));
|
||
}
|
||
rst = (rst + 1) & 7;
|
||
}
|
||
writer?.Reserve(4096);
|
||
int mx = mcu % p.McusX, my = mcu / p.McusX;
|
||
for (var c = 0; c < p.Components; c++)
|
||
{
|
||
int h = c == 0 ? p.HY : 1, v = c == 0 ? p.VY : 1, bpl = p.BlocksPerLine(c), table = c == 0 ? 0 : 2;
|
||
for (var by = 0; by < v; by++)
|
||
{
|
||
for (var bx = 0; bx < h; bx++)
|
||
{
|
||
var block = p.Coefficients[c].AsSpan(((my * v + by) * bpl + mx * h + bx) * 64, 64);
|
||
if (writer is null) CountBlock(block, ref preds[c], freq![table], freq[table + 1]);
|
||
else EncodeBlock(writer, block, ref preds[c], codes![table], codes[table + 1]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
writer?.Flush();
|
||
}
|
||
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
private static int Category(int v) => v == 0 ? 0 : 32 - BitOperations.LeadingZeroCount((uint)Math.Abs(v));
|
||
|
||
private static void CountBlock(ReadOnlySpan<short> block, ref int pred, long[] dc, long[] ac)
|
||
{
|
||
dc[Category(block[0] - pred)]++;
|
||
pred = block[0];
|
||
var run = 0;
|
||
var order = JpegTables.NaturalOrder;
|
||
for (var k = 1; k < 64; k++)
|
||
{
|
||
int v = block[order[k]];
|
||
if (v == 0)
|
||
{
|
||
run++;
|
||
continue;
|
||
}
|
||
for (; run >= 16; run -= 16) ac[0xF0]++;
|
||
ac[run << 4 | Category(v)]++;
|
||
run = 0;
|
||
}
|
||
if (run > 0) ac[0]++;
|
||
}
|
||
|
||
private static void EncodeBlock(JpegBitWriter w, ReadOnlySpan<short> block, ref int pred, JpegHuffmanCode dc, JpegHuffmanCode ac)
|
||
{
|
||
var diff = block[0] - pred;
|
||
pred = block[0];
|
||
var s = Category(diff);
|
||
w.Write((uint)(dc.Code[s] << s | ((diff < 0 ? diff - 1 : diff) & ((1 << s) - 1))), dc.Length[s] + s);
|
||
var run = 0;
|
||
var order = JpegTables.NaturalOrder;
|
||
for (var k = 1; k < 64; k++)
|
||
{
|
||
int v = block[order[k]];
|
||
if (v == 0)
|
||
{
|
||
run++;
|
||
continue;
|
||
}
|
||
for (; run >= 16; run -= 16) w.Write(ac.Code[0xF0], ac.Length[0xF0]);
|
||
s = Category(v);
|
||
var symbol = run << 4 | s;
|
||
w.Write((uint)(ac.Code[symbol] << s | ((v < 0 ? v - 1 : v) & ((1 << s) - 1))), ac.Length[symbol] + s);
|
||
run = 0;
|
||
}
|
||
if (run > 0) w.Write(ac.Code[0], ac.Length[0]);
|
||
}
|
||
|
||
private static void WriteHeaders(Stream output, Plan p, JpegEncodeOptions o, JpegHuffmanCode dcY, JpegHuffmanCode acY, JpegHuffmanCode dcC, JpegHuffmanCode acC)
|
||
{
|
||
var h = new MemoryStream();
|
||
h.Write([0xFF, JpegTables.Soi]);
|
||
if (o.App1Segments is { Count: > 0 } apps)
|
||
{
|
||
foreach (var app in apps)
|
||
{
|
||
if (app.Length > 65533) throw new ArgumentException("APP1 payload exceeds 65533 bytes", nameof(o));
|
||
Segment(h, JpegTables.App1, app);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Segment(h, JpegTables.App0, [(byte)'J', (byte)'F', (byte)'I', (byte)'F', 0, 1, 1, 0, 0, 1, 0, 1, 0, 0]);
|
||
}
|
||
var tables = p.Components == 1 ? 1 : 2;
|
||
var dqt = new byte[65 * tables];
|
||
for (var t = 0; t < tables; t++)
|
||
{
|
||
dqt[65 * t] = (byte)t;
|
||
for (var k = 0; k < 64; k++) dqt[65 * t + 1 + k] = (byte)p.Quant[t][JpegTables.NaturalOrder[k]];
|
||
}
|
||
Segment(h, JpegTables.Dqt, dqt);
|
||
|
||
var sof = new byte[6 + 3 * p.Components];
|
||
sof[0] = 8;
|
||
sof[1] = (byte)(p.Height >> 8);
|
||
sof[2] = (byte)p.Height;
|
||
sof[3] = (byte)(p.Width >> 8);
|
||
sof[4] = (byte)p.Width;
|
||
sof[5] = (byte)p.Components;
|
||
for (var c = 0; c < p.Components; c++)
|
||
{
|
||
sof[6 + 3 * c] = (byte)(c + 1);
|
||
sof[7 + 3 * c] = c == 0 ? (byte)(p.HY << 4 | p.VY) : (byte)0x11;
|
||
sof[8 + 3 * c] = (byte)(c == 0 ? 0 : 1);
|
||
}
|
||
Segment(h, JpegTables.Sof0, sof);
|
||
|
||
var dht = new MemoryStream();
|
||
Huffman(dht, 0x00, dcY);
|
||
Huffman(dht, 0x10, acY);
|
||
if (p.Components > 1)
|
||
{
|
||
Huffman(dht, 0x01, dcC);
|
||
Huffman(dht, 0x11, acC);
|
||
}
|
||
Segment(h, JpegTables.Dht, dht.ToArray());
|
||
if (o.RestartInterval > 0) Segment(h, JpegTables.Dri, [(byte)(o.RestartInterval >> 8), (byte)o.RestartInterval]);
|
||
|
||
var sos = new byte[4 + 2 * p.Components];
|
||
sos[0] = (byte)p.Components;
|
||
for (var c = 0; c < p.Components; c++)
|
||
{
|
||
sos[1 + 2 * c] = (byte)(c + 1);
|
||
sos[2 + 2 * c] = c == 0 ? (byte)0x00 : (byte)0x11;
|
||
}
|
||
sos[^3] = 0;
|
||
sos[^2] = 63;
|
||
sos[^1] = 0;
|
||
Segment(h, JpegTables.Sos, sos);
|
||
h.Position = 0;
|
||
h.CopyTo(output);
|
||
}
|
||
|
||
private static void Huffman(Stream s, byte classAndId, JpegHuffmanCode code)
|
||
{
|
||
s.WriteByte(classAndId);
|
||
s.Write(code.Bits);
|
||
s.Write(code.Values);
|
||
}
|
||
|
||
internal static void Segment(Stream s, byte marker, ReadOnlySpan<byte> payload)
|
||
{
|
||
var length = payload.Length + 2;
|
||
s.Write([0xFF, marker, (byte)(length >> 8), (byte)length]);
|
||
s.Write(payload);
|
||
}
|
||
|
||
private static float[] Transpose(float[] m)
|
||
{
|
||
var t = new float[64];
|
||
for (var i = 0; i < 8; i++)
|
||
{
|
||
for (var j = 0; j < 8; j++) t[j * 8 + i] = m[i * 8 + j];
|
||
}
|
||
return t;
|
||
}
|
||
}
|