Spaces:
Running
Running
| // Image size from the file header, without decoding: PNG, JPEG (with EXIF orientation) and WebP. | |
| // Anything else (GIF, BMP, HEIC, AVIF, …) returns null and is refused before any decoding. | |
| // Returns { width, height, format, rotated } with width/height as displayed (after EXIF rotation), or null. | |
| const HEAD_BYTES = 512 * 1024; | |
| export async function readImageInfo(file) { | |
| const buf = new Uint8Array(await file.slice(0, HEAD_BYTES).arrayBuffer()); | |
| return png(buf) ?? jpeg(buf) ?? webp(buf); | |
| } | |
| const u16be = (b, i) => (b[i] << 8) | b[i + 1]; | |
| const u16le = (b, i) => b[i] | (b[i + 1] << 8); | |
| const u32be = (b, i) => ((b[i] << 24) | (b[i + 1] << 16) | (b[i + 2] << 8) | b[i + 3]) >>> 0; | |
| const u32le = (b, i) => (b[i] | (b[i + 1] << 8) | (b[i + 2] << 16) | (b[i + 3] << 24)) >>> 0; | |
| const ascii = (b, i, n) => String.fromCharCode(...b.subarray(i, i + n)); | |
| function result(width, height, format, orientation = 1) { | |
| if (!width || !height) return null; | |
| const rotated = orientation >= 5 && orientation <= 8; | |
| return { width: rotated ? height : width, height: rotated ? width : height, format, rotated }; | |
| } | |
| function png(b) { | |
| if (b.length < 24 || u32be(b, 0) !== 0x89504e47 || ascii(b, 12, 4) !== "IHDR") return null; | |
| let at = 8; | |
| while (at + 8 <= b.length) { | |
| const len = u32be(b, at); | |
| const type = ascii(b, at + 4, 4); | |
| if (type === "acTL") return { ...result(u32be(b, 16), u32be(b, 20), "png"), animated: true }; | |
| if (type === "IDAT") return result(u32be(b, 16), u32be(b, 20), "png"); | |
| at += 12 + len; | |
| } | |
| return null; | |
| } | |
| function exifOrientation(b, start, len) { | |
| if (ascii(b, start, 4) !== "Exif") return 1; | |
| const tiff = start + 6; | |
| if (tiff + 8 > b.length) return 1; | |
| const little = ascii(b, tiff, 2) === "II"; | |
| const r16 = (i) => (little ? u16le(b, i) : u16be(b, i)); | |
| const r32 = (i) => (little ? u32le(b, i) : u32be(b, i)); | |
| const ifd = tiff + r32(tiff + 4); | |
| if (ifd + 2 > Math.min(b.length, start + len)) return 1; | |
| const count = r16(ifd); | |
| for (let k = 0; k < count; k++) { | |
| const e = ifd + 2 + k * 12; | |
| if (e + 12 > b.length) break; | |
| if (r16(e) === 0x0112) return r16(e + 8) || 1; | |
| } | |
| return 1; | |
| } | |
| function jpeg(b) { | |
| if (b.length < 4 || b[0] !== 0xff || b[1] !== 0xd8) return null; | |
| let at = 2; | |
| let orientation = 1; | |
| while (at + 4 <= b.length) { | |
| if (b[at] !== 0xff) return null; | |
| const marker = b[at + 1]; | |
| if (marker === 0xd8 || (marker >= 0xd0 && marker <= 0xd7) || marker === 0x01) { | |
| at += 2; | |
| continue; | |
| } | |
| const len = u16be(b, at + 2); | |
| if (marker === 0xe1) orientation = exifOrientation(b, at + 4, len - 2); | |
| const isSof = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc; | |
| if (isSof && at + 9 <= b.length) return result(u16be(b, at + 7), u16be(b, at + 5), "jpeg", orientation); | |
| at += 2 + len; | |
| } | |
| return null; | |
| } | |
| function webp(b) { | |
| if (b.length < 30 || ascii(b, 0, 4) !== "RIFF" || ascii(b, 8, 4) !== "WEBP") return null; | |
| const kind = ascii(b, 12, 4); | |
| if (kind === "VP8 ") return result(u16le(b, 26) & 0x3fff, u16le(b, 28) & 0x3fff, "webp"); | |
| if (kind === "VP8L") { | |
| const bits = u32le(b, 21); | |
| return result((bits & 0x3fff) + 1, ((bits >> 14) & 0x3fff) + 1, "webp"); | |
| } | |
| if (kind === "VP8X") { | |
| const animated = (b[20] & 0x02) !== 0; | |
| const w = 1 + (b[24] | (b[25] << 8) | (b[26] << 16)); | |
| const h = 1 + (b[27] | (b[28] << 8) | (b[29] << 16)); | |
| return { ...result(w, h, "webp"), animated }; | |
| } | |
| return null; | |
| } | |