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; } }