using System.Buffers.Binary;
using System.Text;
namespace Chronos.Core.Tests.Metadata.Builders;
/// Synthetic JPEG: SOI, arbitrary segments/raw bytes, an optional APP2 MPF index of appended secondary
/// images, SOFn, SOS with a fake scan, EOI. No real entropy data: parsers stop at SOS.
internal sealed class JpegBuilder
{
public const string XmpSignature = "http://ns.adobe.com/xap/1.0/\0";
public const string ExtendedXmpSignature = "http://ns.adobe.com/xmp/extension/\0";
private readonly List _parts = [];
private readonly List<(byte[] Jpeg, uint Type)> _secondary = [];
private int _mpfPart = -1;
/// A minimal JPEG with just a frame header (used as embedded previews).
public static byte[] Minimal(int width, int height, byte sofMarker = 0xC0, int precision = 8, int scanBytes = 32) =>
new JpegBuilder().Build(width, height, sofMarker, precision, scanBytes);
public JpegBuilder Segment(byte marker, byte[] payload)
{
var s = new byte[4 + payload.Length];
s[0] = 0xFF;
s[1] = marker;
BinaryPrimitives.WriteUInt16BigEndian(s.AsSpan(2), (ushort)(payload.Length + 2));
payload.CopyTo(s, 4);
_parts.Add(s);
return this;
}
/// Bytes inserted verbatim (fill bytes, garbage).
public JpegBuilder Raw(params byte[] bytes)
{
_parts.Add(bytes);
return this;
}
public JpegBuilder Exif(byte[] tiff) => Segment(0xE1, [.. "Exif\0\0"u8, .. tiff]);
public JpegBuilder Xmp(string packet) => Segment(0xE1, [.. Encoding.ASCII.GetBytes(XmpSignature), .. Encoding.UTF8.GetBytes(packet)]);
/// Extended XMP split into -byte APP1 segments (written in reverse order to prove
/// reassembly uses offsets).
public JpegBuilder ExtendedXmp(string guid, string packet, int chunk)
{
var data = Encoding.UTF8.GetBytes(packet);
var segments = new List();
for (var offset = 0; offset < data.Length; offset += chunk)
{
var piece = data.AsSpan(offset, Math.Min(chunk, data.Length - offset));
var payload = new byte[ExtendedXmpSignature.Length + 32 + 8 + piece.Length];
Encoding.ASCII.GetBytes(ExtendedXmpSignature).CopyTo(payload, 0);
Encoding.ASCII.GetBytes(guid).CopyTo(payload, ExtendedXmpSignature.Length);
BinaryPrimitives.WriteUInt32BigEndian(payload.AsSpan(ExtendedXmpSignature.Length + 32), (uint)data.Length);
BinaryPrimitives.WriteUInt32BigEndian(payload.AsSpan(ExtendedXmpSignature.Length + 36), (uint)offset);
piece.CopyTo(payload.AsSpan(ExtendedXmpSignature.Length + 40));
segments.Add(payload);
}
segments.Reverse();
foreach (var s in segments) Segment(0xE1, s);
return this;
}
/// APP2 MPF index; each secondary JPEG is appended after the primary's EOI with the given MP type code.
public JpegBuilder Mpf(params (byte[] Jpeg, uint Type)[] secondary)
{
_secondary.AddRange(secondary);
_mpfPart = _parts.Count;
_parts.Add([]);
return this;
}
public byte[] Build(int width, int height, byte sofMarker = 0xC0, int precision = 8, int scanBytes = 32)
{
var tail = new List();
tail.AddRange(SegmentBytes(sofMarker, [(byte)precision, (byte)(height >> 8), (byte)height, (byte)(width >> 8), (byte)width, 3, 1, 0x22, 0, 2, 0x11, 1, 3, 0x11, 1]));
tail.AddRange(SegmentBytes(0xDA, [3, 1, 0, 2, 0x11, 3, 0x11, 0, 0x3F, 0]));
for (var i = 0; i < scanBytes; i++) tail.Add((byte)(i * 37 % 255));
tail.AddRange([0xFF, 0xD9]);
if (_mpfPart >= 0) _parts[_mpfPart] = SegmentBytes(0xE2, MpfPayload(new uint[_secondary.Count], 0));
var headLength = 2 + _parts.Sum(p => p.Length);
var primaryLength = headLength + tail.Count;
if (_mpfPart >= 0)
{
var mpHeader = 2 + _parts.Take(_mpfPart).Sum(p => p.Length) + 4 + 4;
var offsets = new uint[_secondary.Count];
var at = primaryLength;
for (var i = 0; i < offsets.Length; i++)
{
offsets[i] = (uint)(at - mpHeader);
at += _secondary[i].Jpeg.Length;
}
_parts[_mpfPart] = SegmentBytes(0xE2, MpfPayload(offsets, primaryLength));
}
var file = new List(primaryLength);
file.AddRange([0xFF, 0xD8]);
foreach (var p in _parts) file.AddRange(p);
file.AddRange(tail);
foreach (var (jpeg, _) in _secondary) file.AddRange(jpeg);
return file.ToArray();
byte[] MpfPayload(uint[] offsets, int primarySize)
{
// "MPF\0", big-endian MP header, index IFD (version, count, entries), then 16-byte MP entries.
var n = offsets.Length + 1;
var b = new byte[4 + 8 + 2 + 3 * 12 + 4 + 16 * n];
var s = b.AsSpan();
"MPF\0MM\0*"u8.CopyTo(s);
BinaryPrimitives.WriteUInt32BigEndian(s[8..], 8);
var ifd = s[12..];
BinaryPrimitives.WriteUInt16BigEndian(ifd, 3);
WriteEntry(ifd[2..], 0xB000, 7, 4, BinaryPrimitives.ReadUInt32BigEndian("0100"u8));
WriteEntry(ifd[14..], 0xB001, 4, 1, (uint)n);
WriteEntry(ifd[26..], 0xB002, 7, (uint)(16 * n), 8 + 2 + 36 + 4);
var entries = s[(4 + 8 + 2 + 36 + 4)..];
BinaryPrimitives.WriteUInt32BigEndian(entries, 0x20030000);
BinaryPrimitives.WriteUInt32BigEndian(entries[4..], (uint)primarySize);
for (var i = 0; i < offsets.Length; i++)
{
var e = entries[(16 * (i + 1))..];
BinaryPrimitives.WriteUInt32BigEndian(e, _secondary[i].Type);
BinaryPrimitives.WriteUInt32BigEndian(e[4..], (uint)_secondary[i].Jpeg.Length);
BinaryPrimitives.WriteUInt32BigEndian(e[8..], offsets[i]);
}
return b;
}
}
private static void WriteEntry(Span s, ushort tag, ushort type, uint count, uint value)
{
BinaryPrimitives.WriteUInt16BigEndian(s, tag);
BinaryPrimitives.WriteUInt16BigEndian(s[2..], type);
BinaryPrimitives.WriteUInt32BigEndian(s[4..], count);
BinaryPrimitives.WriteUInt32BigEndian(s[8..], value);
}
private static byte[] SegmentBytes(byte marker, byte[] payload)
{
var s = new byte[4 + payload.Length];
s[0] = 0xFF;
s[1] = marker;
BinaryPrimitives.WriteUInt16BigEndian(s.AsSpan(2), (ushort)(payload.Length + 2));
payload.CopyTo(s, 4);
return s;
}
}