diff --git a/apps/android/src/services/image-preview-metadata.ts b/apps/android/src/services/image-preview-metadata.ts new file mode 100644 index 0000000..6fec8c9 --- /dev/null +++ b/apps/android/src/services/image-preview-metadata.ts @@ -0,0 +1,155 @@ +export const MAX_IMAGE_DIMENSION = 8192 +export const MAX_IMAGE_PIXELS = 16_000_000 + +export type ImagePreviewMetadataResult = + | { ok: true; mimeType: string; width: number; height: number } + | { ok: false; reason: 'unsupported' } + | { ok: false; reason: 'invalid' } + | { ok: false; reason: 'too-large'; mimeType: string; width: number; height: number } + +const PNG_MAGIC = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] +const JPEG_SOF_MARKERS = new Set([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]) +const JPEG_STANDALONE_MARKERS = new Set([0x01, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]) +const WEBP_IMAGE_CHUNKS = new Set(['VP8 ', 'VP8L', 'VP8X']) +const MAX_JPEG_SEGMENTS = 512 +const MAX_WEBP_CHUNKS = 32 + +/** + * Compressed bytes can stay under the payload cap while still decoding into a + * huge bitmap, so the pixel budget is enforced from the header before rendering. + */ +export function imagePreviewMetadata(bytes: Uint8Array): ImagePreviewMetadataResult { + const mimeType = imageMagicMimeType(bytes) + if (mimeType === undefined) return { ok: false, reason: 'unsupported' } + const size = mimeType === 'image/png' + ? pngSize(bytes) + : mimeType === 'image/gif' + ? gifSize(bytes) + : mimeType === 'image/jpeg' + ? jpegSize(bytes) + : webpSize(bytes) + if (size === undefined) return { ok: false, reason: 'invalid' } + const [width, height] = size + if (width <= 0 || height <= 0) return { ok: false, reason: 'invalid' } + if (width > MAX_IMAGE_DIMENSION || height > MAX_IMAGE_DIMENSION || width * height > MAX_IMAGE_PIXELS) { + return { ok: false, reason: 'too-large', mimeType, width, height } + } + return { ok: true, mimeType, width, height } +} + +function imageMagicMimeType(bytes: Uint8Array): string | undefined { + if (startsWith(bytes, PNG_MAGIC)) return 'image/png' + if (bytes.byteLength >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return 'image/jpeg' + if (bytes.byteLength >= 6) { + const signature = ascii(bytes, 0, 6) + if (signature === 'GIF87a' || signature === 'GIF89a') return 'image/gif' + } + if (bytes.byteLength >= 12 && ascii(bytes, 0, 4) === 'RIFF' && ascii(bytes, 8, 12) === 'WEBP') return 'image/webp' + return undefined +} + +function pngSize(bytes: Uint8Array): [number, number] | undefined { + if (bytes.byteLength < 24 || ascii(bytes, 12, 16) !== 'IHDR') return undefined + return [readUint32BE(bytes, 16), readUint32BE(bytes, 20)] +} + +function gifSize(bytes: Uint8Array): [number, number] | undefined { + if (bytes.byteLength < 10) return undefined + return [readUint16LE(bytes, 6), readUint16LE(bytes, 8)] +} + +function jpegSize(bytes: Uint8Array): [number, number] | undefined { + let offset = 2 + for (let segment = 0; segment < MAX_JPEG_SEGMENTS && offset + 4 <= bytes.byteLength; segment += 1) { + if (bytes[offset] !== 0xff) return undefined + while (offset < bytes.byteLength && bytes[offset] === 0xff) offset += 1 + const marker = bytes[offset] as number + offset += 1 + if (JPEG_STANDALONE_MARKERS.has(marker)) continue + if (marker === 0xda || marker === 0xd9) return undefined + const length = readUint16BE(bytes, offset) + if (length < 2 || offset + length > bytes.byteLength) return undefined + if (JPEG_SOF_MARKERS.has(marker)) { + if (length < 7) return undefined + return [readUint16BE(bytes, offset + 5), readUint16BE(bytes, offset + 3)] + } + offset += length + } + return undefined +} + +function webpSize(bytes: Uint8Array): [number, number] | undefined { + let offset = 12 + for (let chunk = 0; chunk < MAX_WEBP_CHUNKS && offset + 8 <= bytes.byteLength; chunk += 1) { + const fourcc = ascii(bytes, offset, offset + 4) + const size = readUint32LE(bytes, offset + 4) + const payload = offset + 8 + if (size > bytes.byteLength - payload) return undefined + if (WEBP_IMAGE_CHUNKS.has(fourcc)) { + const dimensions = fourcc === 'VP8X' + ? webpExtendedSize(bytes, payload, size) + : fourcc === 'VP8L' + ? webpLosslessSize(bytes, payload, size) + : webpLossySize(bytes, payload, size) + return dimensions + } + offset = payload + size + (size % 2) + } + return undefined +} + +function webpLossySize(bytes: Uint8Array, payload: number, size: number): [number, number] | undefined { + if (size < 10 || bytes[payload + 3] !== 0x9d || bytes[payload + 4] !== 0x01 || bytes[payload + 5] !== 0x2a) return undefined + return [readUint16LE(bytes, payload + 6) & 0x3fff, readUint16LE(bytes, payload + 8) & 0x3fff] +} + +function webpLosslessSize(bytes: Uint8Array, payload: number, size: number): [number, number] | undefined { + if (size < 5 || bytes[payload] !== 0x2f) return undefined + const bits = readUint32LE(bytes, payload + 1) + return [(bits & 0x3fff) + 1, ((bits >>> 14) & 0x3fff) + 1] +} + +function webpExtendedSize(bytes: Uint8Array, payload: number, size: number): [number, number] | undefined { + if (size < 10) return undefined + return [readUint24LE(bytes, payload + 4) + 1, readUint24LE(bytes, payload + 7) + 1] +} + +function startsWith(bytes: Uint8Array, pattern: readonly number[]): boolean { + if (bytes.byteLength < pattern.length) return false + for (let index = 0; index < pattern.length; index += 1) { + if (bytes[index] !== pattern[index]) return false + } + return true +} + +function ascii(bytes: Uint8Array, start: number, end: number): string { + let value = '' + for (let index = start; index < end; index += 1) value += String.fromCharCode(bytes[index] as number) + return value +} + +function readUint16BE(bytes: Uint8Array, offset: number): number { + return ((bytes[offset] as number) << 8) | (bytes[offset + 1] as number) +} + +function readUint16LE(bytes: Uint8Array, offset: number): number { + return (bytes[offset] as number) | ((bytes[offset + 1] as number) << 8) +} + +function readUint24LE(bytes: Uint8Array, offset: number): number { + return (bytes[offset] as number) | ((bytes[offset + 1] as number) << 8) | ((bytes[offset + 2] as number) << 16) +} + +function readUint32LE(bytes: Uint8Array, offset: number): number { + return ((bytes[offset] as number) + | ((bytes[offset + 1] as number) << 8) + | ((bytes[offset + 2] as number) << 16) + | ((bytes[offset + 3] as number) << 24)) >>> 0 +} + +function readUint32BE(bytes: Uint8Array, offset: number): number { + return (((bytes[offset] as number) << 24) + | ((bytes[offset + 1] as number) << 16) + | ((bytes[offset + 2] as number) << 8) + | (bytes[offset + 3] as number)) >>> 0 +}