254 lines
8.3 KiB
TypeScript
254 lines
8.3 KiB
TypeScript
import { crc32 } from "@add-ideas/toolbox-helpers";
|
|
import { zlibSync } from "fflate";
|
|
|
|
const encoder = new TextEncoder();
|
|
|
|
export function jpegFixture(options: { trailing?: boolean } = {}): Uint8Array {
|
|
const xmp = encoder.encode(
|
|
"http://ns.adobe.com/xap/1.0/\0" +
|
|
'<?xpacket begin=""><x:xmpmeta xmlns:x="adobe:ns:meta/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:exif="http://ns.adobe.com/exif/1.0/" xmlns:xmp="http://ns.adobe.com/xap/1.0/" xmlns:xmpMM="http://ns.adobe.com/xap/1.0/mm/"><rdf:RDF><rdf:Description><dc:creator>Alice Example</dc:creator><exif:GPSLatitude>48.1 N</exif:GPSLatitude><xmp:CreatorTool>Fixture Camera</xmp:CreatorTool><xmpMM:DocumentID>doc-123</xmpMM:DocumentID></rdf:Description></rdf:RDF></x:xmpmeta><?xpacket end="w"?>',
|
|
);
|
|
const jfif = concat(
|
|
encoder.encode("JFIF\0"),
|
|
bytes(1, 2, 0),
|
|
u16be(72),
|
|
u16be(72),
|
|
bytes(0, 0),
|
|
);
|
|
const iptc = concat(
|
|
iptcDataset(80, "Alice Reporter"),
|
|
iptcDataset(90, "Berlin"),
|
|
iptcDataset(120, "Private caption"),
|
|
);
|
|
const photoshop = concat(
|
|
encoder.encode("Photoshop 3.0\0"),
|
|
encoder.encode("8BIM"),
|
|
u16be(0x0404),
|
|
bytes(0, 0),
|
|
u32be(iptc.byteLength),
|
|
iptc,
|
|
iptc.byteLength % 2 ? bytes(0) : bytes(),
|
|
);
|
|
const body = concat(
|
|
bytes(0xff, 0xd8),
|
|
jpegSegment(0xe0, jfif),
|
|
jpegSegment(0xe1, concat(encoder.encode("Exif\0\0"), tiffFixture())),
|
|
jpegSegment(0xe1, xmp),
|
|
jpegSegment(
|
|
0xe2,
|
|
concat(
|
|
encoder.encode("ICC_PROFILE\0"),
|
|
bytes(1, 1),
|
|
encoder.encode("icc"),
|
|
),
|
|
),
|
|
jpegSegment(0xeb, encoder.encode("jumb/c2pa test manifest")),
|
|
jpegSegment(0xed, photoshop),
|
|
jpegSegment(0xfe, encoder.encode("private jpeg comment")),
|
|
jpegSegment(0xc0, bytes(8, 0, 2, 0, 3, 1, 1, 0x11, 0)),
|
|
bytes(0xff, 0xda, 0xff, 0xd9),
|
|
);
|
|
return options.trailing ? concat(body, encoder.encode("hidden")) : body;
|
|
}
|
|
|
|
export function pngFixture(
|
|
options: {
|
|
cycleTiff?: boolean;
|
|
inflatedCommentBytes?: number;
|
|
animated?: boolean;
|
|
trailing?: boolean;
|
|
} = {},
|
|
): Uint8Array {
|
|
const width = 2;
|
|
const height = 1;
|
|
const ihdr = concat(u32be(width), u32be(height), bytes(8, 6, 0, 0, 0));
|
|
const xmp = encoder.encode(
|
|
"XML:com.adobe.xmp\0\0\0\0\0" +
|
|
'<rdf:Description xmlns:rdf="urn:rdf"><dc:creator xmlns:dc="urn:dc">PNG Alice</dc:creator><xmp:CreatorTool xmlns:xmp="urn:xmp">PNG Fixture</xmp:CreatorTool></rdf:Description>',
|
|
);
|
|
const inflated = encoder.encode(
|
|
"x".repeat(options.inflatedCommentBytes ?? 32),
|
|
);
|
|
const scanline = bytes(0, 255, 0, 0, 255, 0, 0, 255, 255);
|
|
const chunks = [
|
|
pngChunk("IHDR", ihdr),
|
|
pngChunk("tEXt", encoder.encode("Author\0Alice PNG")),
|
|
pngChunk(
|
|
"zTXt",
|
|
concat(encoder.encode("Comment\0"), bytes(0), zlibSync(inflated)),
|
|
),
|
|
pngChunk("iTXt", xmp),
|
|
pngChunk("eXIf", tiffFixture({ cycle: options.cycleTiff })),
|
|
pngChunk(
|
|
"iCCP",
|
|
concat(
|
|
encoder.encode("fixture profile\0"),
|
|
bytes(0),
|
|
zlibSync(encoder.encode("ICC profile bytes")),
|
|
),
|
|
),
|
|
pngChunk("vpAg", encoder.encode("private ancillary data")),
|
|
...(options.animated ? [pngChunk("acTL", concat(u32be(2), u32be(0)))] : []),
|
|
pngChunk("IDAT", zlibSync(scanline)),
|
|
pngChunk("IEND", bytes()),
|
|
];
|
|
const image = concat(
|
|
bytes(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a),
|
|
...chunks,
|
|
);
|
|
return options.trailing
|
|
? concat(image, encoder.encode("trailing secret"))
|
|
: image;
|
|
}
|
|
|
|
export function webpFixture(options: { animated?: boolean } = {}): Uint8Array {
|
|
const vp8x = bytes(options.animated ? 0x02 : 0, 0, 0, 0, 3, 0, 0, 2, 0, 0);
|
|
const dimensions = 3 | (2 << 14);
|
|
const vp8l = concat(bytes(0x2f), u32le(dimensions));
|
|
const xmp = encoder.encode(
|
|
'<rdf:Description xmlns:rdf="urn:rdf"><dc:creator xmlns:dc="urn:dc">WebP Alice</dc:creator><exif:GPSLongitude xmlns:exif="urn:exif">13.4 E</exif:GPSLongitude></rdf:Description>',
|
|
);
|
|
const chunks = concat(
|
|
riffChunk("VP8X", vp8x),
|
|
riffChunk("VP8L", vp8l),
|
|
riffChunk("EXIF", concat(encoder.encode("Exif\0\0"), tiffFixture())),
|
|
riffChunk("XMP ", xmp),
|
|
riffChunk("ICCP", encoder.encode("ICC profile bytes")),
|
|
...(options.animated ? [riffChunk("ANIM", bytes(0, 0, 0, 0, 0, 0))] : []),
|
|
);
|
|
return concat(
|
|
encoder.encode("RIFF"),
|
|
u32le(chunks.byteLength + 4),
|
|
encoder.encode("WEBP"),
|
|
chunks,
|
|
);
|
|
}
|
|
|
|
export function tiffFixture(
|
|
options: { cycle?: boolean; orientation?: number } = {},
|
|
): Uint8Array {
|
|
const make = encoder.encode("CameraCo\0");
|
|
const date = encoder.encode("2026:09:01 12:34:56\0");
|
|
const gpsDate = encoder.encode("2026:09:01\0");
|
|
const mainOffset = 8;
|
|
const mainEntries = 4;
|
|
const mainEnd = mainOffset + 2 + mainEntries * 12;
|
|
const dataStart = mainEnd + 4;
|
|
const makeOffset = dataStart;
|
|
const dateOffset = makeOffset + make.byteLength;
|
|
const gpsOffset = dateOffset + date.byteLength;
|
|
const gpsEntries = 2;
|
|
const gpsEnd = gpsOffset + 2 + gpsEntries * 12;
|
|
const gpsDateOffset = gpsEnd + 4;
|
|
const result = new Uint8Array(gpsDateOffset + gpsDate.byteLength);
|
|
const view = new DataView(result.buffer);
|
|
result.set(bytes(0x49, 0x49), 0);
|
|
view.setUint16(2, 42, true);
|
|
view.setUint32(4, mainOffset, true);
|
|
view.setUint16(mainOffset, mainEntries, true);
|
|
writeIfdEntry(view, mainOffset + 2, 0x010f, 2, make.byteLength, makeOffset);
|
|
writeIfdEntry(view, mainOffset + 14, 0x0112, 3, 1, options.orientation ?? 1);
|
|
writeIfdEntry(view, mainOffset + 26, 0x0132, 2, date.byteLength, dateOffset);
|
|
writeIfdEntry(view, mainOffset + 38, 0x8825, 4, 1, gpsOffset);
|
|
view.setUint32(mainEnd, options.cycle ? mainOffset : 0, true);
|
|
result.set(make, makeOffset);
|
|
result.set(date, dateOffset);
|
|
view.setUint16(gpsOffset, gpsEntries, true);
|
|
writeIfdEntry(view, gpsOffset + 2, 1, 2, 2, 0x4e);
|
|
writeIfdEntry(view, gpsOffset + 14, 29, 2, gpsDate.byteLength, gpsDateOffset);
|
|
view.setUint32(gpsEnd, 0, true);
|
|
result.set(gpsDate, gpsDateOffset);
|
|
return result;
|
|
}
|
|
|
|
export function malformedPngLengthFixture(): Uint8Array {
|
|
const image = pngFixture();
|
|
const malformed = image.slice();
|
|
new DataView(malformed.buffer).setUint32(8, 0xfffffff0, false);
|
|
return malformed;
|
|
}
|
|
|
|
export function toArrayBuffer(value: Uint8Array): ArrayBuffer {
|
|
return value.slice().buffer as ArrayBuffer;
|
|
}
|
|
|
|
function jpegSegment(marker: number, payload: Uint8Array): Uint8Array {
|
|
return concat(bytes(0xff, marker), u16be(payload.byteLength + 2), payload);
|
|
}
|
|
|
|
function iptcDataset(dataset: number, value: string): Uint8Array {
|
|
const encoded = encoder.encode(value);
|
|
return concat(bytes(0x1c, 2, dataset), u16be(encoded.byteLength), encoded);
|
|
}
|
|
|
|
function pngChunk(type: string, data: Uint8Array): Uint8Array {
|
|
const typeBytes = encoder.encode(type);
|
|
const checksumInput = concat(typeBytes, data);
|
|
return concat(
|
|
u32be(data.byteLength),
|
|
checksumInput,
|
|
u32be(crc32(checksumInput, 16 * 1024 * 1024)),
|
|
);
|
|
}
|
|
|
|
function riffChunk(type: string, data: Uint8Array): Uint8Array {
|
|
return concat(
|
|
encoder.encode(type),
|
|
u32le(data.byteLength),
|
|
data,
|
|
data.byteLength % 2 ? bytes(0) : bytes(),
|
|
);
|
|
}
|
|
|
|
function writeIfdEntry(
|
|
view: DataView,
|
|
offset: number,
|
|
tag: number,
|
|
type: number,
|
|
count: number,
|
|
value: number,
|
|
): void {
|
|
view.setUint16(offset, tag, true);
|
|
view.setUint16(offset + 2, type, true);
|
|
view.setUint32(offset + 4, count, true);
|
|
if (type === 3 && count === 1) view.setUint16(offset + 8, value, true);
|
|
else view.setUint32(offset + 8, value, true);
|
|
}
|
|
|
|
function concat(...parts: readonly Uint8Array[]): Uint8Array {
|
|
const size = parts.reduce((total, part) => total + part.byteLength, 0);
|
|
const result = new Uint8Array(size);
|
|
let offset = 0;
|
|
for (const part of parts) {
|
|
result.set(part, offset);
|
|
offset += part.byteLength;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function bytes(...values: readonly number[]): Uint8Array {
|
|
return Uint8Array.from(values);
|
|
}
|
|
|
|
function u16be(value: number): Uint8Array {
|
|
return bytes((value >>> 8) & 0xff, value & 0xff);
|
|
}
|
|
|
|
function u32be(value: number): Uint8Array {
|
|
return bytes(
|
|
(value >>> 24) & 0xff,
|
|
(value >>> 16) & 0xff,
|
|
(value >>> 8) & 0xff,
|
|
value & 0xff,
|
|
);
|
|
}
|
|
|
|
function u32le(value: number): Uint8Array {
|
|
return bytes(
|
|
value & 0xff,
|
|
(value >>> 8) & 0xff,
|
|
(value >>> 16) & 0xff,
|
|
(value >>> 24) & 0xff,
|
|
);
|
|
}
|