304 lines
8.7 KiB
TypeScript
304 lines
8.7 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)
|
|
}
|
|
}
|