@swf2es/player 0.0.0-stage → 0.1.1

package/src/bitmap/ops.ts

@@ -0,0 +1,1608 @@
+// The pixel operations of BitmapData that read and write its store alone
+// (bitmap.ts): each on unmultiplied ARGB as Flash's results show it works,
+// the store premultiplying again as it writes. The rules are the ones
+// Flash traces under adl and records in Ruffle's corpus.
+import {
+  type CopyOp,
+  DRAW_OPAQUE,
+  DRAW_SKIP_ZERO_ALPHA,
+  DRAW_SMOOTH,
+  DRAW_TRANSFORM,
+  DrawKernel,
+} from "@swf2es/native/render";
+import { BitmapStore, over, type PixelRect, premultiply, unmultiply } from "./bitmap.js";
+import { bitmapKernel, drawKernel } from "./kernel.js";
+import { perlinSetup } from "./turbulence.js";
+
+const M = 2147483647;
+
+/**
+ * Flash's noise generator's first state: Park-Miller's minimal standard,
+ * x * 16807 mod 2^31 - 1, a seed of 0 taken as 1 and one under 0 as
+ * -seed + 1 (all 25 pixels Ruffle's bitmapdata_getvector records of
+ * noise(0) match). The render module draws from it (pixels.zig).
+ */
+function noiseState(seed: number): number {
+  let s = seed | 0;
+  if (s <= 0) {
+    s = -s + 1;
+  }
+
+  return s % M || 1;
+}
+
+/**
+ * noise: each pixel's channels drawn in R, G, B order, then alpha, which
+ * only a transparent bitmap draws; a grayscale draw is one for all three
+ * colours, then alpha. A value is low + r % (high - low + 1), high capped
+ * at 255 and a range upside down giving low. A colour left out is 0, an
+ * alpha left out 255.
+ */
+export function noise(
+  store: BitmapStore,
+  seed: number,
+  low: number,
+  high: number,
+  channels: number,
+  gray: boolean,
+): void {
+  const lo = Math.max(0, Math.min(255, low));
+  const hi = Math.max(0, Math.min(255, high));
+  bitmapKernel()?.noise(
+    store.pixels,
+    noiseState(seed),
+    lo,
+    hi - lo + 1,
+    channels & 15,
+    gray,
+    store.transparent,
+  );
+  store.changed();
+}
+
+/** The channel's shift in ARGB: 1 red, 2 green, 4 blue, 8 alpha; -1 for another value. */
+function shiftOf(channel: number): number {
+  switch (channel) {
+    case 1:
+      return 16;
+    case 2:
+      return 8;
+    case 4:
+      return 0;
+    case 8:
+      return 24;
+    default:
+      return -1;
+  }
+}
+
+/** Each destination pixel's channel set from the source pixel's channel, both unmultiplied. */
+export function copyChannel(
+  store: BitmapStore,
+  source: BitmapStore,
+  rect: PixelRect,
+  dx: number,
+  dy: number,
+  from: number,
+  to: number,
+): void {
+  const fromShift = shiftOf(from);
+  const toShift = shiftOf(to);
+  if (toShift < 0 || (toShift === 24 && !store.transparent)) {
+    return;
+  }
+
+  // A source of more than one channel, or none, copies 0, as Flash does.
+  copied(store, source, rect, dx, dy, { op: "channel", from: fromShift, to: toShift });
+}
+
+/**
+ * colorTransform as Flash computes it, fitted under adl: each channel read
+ * back as p * 255 / a, floored; then (c * floor(mul * 256) >> 8) +
+ * trunc(offset), clamped to 0..255, the alpha alike; and written
+ * premultiplied as c * (a + 1) >> 8, not as setPixel32 rounds. A pixel
+ * of alpha 0 is left as it is; an opaque bitmap's alpha is transformed
+ * like a transparent one's.
+ */
+export function colorTransform(
+  store: BitmapStore,
+  rect: PixelRect,
+  ct: {
+    rMul: number;
+    gMul: number;
+    bMul: number;
+    aMul: number;
+    rAdd: number;
+    gAdd: number;
+    bAdd: number;
+    aAdd: number;
+  },
+): void {
+  const c = store.clip(rect);
+  if (!c) {
+    return;
+  }
+
+  const fixed = (m: number) => Math.trunc(m * 256);
+  const muls = [ct.rMul, ct.gMul, ct.bMul, ct.aMul].map(fixed);
+  const adds = [ct.rAdd, ct.gAdd, ct.bAdd, ct.aAdd].map(Math.trunc);
+  bitmapKernel()?.transform(store.pixels, store.width, c, muls, adds);
+  store.changed();
+}
+
+/**
+ * merge: each channel ((s * m + d * (256 - m)) >> 8) & 0xFF, unmultiplied,
+ * the multiplier a uint and nothing clamped, as 18 multipliers from -257
+ * to 2^32 - 1 show Flash computing it under adl; a double holds the
+ * product, so the shift is a division.
+ */
+export function merge(
+  store: BitmapStore,
+  source: BitmapStore,
+  rect: PixelRect,
+  dx: number,
+  dy: number,
+  muls: [number, number, number, number],
+): void {
+  copied(store, source, rect, dx, dy, { op: "merge", muls });
+}
+
+/**
+ * The source rect's pixels against the destination's at the point, both
+ * clipped and unmultiplied, each destination pixel made by `op` of the
+ * pair (pixel-ops.ts). In place, rows down and pixels along, each read as
+ * the ones before it left it, as Flash does: a move down or right repeats
+ * what it wrote.
+ */
+function copied(
+  store: BitmapStore,
+  source: BitmapStore,
+  rect: PixelRect,
+  dx: number,
+  dy: number,
+  op: CopyOp,
+): void {
+  const s = source.clip(rect);
+  if (!s) {
+    return;
+  }
+
+  dx += s.x - rect.x;
+  dy += s.y - rect.y;
+  const d = store.clip({ x: dx, y: dy, width: s.width, height: s.height });
+  if (!d) {
+    return;
+  }
+
+  // The store written first: if it is the source, both are then its own array.
+  const into = store.pixels;
+  const from = source.readable;
+  const sx = s.x + (d.x - dx);
+  const sy = s.y + (d.y - dy);
+  bitmapKernel()?.copy(into, store.width, from, source.width, d, sx, sy, store.transparent, op);
+  store.changed();
+}
+
+/**
+ * paletteMap: each copied pixel the sum of its channels' entries in the
+ * four tables, red, green, blue and alpha, wrapping at 32 bits, as Flash
+ * makes it (Ruffle's operations.rs); a table not given maps its channel
+ * to itself.
+ */
+export function paletteMap(
+  store: BitmapStore,
+  source: BitmapStore,
+  rect: PixelRect,
+  dx: number,
+  dy: number,
+  tables: readonly [Uint32Array, Uint32Array, Uint32Array, Uint32Array],
+): void {
+  copied(store, source, rect, dx, dy, { op: "palette", tables });
+}
+
+/**
+ * compare's differing pixels, null where none differ: 0 for a pixel the
+ * same in both, the colours' differences, opaque, where they differ, else
+ * the alphas' difference in every channel (Ruffle's operations.rs).
+ */
+export function comparePixels(left: BitmapStore, right: BitmapStore): Uint32Array | null {
+  const out = new Uint32Array(left.width * left.height);
+  let different = false;
+  for (let i = 0; i < out.length; i++) {
+    const p = left.unmultiplied(left.readable[i]);
+    const q = right.unmultiplied(right.readable[i]);
+    if (p === q) {
+      continue;
+    }
+
+    different = true;
+    if ((p & 0xffffff) !== (q & 0xffffff)) {
+      out[i] =
+        (0xff000000 |
+          ((((p >>> 16) - (q >>> 16)) & 0xff) << 16) |
+          ((((p >>> 8) - (q >>> 8)) & 0xff) << 8) |
+          ((p - q) & 0xff)) >>>
+        0;
+    } else {
+      const alpha = ((p >>> 24) - (q >>> 24)) & 0xff;
+      out[i] = ((alpha << 24) | (alpha << 16) | (alpha << 8) | alpha) >>> 0;
+    }
+  }
+
+  return different ? out : null;
+}
+
+/**
+ * perlinNoise: each pixel's channels from turbulence.ts, a channel left
+ * out its least, alpha left out opaque, written as they come, not
+ * premultiplied, as Flash writes them (Ruffle's operations.rs, whose
+ * conversion to a byte is Flash's). A channel's noise is drawn from the
+ * next of the generator's four only for the channels asked for.
+ */
+export function perlinNoise(
+  store: BitmapStore,
+  base: [number, number],
+  offsets: readonly [number, number][],
+  seed: number,
+  stitch: boolean,
+  fractal: boolean,
+  channels: number,
+  gray: boolean,
+): void {
+  const { width, height } = store;
+  // A base's sign is dropped (adl).
+  const frequency: [number, number] = [
+    base[0] === 0 ? 0 : 1 / Math.abs(base[0]),
+    base[1] === 0 ? 0 : 1 / Math.abs(base[1]),
+  ];
+  bitmapKernel()?.perlin(store.pixels, width, {
+    ...perlinSetup(seed, frequency, stitch, width, height),
+    offsets,
+    fractal,
+    channels: channels & 15,
+    gray,
+    transparent: store.transparent,
+  });
+  store.changed();
+}
+
+/** scroll: the pixels moved by (x, y); what nothing moved onto keeps its old pixels. */
+export function scroll(store: BitmapStore, x: number, y: number): void {
+  const { width, height } = store;
+  // Nothing moves: the pixels are left where they are, on the GPU or not, and
+  // a GPU copy that holds the newest stays current, or the next move on it
+  // would bring the store back and leave the CPU's copy behind.
+  if (x === 0 && y === 0) {
+    if (!store.onGpu(() => true)) {
+      store.changed();
+    }
+
+    return;
+  }
+
+  // The pixels that stay within the store, moved on the GPU where it holds the newest.
+  const moved = store.clip({ x: -x, y: -y, width, height });
+  if (store.onGpu((copy) => !moved || copy.copy(store, moved, moved.x + x, moved.y + y))) {
+    return;
+  }
+
+  const old = store.pixels.slice();
+  for (let row = 0; row < height; row++) {
+    const sy = row - y;
+    if (sy < 0 || sy >= height) {
+      continue;
+    }
+
+    for (let col = 0; col < width; col++) {
+      const sx = col - x;
+      if (sx >= 0 && sx < width) {
+        store.pixels[row * width + col] = old[sy * width + sx];
+      }
+    }
+  }
+
+  store.changed();
+}
+
+const OPERATIONS: Record<string, (a: number, b: number) => boolean> = {
+  "<": (a, b) => a < b,
+  "<=": (a, b) => a <= b,
+  ">": (a, b) => a > b,
+  ">=": (a, b) => a >= b,
+  "==": (a, b) => a === b,
+  "!=": (a, b) => a !== b,
+};
+
+/** Whether `op` is one threshold takes. */
+export function isThresholdOperation(op: string): boolean {
+  // Its own keys only: "constructor" and the rest of Object's are not operations.
+  return Object.hasOwn(OPERATIONS, op);
+}
+
+/**
+ * threshold: each source pixel, unmultiplied and masked, compared with the
+ * masked threshold as unsigned numbers; where the test holds the
+ * destination pixel becomes `color`, elsewhere the source pixel if
+ * `copySource`; how many held. With `premultiplied`, as AVM1's
+ * BitmapData has it (Ruffle's operations.rs), the pixel is compared as it
+ * is kept, premultiplied, and `color` and the source pixel are written as
+ * a transparent bitmap keeps them, the colour's channels premultiplied by
+ * its alpha. Flash leaves an opaque bitmap's alpha as written there too,
+ * which its getPixel32 then reads; here an opaque store keeps every alpha
+ * at 255, which its drawing, copies and filters take it to have, so its
+ * getPixel32 alone differs from Flash's (its getPixel does not).
+ */
+export function threshold(
+  store: BitmapStore,
+  source: BitmapStore,
+  rect: PixelRect,
+  dx: number,
+  dy: number,
+  op: string,
+  value: number,
+  color: number,
+  mask: number,
+  copySource: boolean,
+  premultiplied = false,
+): number {
+  const test = OPERATIONS[op];
+  const target = (value & mask) >>> 0;
+  let count = 0;
+  const s = source.clip(rect);
+  if (!s) {
+    return 0;
+  }
+
+  dx += s.x - rect.x;
+  dy += s.y - rect.y;
+  const d = store.clip({ x: dx, y: dy, width: s.width, height: s.height });
+  if (!d) {
+    return 0;
+  }
+
+  const sx = s.x + (d.x - dx);
+  const sy = s.y + (d.y - dy);
+  // In place, each pixel read as the ones before it left it (copied).
+  const into = store.pixels;
+  const pixels = source.readable;
+  const opaque = store.transparent ? 0 : 0xff000000;
+  const fill = premultiplied
+    ? (premultiply(color >>> 0) | opaque) >>> 0
+    : store.premultiplied(color >>> 0);
+  for (let row = 0; row < d.height; row++) {
+    for (let i = 0; i < d.width; i++) {
+      const to = (d.y + row) * store.width + d.x + i;
+      const raw = pixels[(sy + row) * source.width + sx + i];
+      if (test(((premultiplied ? raw : unmultiply(raw)) & mask) >>> 0, target)) {
+        into[to] = fill;
+        count++;
+      } else if (copySource) {
+        into[to] = (raw | opaque) >>> 0;
+      }
+    }
+  }
+
+  store.changed();
+  return count;
+}
+
+/**
+ * getColorBoundsRect: the smallest rect holding every pixel whose
+ * unmultiplied value, masked, is `color` (or is not, without findColor);
+ * empty where none is, and where the one found is the pixel at the
+ * origin alone, as Flash has it (Ruffle's bitmap_data). With
+ * `premultiplied`, as AVM1's BitmapData has it (Ruffle's operations.rs),
+ * the pixel is compared as it is kept, premultiplied, masked, with the
+ * colour premultiplied and not masked, and an opaque bitmap's alpha is
+ * in the mask.
+ */
+export function colorBounds(
+  store: BitmapStore,
+  mask: number,
+  color: number,
+  find: boolean,
+  premultiplied = false,
+): PixelRect {
+  let x0 = store.width;
+  let y0 = store.height;
+  let x1 = -1;
+  let y1 = -1;
+  if (premultiplied && !store.transparent) {
+    mask = (mask | 0xff000000) >>> 0;
+  }
+
+  const target = premultiplied ? store.premultiplied(color >>> 0) : (color & mask) >>> 0;
+  for (let y = 0; y < store.height; y++) {
+    for (let x = 0; x < store.width; x++) {
+      const pixel = store.pixels[y * store.width + x];
+      const hit = ((premultiplied ? pixel : unmultiply(pixel)) & mask) >>> 0 === target;
+      if (hit === find) {
+        x0 = Math.min(x0, x);
+        y0 = Math.min(y0, y);
+        x1 = Math.max(x1, x);
+        y1 = Math.max(y1, y);
+      }
+    }
+  }
+
+  // Flash takes extents that end at the origin for none found: a lone hit at (0, 0) gives an empty rect.
+  return x1 <= 0 && y1 <= 0
+    ? { x: 0, y: 0, width: 0, height: 0 }
+    : { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
+
+/** floodFill: the 4-connected region of the start pixel's exact value set to `color`. */
+export function floodFill(store: BitmapStore, x: number, y: number, color: number): void {
+  const { width, height } = store;
+  if (x < 0 || y < 0 || x >= width || y >= height) {
+    return;
+  }
+
+  const from = store.pixels[y * width + x];
+  const to = store.premultiplied(color >>> 0);
+  if (from === to) {
+    return;
+  }
+
+  const stack = [y * width + x];
+  while (stack.length) {
+    const i = stack.pop() as number;
+    if (store.pixels[i] !== from) {
+      continue;
+    }
+
+    store.pixels[i] = to;
+    const px = i % width;
+    if (px > 0) {
+      stack.push(i - 1);
+    }
+
+    if (px < width - 1) {
+      stack.push(i + 1);
+    }
+
+    if (i >= width) {
+      stack.push(i - width);
+    }
+
+    if (i + width < width * height) {
+      stack.push(i + width);
+    }
+  }
+
+  store.changed();
+}
+
+/** histogram: four arrays of 256 counts, red, green, blue and alpha, of the rect's unmultiplied pixels. */
+export function histogram(store: BitmapStore, rect: PixelRect): number[][] {
+  const counts = [0, 1, 2, 3].map(() => new Array<number>(256).fill(0));
+  const c = store.clip(rect);
+  if (!c) {
+    return counts;
+  }
+
+  for (let y = c.y; y < c.y + c.height; y++) {
+    for (let x = c.x; x < c.x + c.width; x++) {
+      const p = unmultiply(store.pixels[y * store.width + x]);
+      counts[0][(p >>> 16) & 0xff]++;
+      counts[1][(p >>> 8) & 0xff]++;
+      counts[2][p & 0xff]++;
+      counts[3][p >>> 24]++;
+    }
+  }
+
+  return counts;
+}
+
+/** The unmultiplied alpha at (x, y), as a hit test reads it: an opaque bitmap's 255; -1 outside. */
+export function alphaAt(store: BitmapStore, x: number, y: number): number {
+  if (x < 0 || y < 0 || x >= store.width || y >= store.height) {
+    return -1;
+  }
+
+  return store.transparent ? store.readable[y * store.width + x] >>> 24 : 255;
+}
+
+/**
+ * Flash's pixelDissolve taps, by the state's width in bits: a Galois LFSR,
+ * s >> 1, xor the tap where s was odd, read off adl for every width a
+ * BitmapData can have (2 to 26 bits).
+ */
+const DISSOLVE_TAPS = [
+  0, 0, 3, 6, 12, 20, 48, 96, 184, 272, 576, 1280, 3232, 6912, 13568, 24576, 46080, 73728, 132096,
+  466944, 589824, 1310720, 3145728, 4325376, 14155776, 18874368, 59244544,
+];
+
+/** Bits to number 0..n - 1: ceil(log2(n)). */
+function bitsFor(n: number): number {
+  return n <= 1 ? 0 : 32 - Math.clz32(n - 1);
+}
+
+/**
+ * pixelDissolve as Flash does it, fitted under adl: a state of
+ * ceil(log2 w) + ceil(log2 h) bits stands for the pixel (s & (2^bw - 1),
+ * s >> bw) of the rect, a state outside it skipped; each call writes
+ * numPixels pixels, from the seed on, and returns the state after the
+ * last, raw, so the next call goes on from there. Every call writes the
+ * pixel at the origin too, which no state stands for, and so n calls of
+ * 1 write n + 1 (Ruffle's bitmapdata_pixeldissolve); 0 starts at the tap,
+ * and a seed past the generator's states steps down to them as any state
+ * does, its bits shifted out, or to 0, which writes the origin for good. A
+ * pixel takes the fill colour where the source is the destination, and
+ * there it is the source rect that dissolves, the point aside, though
+ * clipped as a copy's; else the source's pixel. A rect a pixel high or
+ * wide dissolves nothing and gives the seed back as it came; a count of 0
+ * writes the origin alone and gives the seed back, the tap for 0. AS3's
+ * answers are AVM1's (the dissolve-noise case).
+ */
+export function pixelDissolve(
+  store: BitmapStore,
+  source: BitmapStore,
+  rect: PixelRect,
+  dx: number,
+  dy: number,
+  seed: number,
+  count: number,
+  fill: number,
+): number {
+  // Over the rect clipped to the source and then to the destination, as the copies are.
+  const sc = source.clip(rect);
+  if (!sc) {
+    return seed;
+  }
+
+  const ox = dx + (sc.x - rect.x);
+  const oy = dy + (sc.y - rect.y);
+  const dc = store.clip({ x: ox, y: oy, width: sc.width, height: sc.height });
+  if (!dc) {
+    return seed;
+  }
+
+  const rx = sc.x + (dc.x - ox);
+  const ry = sc.y + (dc.y - oy);
+  dx = dc.x;
+  dy = dc.y;
+  const { width: w, height: h } = dc;
+  if (w <= 1 || h <= 1) {
+    return seed;
+  }
+
+  const bw = bitsFor(w);
+  const bits = bw + bitsFor(h);
+  const tap = DISSOLVE_TAPS[bits] ?? 0;
+  const xMask = (1 << bw) - 1;
+  const color = store.premultiplied(fill >>> 0);
+  // An opaque store keeps every alpha at 255, as threshold's copies have it.
+  const opaque = store.transparent ? 0 : 0xff000000;
+  const next = (s: number) => (s & 1 ? (s >>> 1) ^ tap : s >>> 1);
+
+  // A position of the rect, written where it lies in both bitmaps.
+  const write = (state: number) => {
+    const px = state & xMask;
+    const py = Math.floor(state / 2 ** bw);
+    const sx = rx + px;
+    const sy = ry + py;
+    // In place, Flash fills the source rect's pixels, wherever the point is.
+    const tx = source === store ? sx : dx + px;
+    const ty = source === store ? sy : dy + py;
+    if (
+      sx < 0 ||
+      sy < 0 ||
+      sx >= source.width ||
+      sy >= source.height ||
+      tx < 0 ||
+      ty < 0 ||
+      tx >= store.width ||
+      ty >= store.height
+    ) {
+      return;
+    }
+
+    store.pixels[ty * store.width + tx] =
+      source === store ? color : (source.pixels[sy * source.width + sx] | opaque) >>> 0;
+  };
+  const inside = (state: number) => (state & xMask) < w && Math.floor(state / 2 ** bw) < h;
+
+  // The origin is written on every call; 0, which no state within the
+  // generator's steps to (a seed past them may), starts at the tap.
+  write(0);
+  if (seed === 0) {
+    seed = tap;
+  }
+
+  if (count === 0) {
+    store.changed();
+    return seed;
+  }
+
+  let s = seed >>> 0;
+
+  // The states inside the rect come round every w * h - 1 writes (state 0
+  // is the origin's, which only a seed past the states steps down to, and
+  // stays at), so a count past that is one full round, which writes every
+  // pixel, and the remainder: the same pixels and the seed Flash returns,
+  // without its seconds-long loop.
+  const round = w * h - 1;
+  const steps = count > round ? round + (count % round) : count;
+  for (let k = 0; k < steps; k++) {
+    // A seed's bits past the states shift out, and every state then comes
+    // round within 2^bits steps, so this ends.
+    while (!inside(s)) {
+      s = next(s);
+    }
+
+    write(s);
+    s = next(s);
+  }
+
+  store.changed();
+  return s;
+}
+
+/** An affine matrix as Flash's flash.geom.Matrix has it: x' = a x + c y + tx, y' = b x + d y + ty. */
+export interface Affine {
+  a: number;
+  b: number;
+  c: number;
+  d: number;
+  tx: number;
+  ty: number;
+}
+
+export interface ColorTransformValues {
+  rMul: number;
+  gMul: number;
+  bMul: number;
+  aMul: number;
+  rAdd: number;
+  gAdd: number;
+  bAdd: number;
+  aAdd: number;
+}
+
+interface PreparedColorTransform extends ColorTransformValues {
+  skipZeroAlpha: boolean;
+}
+
+/** A display object's layer drawn (drawBitmap): a Bitmap's, a drawing's snapshot, or none. */
+export type Layer = "bitmap" | "drawing" | null;
+
+// The blend modes draw composites with, as the numbers the pixel loops take,
+// worked out once a draw.
+const NORMAL = 0;
+const MULTIPLY = 1;
+const SCREEN = 2;
+const LIGHTEN = 3;
+const DARKEN = 4;
+const DIFFERENCE = 5;
+const ADD = 6;
+const SUBTRACT = 7;
+const INVERT = 8;
+const OVERLAY = 9;
+const HARDLIGHT = 10;
+const ERASE = 11;
+const ALPHA = 12;
+
+/**
+ * Each blend mode draw takes, by its name; any other draws nothing. Alpha
+ * and erase need a layer: a display object drawn has one, and they then
+ * scale the destination's alpha where it covers; a BitmapData drawn has
+ * not, and they do nothing.
+ */
+const MODES = new Map([
+  ["normal", NORMAL],
+  ["layer", NORMAL],
+  ["multiply", MULTIPLY],
+  ["screen", SCREEN],
+  ["lighten", LIGHTEN],
+  ["darken", DARKEN],
+  ["difference", DIFFERENCE],
+  ["add", ADD],
+  ["subtract", SUBTRACT],
+  ["invert", INVERT],
+  ["overlay", OVERLAY],
+  ["hardlight", HARDLIGHT],
+  ["erase", ERASE],
+  ["alpha", ALPHA],
+]);
+
+/**
+ * draw of a bitmap source: each destination pixel in the clip takes the
+ * source pixel under its centre, through the matrix's inverse, clamped to
+ * the source's edges (bilinear when smoothing), scaled by how much of the
+ * pixel the transformed source covers (a 4 x 4 sample grid), passed
+ * through the colour transform as colorTransform does, and composited by
+ * the blend mode. Flash's own pixels, under adl: nearest at the centre,
+ * normal as the store's source-over, alpha and erase as nothing unless the
+ * source is a display object's `layer`: a Bitmap's, every pixel of which it
+ * covers, or a drawing's snapshot, which covers only where it drew.
+ */
+export function drawBitmap(
+  store: BitmapStore,
+  source: BitmapStore,
+  m: Affine,
+  ct: ColorTransformValues | null,
+  mode: string,
+  clip: PixelRect | null,
+  smooth: boolean,
+  rows = false,
+  layer: Layer = null,
+): void {
+  const code = MODES.get(mode);
+  const whole = code === ERASE || code === ALPHA;
+  if (code === undefined || (whole && layer === null)) {
+    return;
+  }
+
+  // A drawing's alpha blend leaves the destination where it drew nothing, or drew clear (adl).
+  const keepClear = code === ALPHA && layer === "drawing";
+
+  // Flash rasterises the translation snapped down to quarter pixels, which
+  // its 4 x 4 coverage then reads exactly (a move of 0.49 covers 3/4 and
+  // 1/4 of the edge pixels under adl).
+  m = { ...m, tx: Math.floor(m.tx * 4) / 4, ty: Math.floor(m.ty * 4) / 4 };
+  const det = m.a * m.d - m.b * m.c;
+  if (det === 0) {
+    return;
+  }
+
+  // The destination pixels the source can reach: its corners through the matrix.
+  const corners = [
+    [0, 0],
+    [source.width, 0],
+    [0, source.height],
+    [source.width, source.height],
+  ].map(([x, y]) => [m.a * x + m.c * y + m.tx, m.b * x + m.d * y + m.ty]);
+  const xs = corners.map((p) => p[0]);
+  const ys = corners.map((p) => p[1]);
+  let area: PixelRect | null = store.clip({
+    x: Math.floor(Math.min(...xs)),
+    y: Math.floor(Math.min(...ys)),
+    width: Math.ceil(Math.max(...xs)) - Math.floor(Math.min(...xs)),
+    height: Math.ceil(Math.max(...ys)) - Math.floor(Math.min(...ys)),
+  });
+  if (area && clip) {
+    area = store.clip({
+      x: Math.max(area.x, clip.x),
+      y: Math.max(area.y, clip.y),
+      width: Math.min(area.x + area.width, clip.x + clip.width) - Math.max(area.x, clip.x),
+      height: Math.min(area.y + area.height, clip.y + clip.height) - Math.max(area.y, clip.y),
+    });
+  }
+
+  if (!area) {
+    return;
+  }
+
+  // A layer's blend reads the source as it was: of a Bitmap of the bitmap itself, the part
+  // that can reach the area is copied first.
+  if (whole && source === store) {
+    [source, m] = reachable(store, m, area);
+  }
+
+  const transform = ct ? prepareColorTransform(ct) : null;
+  // Unscaled at a whole pixel, as every snapshot of a display object is
+  // composited: each covered pixel is covered whole and is the source's
+  // own, so it is copied straight, as the general path below would.
+  const moved =
+    m.a === 1 &&
+    m.b === 0 &&
+    m.c === 0 &&
+    m.d === 1 &&
+    Number.isInteger(m.tx) &&
+    Number.isInteger(m.ty) &&
+    source !== store;
+  // The inverse: from a destination point to the source's.
+  const ia = m.d / det;
+  const ib = -m.b / det;
+  const ic = -m.c / det;
+  const id = m.a / det;
+  const itx = -(ia * m.tx + ic * m.ty);
+  const ity = -(ib * m.tx + id * m.ty);
+  if (code === NORMAL && source !== store) {
+    const inverse = job.inverse;
+    inverse[0] = ia;
+    inverse[1] = ib;
+    inverse[2] = ic;
+    inverse[3] = id;
+    inverse[4] = itx;
+    inverse[5] = ity;
+    if (drawnNatively(store, source, m, moved, area, transform, smooth)) {
+      return;
+    }
+  }
+
+  if (moved) {
+    if (composite(store, source, area, m.tx, m.ty, transform, code, keepClear)) {
+      store.changed();
+    }
+
+    return;
+  }
+
+  // How many of the pixel's 4 x 4 samples fall inside the source.
+  const coverage = (x: number, y: number) => {
+    let hits = 0;
+    for (let k = 0; k < 16; k++) {
+      const px = x + ((k & 3) + 0.5) / 4;
+      const py = y + ((k >> 2) + 0.5) / 4;
+      const sx = ia * px + ic * py + itx;
+      const sy = ib * px + id * py + ity;
+      if (sx >= 0 && sy >= 0 && sx < source.width && sy < source.height) {
+        hits++;
+      }
+    }
+
+    return hits;
+  };
+
+  // The arrays taken once. What the source reads as: its own pixels drawn into itself, else as
+  // a draw reads them. The store's, which bring back what the GPU drew last or copy a library
+  // bitmap's, are taken at the first pixel put, but first when the source is the store, which
+  // reads them as written.
+  let into = source === store ? store.pixels : null;
+  const pixels = source === store ? source.readable : source.drawable;
+  // Whether a pixel was put, for the store to count a change: a draw that puts none is none.
+  let wrote = false;
+
+  // Through a Bitmap of itself, a BitmapData is drawn in plain scan order,
+  // each pixel reading what the ones before it wrote, which smears both
+  // ways (adl): pixel by pixel. A layer's blend has a copy of it by now.
+  if (source === store && !rows) {
+    for (let y = area.y; y < area.y + area.height; y++) {
+      for (let x = area.x; x < area.x + area.width; x++) {
+        const hits = coverage(x, y);
+        if (hits === 0) {
+          continue;
+        }
+
+        const cx = x + 0.5;
+        const cy = y + 0.5;
+        const sx = ia * cx + ic * cy + itx;
+        const sy = ib * cx + id * cy + ity;
+        let p = smooth
+          ? bilinear(pixels, source.width, source.height, sx - 0.5, sy - 0.5)
+          : nearest(pixels, source.width, source.height, sx, sy);
+        if (transform) {
+          p = transformed(p, transform);
+        }
+
+        if (hits < 16) {
+          p = scaleBy(p, hits / 16);
+        }
+
+        into ??= store.pixels;
+        put(store, into, y * store.width + x, code, p);
+        wrote = true;
+      }
+    }
+
+    if (wrote) {
+      store.changed();
+    }
+
+    return;
+  }
+
+  // Otherwise a row at a time, each pass over it in a loop of its own, so
+  // that no pixel crosses a call: a pixel past 2^30 a call returns is a
+  // number V8 allocates. Every pixel of a row is read before one is
+  // written, which is how Flash draws a BitmapData into itself: a move
+  // right keeps the pixels, a move down smears rows.
+  const n = area.width;
+  const buffers = takeRows(n);
+  try {
+    const { pixels: row, hits, us, vs } = buffers;
+    const w = source.width;
+    const h = source.height;
+
+    for (let y = area.y; y < area.y + area.height; y++) {
+      // Where all 16 samples of a pixel surely fall inside the source, and
+      // where none can: only the pixels between are tested sample by sample.
+      spanFrom = Number.NEGATIVE_INFINITY;
+      spanTo = Number.POSITIVE_INFINITY;
+      const spans = !whole && coveredSpan(ia, ic, itx, w, y) && coveredSpan(ib, id, ity, h, y);
+      const fullFrom = spans ? Math.max(area.x, spanFrom) : 0;
+      const fullTo = spans ? Math.min(area.x + n, spanTo) : 0;
+      let any = 0;
+
+      for (let x = area.x, k = 0; k < n; x++, k++) {
+        const cx = x + 0.5;
+        const cy = y + 0.5;
+        const sx = ia * cx + ic * cy + itx;
+        const sy = ib * cx + id * cy + ity;
+        let hit = 16;
+        if (whole) {
+          // Erase and alpha take a pixel whole where the source is at its centre, as adl
+          // draws a shape's edge for them, an edge through the centre counted on its right
+          // and below.
+          hit = sx > 0 && sy > 0 && sx <= w && sy <= h ? 16 : 0;
+        } else if (x < fullFrom || x >= fullTo) {
+          hit = coverage(x, y);
+        }
+
+        hits[k] = hit;
+        if (hit === 0) {
+          continue;
+        }
+
+        any++;
+        us[k] = sx;
+        vs[k] = sy;
+      }
+
+      if (any === 0) {
+        continue;
+      }
+
+      sampleRow(pixels, w, h, us, vs, hits, row, n, smooth);
+      if (transform) {
+        transformRow(row, hits, n, transform);
+      }
+
+      coverRow(row, hits, n);
+      into ??= store.pixels;
+      blendRow(store, into, y * store.width + area.x, row, hits, n, code, keepClear);
+      wrote = true;
+    }
+  } finally {
+    giveRowsBack(buffers);
+  }
+
+  if (wrote) {
+    store.changed();
+  }
+}
+
+/** The draw kernel's job, filled for each draw: drawBitmap allocates nothing for it. */
+const job = DrawKernel.job();
+
+/** How far a source point may lie for the draw kernel, whose numbers are then exact as drawBitmap's. */
+const REACH = 2 ** 30;
+
+/**
+ * A draw in the normal blend mode of another store, by the draw kernel
+ * (draw.zig), whose pixels are those of the paths below, to the bit, the
+ * matrix's inverse in `job.inverse` already: whether it drew it, which it
+ * does not for numbers it cannot take as they are, nor where the realm has
+ * no kernel.
+ */
+function drawnNatively(
+  store: BitmapStore,
+  source: BitmapStore,
+  m: Affine,
+  moved: boolean,
+  area: PixelRect,
+  ct: PreparedColorTransform | null,
+  smooth: boolean,
+): boolean {
+  // A store the GPU drew last is read back only by a draw that puts a pixel, as below.
+  if (store.newerOnGpu) {
+    return false;
+  }
+
+  // The source rows the draw reads: the area's, moved; else those its corners reach, and one
+  // more each way for smoothing and rounding. A point far out, or not finite, is drawn below.
+  const inverse = job.inverse;
+  let top: number;
+  let bottom: number;
+  if (moved) {
+    if (Math.abs(m.tx) >= 2 ** 31 || Math.abs(m.ty) >= 2 ** 31) {
+      return false;
+    }
+
+    top = area.y - m.ty;
+    bottom = top + area.height;
+  } else {
+    const x0 = area.x;
+    const x1 = area.x + area.width;
+    const y0 = area.y;
+    const y1 = area.y + area.height;
+    const ia = inverse[0];
+    const ib = inverse[1];
+    const ic = inverse[2];
+    const id = inverse[3];
+    const itx = inverse[4];
+    const ity = inverse[5];
+    const ya = ib * x0 + id * y0 + ity;
+    const yb = ib * x1 + id * y0 + ity;
+    const yc = ib * x0 + id * y1 + ity;
+    const yd = ib * x1 + id * y1 + ity;
+    const xa = ia * x0 + ic * y0 + itx;
+    const xb = ia * x1 + ic * y0 + itx;
+    const xc = ia * x0 + ic * y1 + itx;
+    const xd = ia * x1 + ic * y1 + itx;
+    const low = Math.min(ya, yb, yc, yd);
+    const high = Math.max(ya, yb, yc, yd);
+    const far = Math.max(Math.abs(xa), Math.abs(xb), Math.abs(xc), Math.abs(xd));
+    if (!(Math.abs(low) < REACH && Math.abs(high) < REACH && far < REACH)) {
+      return false;
+    }
+
+    top = Math.max(0, Math.min(source.height - 1, Math.floor(low) - 1));
+    bottom = Math.max(top + 1, Math.min(source.height, Math.ceil(high) + 1));
+  }
+
+  if (ct) {
+    const t = job.transform;
+    t[0] = ct.rMul;
+    t[1] = ct.gMul;
+    t[2] = ct.bMul;
+    t[3] = ct.aMul;
+    t[4] = ct.rAdd;
+    t[5] = ct.gAdd;
+    t[6] = ct.bAdd;
+    t[7] = ct.aAdd;
+    if (!t.every(Number.isFinite)) {
+      return false;
+    }
+  }
+
+  // Copying wide source rows for a small clip can cost more than the draw.
+  // Whole-pixel moves do less work per destination pixel, so their limit is lower.
+  const sourcePixels = source.width * (bottom - top);
+  const copiedPerPixel = moved ? 32 : 128;
+  if (sourcePixels > Math.max(1024, area.width * area.height * copiedPerPixel)) {
+    return false;
+  }
+
+  const kernel = drawKernel();
+  if (!kernel) {
+    return false;
+  }
+
+  job.source = source.drawable;
+  job.sourceWidth = source.width;
+  job.sourceHeight = source.height;
+  job.sourceTop = top;
+  job.sourceRows = bottom - top;
+  job.into = store.readable;
+  job.intoWidth = store.width;
+  job.x = area.x;
+  job.y = area.y;
+  job.width = area.width;
+  job.height = area.height;
+  job.moved = moved;
+  job.tx = moved ? m.tx : 0;
+  job.ty = moved ? m.ty : 0;
+  job.flags =
+    (smooth ? DRAW_SMOOTH : 0) |
+    (ct ? DRAW_TRANSFORM : 0) |
+    (store.transparent ? 0 : DRAW_OPAQUE) |
+    (ct?.skipZeroAlpha ? DRAW_SKIP_ZERO_ALPHA : 0);
+  const result = kernel.draw(job);
+  // The job holds no store's pixels past the draw.
+  job.source = EMPTY;
+  job.into = EMPTY;
+  if (result === "refused") {
+    return false;
+  }
+
+  if (result === "written") {
+    kernel.writeBack(job, store.pixels);
+    store.changed();
+  }
+
+  return true;
+}
+
+const EMPTY = new Uint32Array(0);
+
+/** drawBitmap's buffers for a row. */
+interface RowScratch {
+  pixels: Uint32Array;
+  hits: Uint8Array;
+  /** Each pixel's point in the source. */
+  us: Float64Array;
+  vs: Float64Array;
+}
+
+/**
+ * The row buffers kept between draws, which drawBitmap and composite take
+ * for a draw and give back after it. A draw runs to its end without
+ * calling out, so no other draw can take them in the middle of one:
+ * `scratchTaken` holds that, and a draw that finds them taken throws
+ * rather than overwrite a row another is working on.
+ */
+let scratch: RowScratch = {
+  pixels: new Uint32Array(0),
+  hits: new Uint8Array(0),
+  us: new Float64Array(0),
+  vs: new Float64Array(0),
+};
+let scratchTaken = false;
+
+/** The widest row whose buffers are kept for the next draw: a wider one's go with its draw. */
+const ROW_KEPT = 8192;
+
+/** Buffers for rows of `n` pixels: the kept ones where they are wide enough, until given back. */
+function takeRows(n: number): RowScratch {
+  if (scratch.pixels.length >= n) {
+    if (scratchTaken) {
+      throw new Error("drawBitmap's row buffers are taken by a draw already under way");
+    }
+
+    scratchTaken = true;
+    return scratch;
+  }
+
+  const buffers = {
+    pixels: new Uint32Array(n),
+    hits: new Uint8Array(n),
+    us: new Float64Array(n),
+    vs: new Float64Array(n),
+  };
+  if (n <= ROW_KEPT && !scratchTaken) {
+    scratch = buffers;
+    scratchTaken = true;
+  }
+
+  return buffers;
+}
+
+function giveRowsBack(buffers: RowScratch): void {
+  if (buffers === scratch) {
+    scratchTaken = false;
+  }
+}
+
+/** coveredSpan's answer: the first pixel of a row covered whole and the one past the last. */
+let spanFrom = 0;
+let spanTo = 0;
+
+/**
+ * Narrows spanFrom to spanTo, the destination pixels in row y whose 16 samples
+ * all have u = a x + c y' + t within [0, size), y' each of the row's four
+ * sample rows; false where u barely moves along x without being still,
+ * which leaves every pixel to be tested. The span keeps a margin of a
+ * thousandth of a pixel, and more where the numbers are large, from where
+ * the samples' own arithmetic decides, so a pixel in it is one the tests
+ * find whole.
+ */
+function coveredSpan(a: number, c: number, t: number, size: number, y: number): boolean {
+  if (a === 0) {
+    // u is the same all along a sample row, worked out as the tests do.
+    for (let k = 0; k < 4; k++) {
+      const u = c * (y + (k + 0.5) / 4) + t;
+      if (!(u >= 0 && u < size)) {
+        spanFrom = Number.POSITIVE_INFINITY;
+      }
+    }
+
+    return true;
+  }
+
+  if (Math.abs(a) < 1e-6) {
+    return false;
+  }
+
+  for (let k = 0; k < 4; k++) {
+    const offset = c * (y + (k + 0.5) / 4) + t;
+    // The x where u is 0 and where it is size, in either order.
+    const at0 = -offset / a;
+    const atSize = (size - offset) / a;
+    const margin =
+      0.001 +
+      (1e-12 * (Math.abs(offset) + size + Math.abs(a) * (Math.abs(at0) + Math.abs(atSize)))) /
+        Math.abs(a);
+    const low = Math.min(at0, atSize) + margin;
+    const high = Math.max(at0, atSize) - margin;
+    if (!Number.isFinite(low) || !Number.isFinite(high)) {
+      return false;
+    }
+
+    // Samples lie at x + 1/8 to x + 7/8.
+    spanFrom = Math.max(spanFrom, Math.ceil(low - 0.125));
+    spanTo = Math.min(spanTo, Math.floor(high - 0.875) + 1);
+  }
+
+  return true;
+}
+
+/** The source's pixel under each covered pixel's point of the row, nearest or bilinear. */
+function sampleRow(
+  from: Uint32Array,
+  width: number,
+  height: number,
+  us: Float64Array,
+  vs: Float64Array,
+  hits: Uint8Array,
+  row: Uint32Array,
+  n: number,
+  smooth: boolean,
+): void {
+  for (let k = 0; k < n; k++) {
+    if (hits[k] === 0) {
+      continue;
+    }
+
+    row[k] = smooth
+      ? bilinear(from, width, height, us[k] - 0.5, vs[k] - 0.5)
+      : nearest(from, width, height, us[k], vs[k]);
+  }
+}
+
+/** The row's covered pixels through the colour transform, a run of one pixel transformed once. */
+function transformRow(
+  row: Uint32Array,
+  hits: Uint8Array,
+  n: number,
+  ct: PreparedColorTransform,
+): void {
+  let last = -1;
+  let out = 0;
+  for (let k = 0; k < n; k++) {
+    if (hits[k] === 0) {
+      continue;
+    }
+
+    const p = row[k];
+    if (p !== last) {
+      last = p;
+      out = transformed(p, ct);
+    }
+
+    row[k] = out;
+  }
+}
+
+/** The row's partly covered pixels scaled by their coverage. */
+function coverRow(row: Uint32Array, hits: Uint8Array, n: number): void {
+  for (let k = 0; k < n; k++) {
+    const hit = hits[k];
+    if (hit !== 0 && hit < 16) {
+      row[k] = scaleBy(row[k], hit / 16);
+    }
+  }
+}
+
+/**
+ * The row's covered pixels composited into the store's pixels from `at` by
+ * the blend mode; with `keepClear`, a clear one leaves the destination be.
+ */
+function blendRow(
+  store: BitmapStore,
+  into: Uint32Array,
+  at: number,
+  row: Uint32Array,
+  hits: Uint8Array,
+  n: number,
+  mode: number,
+  keepClear: boolean,
+): void {
+  if (mode === NORMAL) {
+    const opaque = store.transparent ? 0 : 0xff000000;
+    for (let k = 0; k < n; k++) {
+      if (hits[k] === 0) {
+        continue;
+      }
+
+      const p = row[k];
+      const sa = p >>> 24;
+      into[at + k] = sa === 255 ? p : (over(p, into[at + k]) | opaque) >>> 0;
+    }
+
+    return;
+  }
+
+  for (let k = 0; k < n; k++) {
+    if (hits[k] !== 0 && !(keepClear && row[k] >>> 24 === 0)) {
+      put(store, into, at + k, mode, row[k]);
+    }
+  }
+}
+
+/** `source` at (tx, ty) composited into `area` of the store, a pixel each; whether it put one. */
+function composite(
+  store: BitmapStore,
+  source: BitmapStore,
+  area: PixelRect,
+  tx: number,
+  ty: number,
+  ct: PreparedColorTransform | null,
+  mode: number,
+  keepClear: boolean,
+): boolean {
+  const from = source.drawable;
+  const opaque = store.transparent ? 0 : 0xff000000;
+  // The store's pixels, taken as drawBitmap takes them: at the first pixel put.
+  let into: Uint32Array | null = null;
+  if (!ct && mode === NORMAL) {
+    for (let y = area.y; y < area.y + area.height; y++) {
+      let i = y * store.width + area.x;
+      let j = (y - ty) * source.width + (area.x - tx);
+      for (let x = 0; x < area.width; x++, i++, j++) {
+        // Source over, inline: what blend("normal") computes.
+        const p = from[j];
+        const sa = p >>> 24;
+        if (sa === 0) {
+          continue;
+        }
+
+        into ??= store.pixels;
+        into[i] = sa === 255 ? p : (over(p, into[i]) | opaque) >>> 0;
+      }
+    }
+
+    return into !== null;
+  }
+
+  // A row at a time through the passes drawBitmap's rows take, every pixel covered.
+  const n = area.width;
+  const buffers = takeRows(n);
+  try {
+    const { pixels: row, hits } = buffers;
+    hits.fill(16, 0, n);
+    into = store.pixels;
+
+    for (let y = area.y; y < area.y + area.height; y++) {
+      const j = (y - ty) * source.width + (area.x - tx);
+      // A view and a copy: a loop copying it was slower, for all a view allocates.
+      row.set(from.subarray(j, j + n));
+      if (ct) {
+        transformRow(row, hits, n, ct);
+      }
+
+      blendRow(store, into, y * store.width + area.x, row, hits, n, mode, keepClear);
+    }
+  } finally {
+    giveRowsBack(buffers);
+  }
+
+  return true;
+}
+
+/**
+ * A drawn pixel composited into the store by the blend mode, opaque where
+ * the store is, but for erase and alpha: an opaque bitmap holds the alpha
+ * they leave, as Flash's memory does, and reads it back (getPixel32).
+ */
+function put(store: BitmapStore, into: Uint32Array, i: number, mode: number, p: number): void {
+  const out = blend(mode, p, into[i]);
+  if (store.transparent) {
+    into[i] = out;
+  } else if (mode === ERASE || mode === ALPHA) {
+    into[i] = out;
+    store.holdsAlpha ||= out >>> 24 !== 255;
+  } else {
+    into[i] = (out | 0xff000000) >>> 0;
+  }
+}
+
+/**
+ * The part of `store` a draw of itself through `m` into `area` can read,
+ * copied, as a layer reads it before the draw writes, and the matrix that
+ * draws the copy where the store would be drawn: the area's corners taken
+ * back through the matrix, a pixel wider for smoothing, within the store.
+ */
+function reachable(store: BitmapStore, m: Affine, area: PixelRect): [BitmapStore, Affine] {
+  const det = m.a * m.d - m.b * m.c;
+  const back = [
+    [area.x, area.y],
+    [area.x + area.width, area.y],
+    [area.x, area.y + area.height],
+    [area.x + area.width, area.y + area.height],
+  ].map(([x, y]) => [
+    (m.d * (x - m.tx) - m.c * (y - m.ty)) / det,
+    (m.a * (y - m.ty) - m.b * (x - m.tx)) / det,
+  ]);
+  const x0 = Math.max(0, Math.floor(Math.min(...back.map((p) => p[0]))) - 1);
+  const y0 = Math.max(0, Math.floor(Math.min(...back.map((p) => p[1]))) - 1);
+  const x1 = Math.min(store.width, Math.ceil(Math.max(...back.map((p) => p[0]))) + 1);
+  const y1 = Math.min(store.height, Math.ceil(Math.max(...back.map((p) => p[1]))) + 1);
+  const width = Math.max(0, x1 - x0);
+  const height = Math.max(0, y1 - y0);
+  const copy = new BitmapStore(width, height, store.transparent, 0);
+  const from = store.readable;
+  const into = copy.pixels;
+  for (let y = 0; y < height; y++) {
+    into.set(
+      from.subarray((y0 + y) * store.width + x0, (y0 + y) * store.width + x0 + width),
+      y * width,
+    );
+  }
+
+  copy.holdsAlpha = store.holdsAlpha;
+  return [copy, { ...m, tx: m.tx + m.a * x0 + m.c * y0, ty: m.ty + m.b * x0 + m.d * y0 }];
+}
+
+function nearest(from: Uint32Array, width: number, height: number, x: number, y: number): number {
+  const px = Math.min(width - 1, Math.max(0, Math.floor(x)));
+  const py = Math.min(height - 1, Math.max(0, Math.floor(y)));
+  return from[py * width + px];
+}
+
+/** Bilinear between the four premultiplied pixels round (x, y), clamped to the edges. */
+function bilinear(from: Uint32Array, width: number, height: number, x: number, y: number): number {
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const fx = x - x0;
+  const fy = y - y0;
+  const left = Math.min(width - 1, Math.max(0, x0));
+  const right = Math.min(width - 1, Math.max(0, x0 + 1));
+  const top = Math.min(height - 1, Math.max(0, y0)) * width;
+  const bottom = Math.min(height - 1, Math.max(0, y0 + 1)) * width;
+  const p00 = from[top + left];
+  const p10 = from[top + right];
+  const p01 = from[bottom + left];
+  const p11 = from[bottom + right];
+  const gx = 1 - fx;
+  const gy = 1 - fy;
+
+  return (
+    ((lerp4(p00, p10, p01, p11, 24, fx, fy, gx, gy) << 24) |
+      (lerp4(p00, p10, p01, p11, 16, fx, fy, gx, gy) << 16) |
+      (lerp4(p00, p10, p01, p11, 8, fx, fy, gx, gy) << 8) |
+      lerp4(p00, p10, p01, p11, 0, fx, fy, gx, gy)) >>>
+    0
+  );
+}
+
+/** One channel of bilinear's four pixels, weighed by fx and fy and by gx and gy, their complements. */
+function lerp4(
+  p00: number,
+  p10: number,
+  p01: number,
+  p11: number,
+  shift: number,
+  fx: number,
+  fy: number,
+  gx: number,
+  gy: number,
+): number {
+  const top = ((p00 >>> shift) & 0xff) * gx + ((p10 >>> shift) & 0xff) * fx;
+  const bottom = ((p01 >>> shift) & 0xff) * gx + ((p11 >>> shift) & 0xff) * fx;
+  return Math.round(top * gy + bottom * fy);
+}
+
+/** A premultiplied pixel through a colour transform, as colorTransform computes it. */
+function transformed(p: number, ct: PreparedColorTransform): number {
+  const a0 = p >>> 24;
+  if (a0 === 0 && ct.skipZeroAlpha) {
+    return 0;
+  }
+
+  const a = colorChannel(a0, ct.aMul, ct.aAdd);
+  return (
+    ((a << 24) |
+      (drawColorChannel(p, a0, 16, ct.rMul, ct.rAdd, a) << 16) |
+      (drawColorChannel(p, a0, 8, ct.gMul, ct.gAdd, a) << 8) |
+      drawColorChannel(p, a0, 0, ct.bMul, ct.bAdd, a)) >>>
+    0
+  );
+}
+
+function prepareColorTransform(ct: ColorTransformValues): PreparedColorTransform {
+  return {
+    rMul: Math.trunc(ct.rMul * 256),
+    gMul: Math.trunc(ct.gMul * 256),
+    bMul: Math.trunc(ct.bMul * 256),
+    aMul: Math.trunc(ct.aMul * 256),
+    rAdd: Math.trunc(ct.rAdd),
+    gAdd: Math.trunc(ct.gAdd),
+    bAdd: Math.trunc(ct.bAdd),
+    aAdd: Math.trunc(ct.aAdd),
+    // The alpha-zero guard tests the original offset before truncation.
+    skipZeroAlpha: ct.aAdd <= 0,
+  };
+}
+
+// These stay outside the pixel loops so a transform creates no per-pixel closures.
+function colorChannel(v: number, mul: number, add: number): number {
+  return Math.max(0, Math.min(255, Math.floor((v * mul) / 256) + add));
+}
+
+function straightChannel(p: number, alpha: number, shift: number): number {
+  return alpha === 0 ? 0 : Math.min(255, Math.floor((((p >>> shift) & 0xff) * 255) / alpha));
+}
+
+function premultipliedChannel(v: number, alpha: number): number {
+  return alpha === 255 ? v : (v * (alpha + 1)) >> 8;
+}
+
+function drawColorChannel(
+  p: number,
+  alpha: number,
+  shift: number,
+  mul: number,
+  add: number,
+  outAlpha: number,
+): number {
+  const v = colorChannel(straightChannel(p, alpha, shift), mul, add);
+
+  return premultipliedChannel(v, outAlpha);
+}
+
+/** A premultiplied pixel with all four channels scaled by a coverage. */
+function scaleBy(p: number, f: number): number {
+  return (
+    ((Math.round((p >>> 24) * f) << 24) |
+      (Math.round(((p >>> 16) & 0xff) * f) << 16) |
+      (Math.round(((p >>> 8) & 0xff) * f) << 8) |
+      Math.round((p & 0xff) * f)) >>>
+    0
+  );
+}
+
+/**
+ * The destination alone, as erase and alpha leave it: each channel scaled
+ * by k / 255, what the source's alpha leaves or is, floored, as adl's are.
+ */
+function scaleFloored(d: number, k: number): number {
+  const a = Math.floor(((d >>> 24) * k) / 255);
+  const r = Math.floor((((d >>> 16) & 0xff) * k) / 255);
+  const g = Math.floor((((d >>> 8) & 0xff) * k) / 255);
+  const b = Math.floor(((d & 0xff) * k) / 255);
+  return ((a << 24) | (r << 16) | (g << 8) | b) >>> 0;
+}
+
+/** x * y / 255, rounded as the blend modes' arithmetic has it. */
+function mul(x: number, y: number): number {
+  return (x * y + 127) / 255;
+}
+
+/**
+ * Premultiplied s over d by a blend mode, the W3C's compositing with each
+ * mode's mix. Every helper takes its operands as arguments, so a pixel
+ * allocates nothing: a closure over them would take a context each call.
+ */
+function blend(mode: number, s: number, d: number): number {
+  if (mode === NORMAL) {
+    return over(s, d);
+  }
+
+  const sa = s >>> 24;
+  if (mode === ERASE || mode === ALPHA) {
+    return scaleFloored(d, mode === ERASE ? 255 - sa : sa);
+  }
+
+  const da = d >>> 24;
+  const a =
+    mode === ADD || mode === SUBTRACT
+      ? Math.min(255, sa + da)
+      : Math.min(255, Math.round(sa + da - mul(sa, da)));
+  return (
+    ((a << 24) |
+      (blendChannel(mode, (s >>> 16) & 0xff, (d >>> 16) & 0xff, sa, da) << 16) |
+      (blendChannel(mode, (s >>> 8) & 0xff, (d >>> 8) & 0xff, sa, da) << 8) |
+      blendChannel(mode, s & 0xff, d & 0xff, sa, da)) >>>
+    0
+  );
+}
+
+/** A colour channel of blend: source cs and destination cd under alphas sa and da. */
+function blendChannel(mode: number, cs: number, cd: number, sa: number, da: number): number {
+  let b: number;
+  switch (mode) {
+    case MULTIPLY:
+      b = mul(cs, cd);
+      break;
+    case SCREEN:
+      b = (cs * da) / 255 + (cd * sa) / 255 - mul(cs, cd);
+      break;
+    case LIGHTEN:
+      b = Math.max(mul(cs, da), mul(cd, sa));
+      break;
+    case DARKEN:
+      b = Math.min(mul(cs, da), mul(cd, sa));
+      break;
+    case DIFFERENCE:
+      b = Math.abs(mul(cs, da) - mul(cd, sa));
+      break;
+    case ADD:
+      return Math.min(255, cs + cd);
+    case SUBTRACT:
+      return Math.max(0, cd - cs);
+    case INVERT:
+      // The destination inverted, the source's colour unused.
+      return Math.max(0, Math.min(255, Math.floor(mul(255 - cd, sa) + mul(cd, 255 - sa))));
+    case OVERLAY:
+      b = 2 * cd <= da ? 2 * mul(cs, cd) : mul(sa, da) - 2 * mul(da - cd, sa - cs);
+      break;
+    default:
+      b = 2 * cs <= sa ? 2 * mul(cs, cd) : mul(sa, da) - 2 * mul(da - cd, sa - cs);
+      break;
+  }
+
+  return Math.max(0, Math.min(255, Math.floor(b + mul(cs, 255 - da) + mul(cd, 255 - sa))));
+}