317 lines
8.3 KiB
TypeScript
317 lines
8.3 KiB
TypeScript
import { inflateSync } from "node:zlib";
|
|
import * as jpeg from "jpeg-js";
|
|
|
|
export interface SpriteImage {
|
|
id: number;
|
|
name: string;
|
|
width: number;
|
|
height: number;
|
|
pixels: Buffer; // RGBA
|
|
}
|
|
|
|
// ── DefineBitsLossless2 Parser (with alpha) ──────────────────────
|
|
|
|
export function parseBitsLossless2(data: Buffer): {
|
|
id: number;
|
|
width: number;
|
|
height: number;
|
|
pixels: Buffer;
|
|
} {
|
|
let offset = 0;
|
|
const id = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
const format = data.readUInt8(offset);
|
|
offset += 1;
|
|
const width = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
const height = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
|
|
let colorTableSize = 0;
|
|
if (format === 3) {
|
|
colorTableSize = data.readUInt8(offset) + 1;
|
|
offset += 1;
|
|
}
|
|
|
|
const compressed = data.subarray(offset);
|
|
let decompressed: Buffer;
|
|
try {
|
|
decompressed = inflateSync(compressed);
|
|
} catch {
|
|
return { id, width, height, pixels: Buffer.alloc(width * height * 4) };
|
|
}
|
|
|
|
const pixels = Buffer.alloc(width * height * 4);
|
|
|
|
if (format === 5) {
|
|
let srcOff = 0;
|
|
for (let y = 0; y < height; y++) {
|
|
for (let x = 0; x < width; x++) {
|
|
if (srcOff + 3 >= decompressed.length) break;
|
|
const a = decompressed[srcOff];
|
|
let r = decompressed[srcOff + 1];
|
|
let g = decompressed[srcOff + 2];
|
|
let b = decompressed[srcOff + 3];
|
|
srcOff += 4;
|
|
|
|
// Un-premultiply alpha
|
|
if (a > 0 && a < 255) {
|
|
r = Math.min(255, Math.round((r * 255) / a));
|
|
g = Math.min(255, Math.round((g * 255) / a));
|
|
b = Math.min(255, Math.round((b * 255) / a));
|
|
}
|
|
|
|
const dstOff = (y * width + x) * 4;
|
|
pixels[dstOff] = r;
|
|
pixels[dstOff + 1] = g;
|
|
pixels[dstOff + 2] = b;
|
|
pixels[dstOff + 3] = a;
|
|
}
|
|
}
|
|
} else if (format === 3) {
|
|
const palette: number[][] = [];
|
|
let palOff = 0;
|
|
for (let i = 0; i < colorTableSize; i++) {
|
|
const a = decompressed[palOff];
|
|
let r = decompressed[palOff + 1];
|
|
let g = decompressed[palOff + 2];
|
|
let b = decompressed[palOff + 3];
|
|
// Un-premultiply alpha for palette entries (same as format 5)
|
|
if (a > 0 && a < 255) {
|
|
r = Math.min(255, Math.round((r * 255) / a));
|
|
g = Math.min(255, Math.round((g * 255) / a));
|
|
b = Math.min(255, Math.round((b * 255) / a));
|
|
}
|
|
palette.push([r, g, b, a]);
|
|
palOff += 4;
|
|
}
|
|
|
|
const rowPadded = Math.ceil(width / 4) * 4;
|
|
let srcOff = colorTableSize * 4;
|
|
for (let y = 0; y < height; y++) {
|
|
for (let x = 0; x < width; x++) {
|
|
const idx = decompressed[srcOff + x];
|
|
const color = palette[idx] || [0, 0, 0, 0];
|
|
const dstOff = (y * width + x) * 4;
|
|
pixels[dstOff] = color[0];
|
|
pixels[dstOff + 1] = color[1];
|
|
pixels[dstOff + 2] = color[2];
|
|
pixels[dstOff + 3] = color[3];
|
|
}
|
|
srcOff += rowPadded;
|
|
}
|
|
}
|
|
|
|
return { id, width, height, pixels };
|
|
}
|
|
|
|
// ── DefineBitsLossless Parser (without alpha) ──────────────────────
|
|
|
|
export function parseBitsLossless(data: Buffer): {
|
|
id: number;
|
|
width: number;
|
|
height: number;
|
|
pixels: Buffer;
|
|
} {
|
|
let offset = 0;
|
|
const id = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
const format = data.readUInt8(offset);
|
|
offset += 1;
|
|
const width = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
const height = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
|
|
let colorTableSize = 0;
|
|
if (format === 3) {
|
|
colorTableSize = data.readUInt8(offset) + 1;
|
|
offset += 1;
|
|
}
|
|
|
|
const compressed = data.subarray(offset);
|
|
let decompressed: Buffer;
|
|
try {
|
|
decompressed = inflateSync(compressed);
|
|
} catch {
|
|
return { id, width, height, pixels: Buffer.alloc(width * height * 4) };
|
|
}
|
|
|
|
const pixels = Buffer.alloc(width * height * 4);
|
|
|
|
if (format === 5) {
|
|
let srcOff = 0;
|
|
for (let y = 0; y < height; y++) {
|
|
for (let x = 0; x < width; x++) {
|
|
if (srcOff + 3 >= decompressed.length) break;
|
|
srcOff++; // skip padding byte
|
|
const r = decompressed[srcOff++];
|
|
const g = decompressed[srcOff++];
|
|
const b = decompressed[srcOff++];
|
|
const dstOff = (y * width + x) * 4;
|
|
pixels[dstOff] = r;
|
|
pixels[dstOff + 1] = g;
|
|
pixels[dstOff + 2] = b;
|
|
pixels[dstOff + 3] = 255;
|
|
}
|
|
}
|
|
} else if (format === 3) {
|
|
const palette: number[][] = [];
|
|
let palOff = 0;
|
|
for (let i = 0; i < colorTableSize; i++) {
|
|
const r = decompressed[palOff];
|
|
const g = decompressed[palOff + 1];
|
|
const b = decompressed[palOff + 2];
|
|
palette.push([r, g, b, 255]);
|
|
palOff += 3;
|
|
}
|
|
|
|
const rowPadded = Math.ceil(width / 4) * 4;
|
|
let srcOff = colorTableSize * 3;
|
|
for (let y = 0; y < height; y++) {
|
|
for (let x = 0; x < width; x++) {
|
|
const idx = decompressed[srcOff + x];
|
|
const color = palette[idx] || [0, 0, 0, 255];
|
|
const dstOff = (y * width + x) * 4;
|
|
pixels[dstOff] = color[0];
|
|
pixels[dstOff + 1] = color[1];
|
|
pixels[dstOff + 2] = color[2];
|
|
pixels[dstOff + 3] = color[3];
|
|
}
|
|
srcOff += rowPadded;
|
|
}
|
|
}
|
|
|
|
return { id, width, height, pixels };
|
|
}
|
|
|
|
// ── DefineBitsJpeg2 Parser (JPEG without alpha) ───────────────────
|
|
|
|
export function parseBitsJpeg2(
|
|
data: Buffer,
|
|
): { id: number; width: number; height: number; pixels: Buffer } | null {
|
|
if (data.length < 6) return null;
|
|
|
|
const id = data.readUInt16LE(0);
|
|
let jpegData = data.subarray(2);
|
|
|
|
// Strip erroneous JPEG header (FF D9 FF D1) if present
|
|
if (
|
|
jpegData.length >= 4 &&
|
|
jpegData[0] === 0xff &&
|
|
jpegData[1] === 0xd9 &&
|
|
jpegData[2] === 0xff &&
|
|
jpegData[3] === 0xd1
|
|
) {
|
|
jpegData = jpegData.subarray(4);
|
|
}
|
|
|
|
const dims = parseJpegDimensions(jpegData);
|
|
if (!dims) return null;
|
|
|
|
const pixels = decodeJpegToRGBA(jpegData, dims.width, dims.height);
|
|
return { id, width: dims.width, height: dims.height, pixels };
|
|
}
|
|
|
|
// ── DefineBitsJpeg3 Parser (JPEG with alpha channel) ──────────────
|
|
|
|
export function parseBitsJpeg3(
|
|
data: Buffer,
|
|
): { id: number; width: number; height: number; pixels: Buffer } | null {
|
|
if (data.length < 6) return null;
|
|
|
|
const id = data.readUInt16LE(0);
|
|
const alphaDataOffset = data.readUInt32LE(2);
|
|
let jpegData = data.subarray(6, 6 + alphaDataOffset);
|
|
|
|
// Strip erroneous JPEG header (FF D9 FF D1) if present
|
|
if (
|
|
jpegData.length >= 4 &&
|
|
jpegData[0] === 0xff &&
|
|
jpegData[1] === 0xd9 &&
|
|
jpegData[2] === 0xff &&
|
|
jpegData[3] === 0xd1
|
|
) {
|
|
jpegData = jpegData.subarray(4);
|
|
}
|
|
|
|
const dims = parseJpegDimensions(jpegData);
|
|
if (!dims) return null;
|
|
|
|
const pixels = decodeJpegToRGBA(jpegData, dims.width, dims.height);
|
|
|
|
// Apply zlib-compressed alpha channel
|
|
const compressedAlpha = data.subarray(6 + alphaDataOffset);
|
|
if (compressedAlpha.length > 0) {
|
|
try {
|
|
const alpha = inflateSync(compressedAlpha);
|
|
const pixelCount = dims.width * dims.height;
|
|
for (let i = 0; i < pixelCount && i < alpha.length; i++) {
|
|
pixels[i * 4 + 3] = alpha[i];
|
|
}
|
|
} catch {
|
|
// Alpha decompression failed, keep fully opaque
|
|
}
|
|
}
|
|
|
|
return { id, width: dims.width, height: dims.height, pixels };
|
|
}
|
|
|
|
// ── JPEG Dimension Parser (reads SOF0/SOF2 markers) ───────────────
|
|
|
|
export function parseJpegDimensions(
|
|
jpeg: Buffer,
|
|
): { width: number; height: number } | null {
|
|
let offset = 0;
|
|
while (offset < jpeg.length - 1) {
|
|
if (jpeg[offset] !== 0xff) {
|
|
offset++;
|
|
continue;
|
|
}
|
|
|
|
const marker = jpeg[offset + 1];
|
|
offset += 2;
|
|
|
|
// SOF0 (Baseline), SOF1 (Extended), SOF2 (Progressive)
|
|
if (marker >= 0xc0 && marker <= 0xc2) {
|
|
if (offset + 7 > jpeg.length) return null;
|
|
// Skip length (2 bytes) + precision (1 byte)
|
|
const height = jpeg.readUInt16BE(offset + 3);
|
|
const width = jpeg.readUInt16BE(offset + 5);
|
|
return { width, height };
|
|
}
|
|
|
|
// Skip non-SOF markers with length field
|
|
if (marker === 0xd8 || marker === 0xd9) continue; // SOI / EOI
|
|
if (marker >= 0xd0 && marker <= 0xd7) continue; // RST markers
|
|
if (offset + 2 > jpeg.length) break;
|
|
const segLen = jpeg.readUInt16BE(offset);
|
|
offset += segLen;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// ── JPEG to RGBA decoder using jpeg-js ──────────────────────────────
|
|
|
|
export function decodeJpegToRGBA(
|
|
jpegData: Buffer,
|
|
width: number,
|
|
height: number,
|
|
): Buffer {
|
|
try {
|
|
const decoded = jpeg.decode(jpegData, {
|
|
useTArray: true,
|
|
formatAsRGBA: true,
|
|
});
|
|
// jpeg-js returns RGBA data directly
|
|
return Buffer.from(
|
|
decoded.data.buffer,
|
|
decoded.data.byteOffset,
|
|
decoded.data.byteLength,
|
|
);
|
|
} catch {
|
|
// Fallback: transparent pixels if JPEG decode fails
|
|
return Buffer.alloc(width * height * 4);
|
|
}
|
|
}
|