Import apps/android/src/services/image-preview-metadata.ts

This commit is contained in:
QQ 2026-11-14 14:17:53 +08:00
parent 63728e7acf
commit ffc5f49f9a
1 changed files with 155 additions and 0 deletions

View File

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