// 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 }; }