Download web/frames.js from devmandan/qr-scan-difficulty-check: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/web/frames.js
- Command line
-
hf download hf://spaces/devmandan/qr-scan-difficulty-check/web/frames.js
-
curl -L -o frames.js https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/web/frames.js
10.7 kB
| // A design test's simulated scans, rebuilt in this browser exactly as the server's scanners read them. For each scene: | |
| // its facts (the box where the plain code's frame differs from the design's, and both frames' SHA-256), the design's | |
| // capture JPEG, decoded by this browser and shrunk to the 1280 x 960 grey frame by the whole-number rule, and the | |
| // plain code's patch pasted over a copy of that frame. A frame whose SHA-256 isn't the server's comes again as PNG. | |
| // Pixels are read back through an OffscreenCanvas that is never shown: no frame is shown, sent or kept. | |
| export const CAPTURE = [1920, 1440]; // a scene's capture, as its JPEG comes | |
| export const FRAME = [1280, 960]; // the grey frame every scanner reads: the shrink below is exact for these two sizes | |
| const [CW, CH] = CAPTURE; | |
| const [FW, FH] = FRAME; | |
| const HEX = /^[0-9a-f]{64}$/; | |
| const hex = (buf) => Array.from(new Uint8Array(buf), (b) => b.toString(16).padStart(2, '0')).join(''); | |
| /** The SHA-256 of some bytes, in lower-case hex. */ | |
| export const sha256Hex = async (bytes) => hex(await crypto.subtle.digest('SHA-256', bytes)); | |
| /** An error that says how the browser's part ends: 'stopped', 'slow', 'dropped' or 'aborted'. */ | |
| export const ending = (end) => Object.assign(new Error(end), { end }); | |
| /** An AbortController that aborts with signal too (each request its own, so one can be aborted alone). */ | |
| export function linked(signal) { | |
| const ctl = new AbortController(); | |
| if (signal.aborted) ctl.abort(); | |
| else signal.addEventListener('abort', () => ctl.abort(), { once: true }); | |
| return ctl; | |
| } | |
| /** Wait ms, or reject as 'aborted' once signal aborts. */ | |
| export const sleep = (ms, signal) => new Promise((resolve, reject) => { | |
| if (signal.aborted) { reject(ending('aborted')); return; } | |
| const id = setTimeout(resolve, ms); | |
| signal.addEventListener('abort', () => { clearTimeout(id); reject(ending('aborted')); }, { once: true }); | |
| }); | |
| let away = 0; // ms this page spent frozen before `since`, which the pictures' budget leaves out (get) | |
| let since = null; // when the page was frozen, while it still is | |
| /** test.js, on the page's freeze and resume: whether the page is frozen now (it doesn't run). A page hidden but | |
| * running isn't away: it keeps fetching at the link's own pace. */ | |
| export function hidden(now) { | |
| if (now && since === null) since = performance.now(); | |
| if (!now && since !== null) { | |
| away += performance.now() - since; | |
| since = null; | |
| } | |
| } | |
| const awayMs = () => away + (since === null ? 0 : performance.now() - since); | |
| const contexts = new Map(); // a 2D context for each full size, reused; a fresh one for any other size | |
| function contextFor(w, h) { | |
| const key = `${w}x${h}`; | |
| if (contexts.has(key)) return contexts.get(key); | |
| const ctx = new OffscreenCanvas(w, h).getContext('2d', { willReadFrequently: true }); | |
| if ((w === CW && h === CH) || (w === FW && h === FH)) contexts.set(key, ctx); | |
| return ctx; | |
| } | |
| /** A picture's pixels as one grey byte each, its red channel (every test picture is grey), decoded by this browser: | |
| * createImageBitmap, drawn into an OffscreenCanvas made for frequent reads, read back with getImageData. Throws when | |
| * it doesn't decode, or not at w x h. */ | |
| export async function decodeGrey(bytes, type, w, h) { | |
| const bitmap = await createImageBitmap(new Blob([bytes], { type })); | |
| try { | |
| if (bitmap.width !== w || bitmap.height !== h) throw new Error(`decoded at ${bitmap.width} x ${bitmap.height}`); | |
| const ctx = contextFor(w, h); | |
| ctx.clearRect(0, 0, w, h); | |
| ctx.drawImage(bitmap, 0, 0); | |
| const rgba = ctx.getImageData(0, 0, w, h).data; | |
| const grey = new Uint8Array(w * h); | |
| for (let i = 0, j = 0; i < grey.length; i += 1, j += 4) grey[i] = rgba[j]; | |
| return grey; | |
| } finally { | |
| bitmap.close(); | |
| } | |
| } | |
| /** The whole-number shrink, 1920 x 1440 to 1280 x 960, as the server makes its frames (equal to OpenCV's INTER_AREA | |
| * at this size): on each axis, output i reads source (3i + 1) >> 1 with weight 2/3 and 3 (i >> 1) + 1 with weight | |
| * 1/3, so frame = (4a + 2b + 2c + d + 4) div 9, with a weighted 2/3 both ways and d 1/3 both ways. */ | |
| export function shrink(cap) { | |
| const out = new Uint8Array(FW * FH); | |
| for (let y = 0; y < FH; y += 1) { | |
| const r2 = ((3 * y + 1) >> 1) * CW; | |
| const r1 = (3 * (y >> 1) + 1) * CW; | |
| for (let x = 0; x < FW; x += 1) { | |
| const c2 = (3 * x + 1) >> 1; | |
| const c1 = 3 * (x >> 1) + 1; | |
| out[y * FW + x] = ((4 * cap[r2 + c2] + 2 * cap[r2 + c1] + 2 * cap[r1 + c2] + cap[r1 + c1] + 4) / 9) | 0; | |
| } | |
| } | |
| return out; | |
| } | |
| /** A copy of the design's frame with the plain code's patch (h rows of w bytes) written at (x, y): the plain code's | |
| * frame. Throws when the box isn't inside the frame, or the patch isn't the box's size. */ | |
| export function paste(base, patch, box) { | |
| const [x, y, w, h] = box; | |
| if (!(x >= 0 && y >= 0 && w > 0 && h > 0 && x + w <= FW && y + h <= FH) || patch.length !== w * h) { | |
| throw new Error('the patch doesn’t fit'); | |
| } | |
| const out = new Uint8Array(base); | |
| for (let r = 0; r < h; r += 1) out.set(patch.subarray(r * w, (r + 1) * w), (y + r) * FW + x); | |
| return out; | |
| } | |
| /** An ImageBitmap of grey bytes (w x h) with every alpha 255: what the browser's scanner reads. */ | |
| export function toBitmap(grey, w, h) { | |
| const rgba = new Uint8ClampedArray(w * h * 4); | |
| for (let i = 0, j = 0; i < grey.length; i += 1, j += 4) { | |
| rgba[j] = grey[i]; | |
| rgba[j + 1] = grey[i]; | |
| rgba[j + 2] = grey[i]; | |
| rgba[j + 3] = 255; | |
| } | |
| return createImageBitmap(new ImageData(rgba, w, h)); | |
| } | |
| /** One of a scene's routes, as JSON or (picture) as bytes. A 503 (the scene isn't rendered yet) is asked again after | |
| * meter.wait and isn't a failure; a 404 means the server no longer has the test; any other failure is tried again up | |
| * to meter.tries in all, then stops the browser's part. A picture counts its bytes and the time it took, from the | |
| * request to its last byte, in the budget (meter.ms; 503s aside), and ends the part as 'slow' when the budget's | |
| * time (meter.limit) runs out while it comes; the time the page spent frozen meanwhile counts in neither. | |
| * A scene's facts that haven't come within meter.hold (longer than the server ever holds the request) count as a | |
| * failed fetch. */ | |
| async function get(url, signal, meter, picture) { | |
| for (let fails = 0; ;) { | |
| if (signal.aborted) throw ending('aborted'); | |
| const ctl = linked(signal); | |
| let slow = false; | |
| const limit = picture ? Math.max(0, meter.limit - meter.ms) : meter.hold; | |
| const t0 = performance.now(); | |
| const a0 = awayMs(); | |
| const took = () => performance.now() - t0 - (picture ? awayMs() - a0 : 0); | |
| let timer = 0; | |
| const due = () => { // past the limit by the page's own time; set again for the time it spent away | |
| if (took() < limit) timer = setTimeout(due, limit - took()); | |
| else { slow = picture; ctl.abort(); } | |
| }; | |
| timer = setTimeout(due, limit); | |
| let res = null; | |
| let body = null; | |
| try { | |
| res = await fetch(url, { cache: 'no-store', signal: ctl.signal }); | |
| if (res.ok) body = picture ? new Uint8Array(await res.arrayBuffer()) : await res.json(); | |
| } catch { /* a failed fetch, or aborted: below */ } | |
| clearTimeout(timer); | |
| if (picture && res?.status !== 503) meter.ms += took(); | |
| if (slow) throw ending('slow'); | |
| if (signal.aborted) throw ending('aborted'); | |
| if (body) { | |
| if (picture) meter.bytes += body.length; | |
| return body; | |
| } | |
| if (res?.status === 404) throw ending('dropped'); | |
| if (res?.status === 503) await sleep(meter.wait, signal); | |
| else if ((fails += 1) >= meter.tries) throw ending('stopped'); | |
| } | |
| } | |
| /** The scene's facts: the box (an empty box when the two frames are the same) and both frames' SHA-256. */ | |
| function factsOf(j) { | |
| const box = j?.box; | |
| const ok = Array.isArray(box) && box.length === 4 && box.every((v) => Number.isInteger(v) && v >= 0); | |
| if (!ok || !HEX.test(j.sha256?.plain) || !HEX.test(j.sha256?.design)) throw ending('stopped'); | |
| return { box, empty: box[2] === 0 || box[3] === 0, plain: j.sha256.plain, design: j.sha256.design }; | |
| } | |
| /** Decoded grey bytes, or null when this browser doesn't decode the picture at that size. */ | |
| async function grey(bytes, type, w, h, signal) { | |
| let out = null; | |
| try { out = await decodeGrey(bytes, type, w, h); } catch { /* checked as a failed frame */ } | |
| if (signal.aborted) throw ending('aborted'); | |
| return out; | |
| } | |
| const same = async (frame, want) => Boolean(frame) && (await sha256Hex(frame)) === want; | |
| /** A frame fetched as PNG (k = 2s for the plain code's, 2s + 1 for the design's), which must pass its check, or the | |
| * browser's part stops. */ | |
| async function pngFrame(base, k, want, signal, meter) { | |
| const frame = await grey(await get(`${base}/frame/${k}`, signal, meter, true), 'image/png', FW, FH, signal); | |
| if (!(await same(frame, want))) throw ending('stopped'); | |
| return frame; | |
| } | |
| /** One scene's two frames, rebuilt and checked against the server's SHA-256: { plain, design } (1280 x 960 grey bytes | |
| * each) and switched, true when a frame failed its check (the rest of the test then takes PNG frames). mode 'jpeg' | |
| * rebuilds the design's frame from its capture JPEG, and 'png' fetches it as PNG, as it does for a JPEG frame that | |
| * fails. The plain code's frame is its patch over the design's (the design's own for an empty box), and comes as | |
| * PNG when that fails. meter: the budget's count and the fetches' limits (scanner.js: bytes, ms, scenes, limit, | |
| * tries, wait and hold). Throws ending(...) as get() and pngFrame() do. */ | |
| export async function fetchScene(base, s, mode, signal, meter) { | |
| const f = factsOf(await get(`${base}/scene/${s}`, signal, meter, false)); | |
| let switched = false; | |
| let design = null; | |
| if (mode === 'jpeg') { | |
| const cap = await grey(await get(`${base}/scene/${s}/jpeg`, signal, meter, true), 'image/jpeg', CW, CH, signal); | |
| design = cap && shrink(cap); | |
| if (!(await same(design, f.design))) { | |
| design = null; | |
| switched = true; | |
| } | |
| } | |
| design ||= await pngFrame(base, 2 * s + 1, f.design, signal, meter); | |
| let plain = f.empty && f.plain === f.design ? design : null; | |
| if (!f.empty) { | |
| const [, , w, h] = f.box; | |
| const patch = await grey(await get(`${base}/scene/${s}/patch`, signal, meter, true), 'image/png', w, h, signal); | |
| try { plain = patch && paste(design, patch, f.box); } catch { /* a box outside the frame: checked as failed */ } | |
| if (!(await same(plain, f.plain))) plain = null; | |
| } | |
| if (!plain) { | |
| switched = true; | |
| plain = await pngFrame(base, 2 * s, f.plain, signal, meter); | |
| } | |
| meter.scenes += 1; | |
| return { plain, design, switched }; | |
| } | |