rapier-jxl 2.1.0 → 2.2.0

package/kernels-simd.wat

@@ -0,0 +1,252 @@
+;; SPDX-License-Identifier: MIT
+;; Own bounded integer kernels. Pointers and lengths are checked by kernels.mjs.
+;; Tiny arithmetic helpers are explicitly inlined: Node 22 does not inline WAT calls
+;; by default. i64 multiplication followed by arithmetic >>24 is floor, not truncation.
+;; SIMD averages add one to negative sums before >>1, matching JavaScript's /2 |0.
+(module
+  (import "env" "memory" (memory 1 128))
+  (func $residual
+    (export "residual")
+    (param $p i32)
+    (param $w i32)
+    (param $h i32)
+    (param $pred i32)
+    (param $offset i32)
+    (param $out i32)
+    (local $L v128)
+    (local $T v128)
+    (local $NW v128)
+    (local $V v128)
+    (local $S v128)
+    (local $x i32)
+    (local $y i32)
+    (local $row i32)
+    (local $left i32)
+    (local $top i32)
+    (local $nw i32)
+    (local $g i32)
+    (local $v i32)
+    (local.set $row (i32.shl (local.get $w) (i32.const 2)))
+    (loop $ys
+      (local.set $x (i32.const 0))
+      (loop $xs
+        (block $next
+          (if
+            (i32.and
+              (i32.and (i32.ne (local.get $y) (i32.const 0)) (i32.ne (local.get $x) (i32.const 0)))
+              (i32.and
+                (i32.le_u (i32.add (local.get $x) (i32.const 4)) (local.get $w))
+                (i32.or (i32.eq (local.get $pred) (i32.const 3)) (i32.eq (local.get $pred) (i32.const 5)))))
+            (then
+              (local.set $L (v128.load (i32.sub (local.get $p) (i32.const 4))))
+              (local.set $T (v128.load (i32.sub (local.get $p) (local.get $row))))
+              (local.set $S (i32x4.add (local.get $L) (local.get $T)))
+              (if
+                (i32.eq (local.get $pred) (i32.const 3))
+                (then
+                  (local.set $V
+                    (i32x4.shr_s
+                      (i32x4.add
+                        (local.get $S)
+                        (v128.and (i32x4.shr_s (local.get $S) (i32.const 31)) (i32x4.splat (i32.const 1))))
+                      (i32.const 1))))
+                (else
+                  (local.set $NW (v128.load (i32.sub (i32.sub (local.get $p) (local.get $row)) (i32.const 4))))
+                  (local.set $V
+                    (i32x4.max_s
+                      (i32x4.min_s (local.get $L) (local.get $T))
+                      (i32x4.min_s
+                        (i32x4.max_s (local.get $L) (local.get $T))
+                        (i32x4.sub (local.get $S) (local.get $NW)))))))
+              (local.set $V
+                (i32x4.sub
+                  (i32x4.sub (v128.load (local.get $p)) (local.get $V))
+                  (i32x4.splat (local.get $offset))))
+              (v128.store
+                (local.get $out)
+                (v128.xor (i32x4.shl (local.get $V) (i32.const 1)) (i32x4.shr_s (local.get $V) (i32.const 31))))
+              (local.set $p (i32.add (local.get $p) (i32.const 16)))
+              (local.set $out (i32.add (local.get $out) (i32.const 16)))
+              (local.set $x (i32.add (local.get $x) (i32.const 4)))
+              (br $next)))
+          (local.set $v (i32.const 0))
+          (if
+            (local.get $pred)
+            (then
+              (local.set $left
+                (if
+                  (result i32)
+                  (local.get $x)
+                  (then (i32.load (i32.sub (local.get $p) (i32.const 4))))
+                  (else
+                    (if
+                      (result i32)
+                      (local.get $y)
+                      (then (i32.load (i32.sub (local.get $p) (local.get $row))))
+                      (else (i32.const 0))))))
+              (local.set $top
+                (if
+                  (result i32)
+                  (local.get $y)
+                  (then (i32.load (i32.sub (local.get $p) (local.get $row))))
+                  (else (local.get $left))))
+              (local.set $nw
+                (if
+                  (result i32)
+                  (i32.and (i32.ne (local.get $x) (i32.const 0)) (i32.ne (local.get $y) (i32.const 0)))
+                  (then (i32.load (i32.sub (i32.sub (local.get $p) (local.get $row)) (i32.const 4))))
+                  (else (local.get $left))))
+              (local.set $g (i32.sub (i32.add (local.get $left) (local.get $top)) (local.get $nw)))
+              (if (i32.eq (local.get $pred) (i32.const 1)) (then (local.set $v (local.get $left))))
+              (if (i32.eq (local.get $pred) (i32.const 2)) (then (local.set $v (local.get $top))))
+              (if
+                (i32.eq (local.get $pred) (i32.const 3))
+                (then (local.set $v (i32.div_s (i32.add (local.get $left) (local.get $top)) (i32.const 2)))))
+              (if
+                (i32.eq (local.get $pred) (i32.const 4))
+                (then
+                  (local.set $v
+                    (select
+                      (local.get $left)
+                      (local.get $top)
+                      (i32.lt_s
+                        (i32.sub
+                          (i32.xor
+                            (i32.sub (local.get $g) (local.get $left))
+                            (i32.shr_s (i32.sub (local.get $g) (local.get $left)) (i32.const 31)))
+                          (i32.shr_s (i32.sub (local.get $g) (local.get $left)) (i32.const 31)))
+                        (i32.sub
+                          (i32.xor
+                            (i32.sub (local.get $g) (local.get $top))
+                            (i32.shr_s (i32.sub (local.get $g) (local.get $top)) (i32.const 31)))
+                          (i32.shr_s (i32.sub (local.get $g) (local.get $top)) (i32.const 31))))))))
+              (if
+                (i32.eq (local.get $pred) (i32.const 5))
+                (then
+                  (local.set $v
+                    (select
+                      (select (local.get $left) (local.get $top) (i32.lt_s (local.get $left) (local.get $top)))
+                      (select
+                        (select (local.get $left) (local.get $top) (i32.gt_s (local.get $left) (local.get $top)))
+                        (local.get $g)
+                        (i32.lt_s
+                          (select
+                            (local.get $left)
+                            (local.get $top)
+                            (i32.gt_s (local.get $left) (local.get $top)))
+                          (local.get $g)))
+                      (i32.gt_s
+                        (select (local.get $left) (local.get $top) (i32.lt_s (local.get $left) (local.get $top)))
+                        (select
+                          (select
+                            (local.get $left)
+                            (local.get $top)
+                            (i32.gt_s (local.get $left) (local.get $top)))
+                          (local.get $g)
+                          (i32.lt_s
+                            (select
+                              (local.get $left)
+                              (local.get $top)
+                              (i32.gt_s (local.get $left) (local.get $top)))
+                            (local.get $g))))))))))
+          (i32.store
+            (local.get $out)
+            (i32.xor
+              (i32.shl
+                (i32.sub (i32.sub (i32.load (local.get $p)) (local.get $v)) (local.get $offset))
+                (i32.const 1))
+              (i32.shr_s
+                (i32.sub (i32.sub (i32.load (local.get $p)) (local.get $v)) (local.get $offset))
+                (i32.const 31))))
+          (local.set $out (i32.add (local.get $out) (i32.const 4)))
+          (local.set $p (i32.add (local.get $p) (i32.const 4)))
+          (local.set $x (i32.add (local.get $x) (i32.const 1))))
+        (br_if $xs (i32.lt_u (local.get $x) (local.get $w))))
+      (local.set $y (i32.add (local.get $y) (i32.const 1)))
+      (br_if $ys (i32.lt_u (local.get $y) (local.get $h)))))
+  (func $fill
+    (export "fill")
+    (param $src i32)
+    (param $n i32)
+    (param $channels i32)
+    (param $p0 i32)
+    (param $p1 i32)
+    (param $p2 i32)
+    (param $p3 i32)
+    (local $V v128)
+    (local $R v128)
+    (local $G v128)
+    (local $B v128)
+    (local $Co v128)
+    (local $Cg v128)
+    (local $Tmp v128)
+    (local $v i32)
+    (local $r i32)
+    (local $g i32)
+    (local $b i32)
+    (local $co i32)
+    (local $cg i32)
+    (local $tmp i32)
+    (local $i i32)
+    (block $vectorsDone
+      (loop $vectors
+        (br_if $vectorsDone (i32.gt_u (i32.add (local.get $i) (i32.const 4)) (local.get $n)))
+        (local.set $V (v128.load (local.get $src)))
+        (local.set $R (v128.and (local.get $V) (i32x4.splat (i32.const 255))))
+        (if
+          (i32.ge_u (local.get $channels) (i32.const 3))
+          (then
+            (local.set $G (v128.and (i32x4.shr_u (local.get $V) (i32.const 8)) (i32x4.splat (i32.const 255))))
+            (local.set $B (v128.and (i32x4.shr_u (local.get $V) (i32.const 16)) (i32x4.splat (i32.const 255))))
+            (local.set $Co (i32x4.sub (local.get $R) (local.get $B)))
+            (local.set $Tmp (i32x4.add (local.get $B) (i32x4.shr_s (local.get $Co) (i32.const 1))))
+            (local.set $Cg (i32x4.sub (local.get $G) (local.get $Tmp)))
+            (v128.store (local.get $p0) (i32x4.add (local.get $Tmp) (i32x4.shr_s (local.get $Cg) (i32.const 1))))
+            (v128.store (local.get $p1) (local.get $Co))
+            (v128.store (local.get $p2) (local.get $Cg))
+            (if
+              (i32.eq (local.get $channels) (i32.const 4))
+              (then (v128.store (local.get $p3) (i32x4.shr_u (local.get $V) (i32.const 24))))))
+          (else
+            (v128.store (local.get $p0) (local.get $R))
+            (if
+              (i32.eq (local.get $channels) (i32.const 2))
+              (then (v128.store (local.get $p1) (i32x4.shr_u (local.get $V) (i32.const 24)))))))
+        (local.set $p0 (i32.add (local.get $p0) (i32.const 16)))
+        (local.set $p1 (i32.add (local.get $p1) (i32.const 16)))
+        (local.set $p2 (i32.add (local.get $p2) (i32.const 16)))
+        (local.set $p3 (i32.add (local.get $p3) (i32.const 16)))
+        (local.set $src (i32.add (local.get $src) (i32.const 16)))
+        (local.set $i (i32.add (local.get $i) (i32.const 4)))
+        (br $vectors)))
+    (block $done
+      (loop $next
+        (br_if $done (i32.ge_u (local.get $i) (local.get $n)))
+        (local.set $v (i32.load (local.get $src)))
+        (local.set $r (i32.and (local.get $v) (i32.const 255)))
+        (if
+          (i32.ge_u (local.get $channels) (i32.const 3))
+          (then
+            (local.set $g (i32.and (i32.shr_u (local.get $v) (i32.const 8)) (i32.const 255)))
+            (local.set $b (i32.and (i32.shr_u (local.get $v) (i32.const 16)) (i32.const 255)))
+            (local.set $co (i32.sub (local.get $r) (local.get $b)))
+            (local.set $tmp (i32.add (local.get $b) (i32.shr_s (local.get $co) (i32.const 1))))
+            (local.set $cg (i32.sub (local.get $g) (local.get $tmp)))
+            (i32.store (local.get $p0) (i32.add (local.get $tmp) (i32.shr_s (local.get $cg) (i32.const 1))))
+            (i32.store (local.get $p1) (local.get $co))
+            (i32.store (local.get $p2) (local.get $cg))
+            (if
+              (i32.eq (local.get $channels) (i32.const 4))
+              (then (i32.store (local.get $p3) (i32.shr_u (local.get $v) (i32.const 24))))))
+          (else
+            (i32.store (local.get $p0) (local.get $r))
+            (if
+              (i32.eq (local.get $channels) (i32.const 2))
+              (then (i32.store (local.get $p1) (i32.shr_u (local.get $v) (i32.const 24)))))))
+        (local.set $p0 (i32.add (local.get $p0) (i32.const 4)))
+        (local.set $p1 (i32.add (local.get $p1) (i32.const 4)))
+        (local.set $p2 (i32.add (local.get $p2) (i32.const 4)))
+        (local.set $p3 (i32.add (local.get $p3) (i32.const 4)))
+        (local.set $src (i32.add (local.get $src) (i32.const 4)))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br_if $next (i32.lt_u (local.get $i) (local.get $n)))))))

package/kernels.mjs

@@ -0,0 +1,141 @@
+// Rapier's optional integer WebAssembly kernels. MIT (LICENSE).
+// No fetch, runtime dependency, shared memory or floating-point byte decisions.
+import {kernelHooks} from './kernel-hooks.mjs';
+import {BitWriter, LIMITS} from './bits.mjs';
+import {SCALAR, SIMD, SIMD_PROBE} from './kernels-bytes.mjs';
+
+export const {configureKernels, kernelMode} = (() => {
+const P = 65536, R = 327680, PROPERTY = 589824, CONTEXT = 851968;
+const OUTPUT = 1114128, TABLE = 1642496, SOURCE = 1769472, STATE = 2097152;
+const DIV = 16, WEIGHTS = 272, BUCKET = 16656, MAP = 20672, ALPHABET = 257;
+const CUTS = [-500,-392,-255,-191,-127,-95,-63,-47,-31,-23,-15,-11,-7,-4,-3,-1,0,1,3,5,7,11,15,23,31,47,63,95,127,191,255,392,500];
+let engine, active = 'off';
+const decode = text => Uint8Array.from(atob(text), c => c.charCodeAt(0));
+const acceptablePlane = (p, w, h, offset) => p instanceof Int16Array && Number.isInteger(w) && Number.isInteger(h) && w > 0 && h > 0 && w <= 16384 && w * h <= 65536 && p.length >= w * h && Number.isInteger(offset) && Math.abs(offset) <= 32768;
+const acceptableWriter = w => !w || (w instanceof BitWriter && w.write === BitWriter.prototype.write && w.grow === BitWriter.prototype.grow);
+// A hybrid-integer configuration the kernels write: split up to 15, msb and lsb within it, and every token a residual below
+// 2^19 can take inside the 224 symbols below the LZ77 lengths. A raw histogram (lossless-coding.mjs) is bins for the
+// residual values and the 33 length tokens: at most the 4,096 of a palette's indices and 33 more, in the arena's table.
+const PLAIN = {split: 0, msb: 0, lsb: 0};
+const acceptableConfig = c => Number.isInteger(c.split) && Number.isInteger(c.msb) && Number.isInteger(c.lsb) && c.split >= 0 && c.split <= 15 && c.msb >= 0 && c.lsb >= 0 && c.msb + c.lsb <= c.split && (1 << c.split) + ((19 - c.split) << (c.msb + c.lsb)) <= 224;
+const RAW_BINS = 4096 + 33;
+
+function createEngine() {
+  const memory = new WebAssembly.Memory({initial: 48, maximum: 128});
+  const names = new Map(Object.entries(new WebAssembly.Instance(new WebAssembly.Module(decode(SCALAR)), {env: {memory}}).exports));
+  // Lookup strings are ABI names, never JavaScript property-mangler candidates.
+  const scalar = {residual: names.get('residual'), tokens: names.get('tokens'), fill: names.get('fill'), weighted: names.get('weighted')};
+  const u8 = new Uint8Array(memory.buffer), i32 = new Int32Array(memory.buffer);
+  for (let i = 0; i < 64; i++) i32[(DIV >> 2) + i] = Math.floor(16777216 / (i + 1));
+  for (let most = 12; most <= 13; most++) for (let sum = 0; sum < 2048; sum++) {
+    const shift = Math.max(0, 26 - Math.clz32(sum + 1));
+    i32[(WEIGHTS >> 2) + (most - 12) * 2048 + sum] = 4 + ((most * i32[(DIV >> 2) + (sum >> shift)]) >> shift);
+  }
+  for (let i = 0; i < 1003; i++) i32[(BUCKET >> 2) + i] = CUTS.filter(cut => cut < i - 501).length;
+  return {memory, scalar, simd: null, u8, i32};
+}
+
+// Both passes use one bulk crossing. In particular the writer never calls back into
+// JS per token. Code tables use explicit little-endian i32 fields in private memory.
+function tokens(w, targets, count, contexts, config = PLAIN, rawLength = 0) {
+  const {scalar, i32, u8} = engine, stride = rawLength || ALPHABET;
+  if (!acceptableWriter(w) || !targets.length || targets.length > 34) return false;
+  if (w) {
+    i32.fill(0, TABLE >> 2, (TABLE >> 2) + targets.length * ALPHABET * 2);
+    for (let c = 0; c < targets.length; c++) {
+      const code = targets[c];
+      if (!code?.lengths || !code?.codes || code.lengths.length > ALPHABET) return false;
+      for (let s = 0; s < code.lengths.length; s++) {
+        i32[(TABLE >> 2) + (c * ALPHABET + s) * 2] = code.lengths[s];
+        i32[(TABLE >> 2) + (c * ALPHABET + s) * 2 + 1] = code.codes[s];
+      }
+    }
+  } else {
+    for (let c = 0; c < targets.length; c++) {
+      if (!(targets[c] instanceof Uint32Array) || targets[c].length !== stride) return false;
+      i32.set(targets[c], (TABLE >> 2) + c * stride);
+    }
+  }
+  const written = scalar.tokens(R, contexts, count, TABLE, OUTPUT, w ? 1 : 0, w ? w.acc : 0, w ? w.pending : 0, config.split, config.msb, config.lsb, rawLength);
+  if (w) {
+    if (w.at + written + 8 >= w.bytes.length) w.grow(written + 8);
+    w.bytes.set(u8.subarray(OUTPUT, OUTPUT + written), w.at);
+    w.at += written; w.acc = i32[(OUTPUT - 8) >> 2]; w.pending = i32[(OUTPUT - 4) >> 2];
+  } else for (let c = 0; c < targets.length; c++) targets[c].set(i32.subarray((TABLE >> 2) + c * stride, (TABLE >> 2) + (c + 1) * stride));
+  return true;
+}
+function channel(w, target, plane, width, height, leaf, raw) {
+  const config = leaf.config || PLAIN;
+  if (!acceptablePlane(plane, width, height, leaf.offset) || leaf.multiplier !== 1 || !Number.isInteger(leaf.predictor) || leaf.predictor < 0 || leaf.predictor > 5 || !acceptableWriter(w) || !acceptableConfig(config)) return false;
+  // A raw histogram is counted, never written, into bins that fit the arena's table.
+  if (raw && (w || !(target instanceof Uint32Array) || target.length < 34 || target.length > RAW_BINS)) return false;
+  const n = width * height;
+  if (w && w.at + n * 8 + 32 > LIMITS.bytes) return false;
+  engine.i32.set(plane.subarray(0, n), P >> 2);
+  (active === 'simd' ? engine.simd : engine.scalar).residual(P, width, height, leaf.predictor, leaf.offset, R);
+  return tokens(w, [target], n, 0, config, raw ? target.length : 0);
+}
+function weighted(w, targets, plane, width, height, offset, contextOf, residuals, properties) {
+  if (!acceptablePlane(plane, width, height, offset) || !acceptableWriter(w)) return false;
+  const n = width * height, {i32, scalar} = engine;
+  if (w && w.at + n * 8 + 32 > LIMITS.bytes) return false;
+  if (residuals && (!(residuals instanceof Uint32Array) || residuals.length < n)) return false;
+  if (properties && (!(properties instanceof Int32Array) || properties.length < n)) return false;
+  if (contextOf.length !== 34 || contextOf.some(c => !Number.isInteger(c) || c < 0 || c >= 34)) return false;
+  if (!residuals && contextOf.some(c => c >= targets.length)) return false;
+  i32.set(plane.subarray(0, n), P >> 2); i32.set(contextOf, MAP >> 2);
+  i32.fill(0, STATE >> 2, (STATE >> 2) + (width + 2) * 10);
+  scalar.weighted(P, width, height, offset, R, PROPERTY, CONTEXT, MAP, BUCKET, DIV, WEIGHTS, STATE);
+  if (residuals) {
+    residuals.set(i32.subarray(R >> 2, (R >> 2) + n));
+    if (properties) properties.set(i32.subarray(PROPERTY >> 2, (PROPERTY >> 2) + n));
+    return true;
+  }
+  if (properties) properties.set(i32.subarray(PROPERTY >> 2, (PROPERTY >> 2) + n));
+  return tokens(w, targets, n, CONTEXT);
+}
+function fill(rgba, imageWidth, x0, y0, w, h, channels, planes) {
+  const n = w * h;
+  if (n < 1 || n > 65536 || channels < 1 || channels > 4) return false;
+  const {u8, i32} = engine;
+  for (let y = 0; y < h; y++) {
+    const at = ((y0 + y) * imageWidth + x0) * 4;
+    u8.set(rgba.subarray(at, at + w * 4), SOURCE + y * w * 4);
+  }
+  (active === 'simd' ? engine.simd : engine.scalar).fill(SOURCE, n, channels, P, R, PROPERTY, CONTEXT);
+  for (let c = 0; c < channels; c++) {
+    const at = [P, R, PROPERTY, CONTEXT][c] >> 2;
+    planes[c].set(i32.subarray(at, at + n));
+  }
+  return true;
+}
+
+/** Select this optional door explicitly. Missing/blocked WASM or SIMD returns to JS.
+ * `parts` is a deterministic per-realm ablation switch, not a timing-based decision.
+ * Set it before an encode, never inside a progress callback.
+ */
+function configureKernels(mode = 'auto', parts) {
+  if (!['off', 'auto', 'scalar', 'simd'].includes(mode)) throw new RangeError('Unknown JXL kernel mode: ' + mode);
+  kernelHooks.channel = kernelHooks.weighted = kernelHooks.fill = null; active = 'off';
+  if (mode === 'off') return active;
+  try {
+    if (typeof WebAssembly !== 'object' || !WebAssembly.validate || new Uint8Array(new Uint32Array([1]).buffer)[0] !== 1) return active;
+    // A SIMD request is not silently tested as scalar: unsupported SIMD is JS.
+    const simd = mode !== 'scalar' && SIMD && WebAssembly.validate(decode(SIMD_PROBE));
+    if (mode !== 'scalar' && !simd) return active;
+    engine ||= createEngine();
+    if (simd && !engine.simd) {
+      const names = new Map(Object.entries(new WebAssembly.Instance(new WebAssembly.Module(decode(SIMD)), {env: {memory: engine.memory}}).exports));
+      engine.simd = {residual: names.get('residual'), fill: names.get('fill')};
+    }
+    active = simd ? 'simd' : 'scalar';
+    const enabled = parts ? new Map(Object.entries(parts)) : null;
+    if (!enabled || enabled.get('channel')) kernelHooks.channel = channel;
+    if (!enabled || enabled.get('weighted')) kernelHooks.weighted = weighted;
+    if (!enabled || enabled.get('fill')) kernelHooks.fill = fill;
+  } catch { active = 'off'; kernelHooks.channel = kernelHooks.weighted = kernelHooks.fill = null; }
+  return active;
+}
+function kernelMode() { return active; }
+return {configureKernels, kernelMode};
+})();

package/local.mjs

@@ -2,11 +2,12 @@
 // Effort-only Modular modelling. Every group owns its tree and histograms; a bounded group of samples is the
 // working set, and the complete candidate competes against every lower rung at the door.
 import {BitWriter, packSigned} from './bits.mjs';
-import {writeImageHeader, writeModularFrameHeader, groupLayout, assembleCodestream, GROUP_DIM} from './frame.mjs';
+import {writeImageHeader, writeModularFrameHeader, groupLayout, groupRect, groupPass, assembleCodestream, GROUP_DIM} from './frame.mjs';
 import {buildCode, writePrefixCode, countToken, writeHybrid} from './prefix.mjs';
 import {ALPHABET, LZ77, RESIDUAL_CONFIG, leaf, split, channelTree, writeTree, writeModularHeader, writeChannelHistograms} from './modular.mjs';
 import {codeWeighted} from './weighted.mjs';
 import {admitOutputSize} from './admit.mjs';
+import {planeFill} from './lossless.mjs';
 
 const localRaw = s => Math.max(0, s < 224 ? s - 1 : s - 236);
 const price = freqs => {
@@ -137,11 +138,23 @@ function writeModel(writer, plans) {
   };
 }
 
-export function* localSteps(rgba, width, height, shape, colorSpace, rung = 4, usePalette = false) {
+// A group's own trees and histograms, here or in a pool's worker: the group's section, its bytes returned.
+export function localGroup(setup) {
+  const fill = planeFill(setup), planes = Array.from({length: setup.palette ? 1 : setup.channels}, () => new Int16Array(GROUP_DIM * GROUP_DIM));
+  return (rgba, stride, x0, y0, w, h) => {
+    fill(planes, rgba, stride, x0, y0, w, h);
+    const section = new BitWriter(w * h * planes.length + 256);
+    writeModularHeader(section, {useGlobalTree: false});
+    writeModel(section, plansOf(planes, w, h, setup.rung))();
+    return section.finish();
+  };
+}
+
+export function* localSteps(rgba, width, height, shape, colorSpace, rung = 4, usePalette = false, pooled) {
   const {channels} = shape, layout = groupLayout(width, height), groups = layout.groupsX * layout.groupsY;
   const palette = usePalette ? shape.palette : null;
   if (usePalette && !palette) return null;
-  const planes = Array.from({length: palette ? 1 : channels}, () => new Int16Array(GROUP_DIM * GROUP_DIM));
+  const setup = {channels, alpha: shape.alpha, palette: palette && palette.colours, rung};
   const header = new BitWriter(256);
   writeImageHeader(header, width, height, shape.colour, shape.alpha, {colorSpace});
   writeModularFrameHeader(header, {alpha: shape.alpha});
@@ -155,43 +168,34 @@ export function* localSteps(rgba, width, height, shape, colorSpace, rung = 4, us
   }
   const global = new BitWriter(4096), sections = [];
   let sectionBytes = 0;
-  const appendSection = writer => {
-    // Refuse before copying a completed section or retaining later groups of an oversized optional candidate.
-    sectionBytes += Math.ceil(writer.bitLength / 8); admitOutputSize(sectionBytes);
-    sections.push(writer.finish());
+  const appendSection = bytes => {
+    // Refuse before retaining later groups of an oversized optional candidate.
+    sectionBytes += bytes.length; admitOutputSize(sectionBytes);
+    sections.push(bytes);
   };
   global.write(1, 1); global.write(1, 1);
-  if (!layout.single) {
-    let write;
-    if (palettePlans) write = writeModel(global, palettePlans);
-    else {
-      const leaves = planes.map(() => leaf(5));
-      writeChannelHistograms(global, writeTree(global, channelTree(leaves)), planes.map(() => new Uint32Array(ALPHABET)), l => leaves.indexOf(l));
-    }
+  if (layout.single) {
+    // One group: everything in the global section, the palette's plans before the picture's.
+    const planes = Array.from({length: palette ? 1 : channels}, () => new Int16Array(GROUP_DIM * GROUP_DIM));
+    planeFill(setup)(planes, rgba, width, 0, 0, width, height);
+    const write = writeModel(global, [...palettePlans || [], ...plansOf(planes, width, height, rung)]);
     writeModularHeader(global, {transforms});
-    if (write) write();
-    appendSection(global);
-    for (let i = 0; i < layout.dcGroupsX * layout.dcGroupsY + 1; i++) sections.push(new Uint8Array(0));
+    write(); appendSection(global.finish());
+    if (yield 1) return null;
+    return assembleCodestream(header, sections);
   }
-  for (let g = 0; g < groups; g++) {
-    const x0 = g % layout.groupsX * GROUP_DIM, y0 = (g / layout.groupsX | 0) * GROUP_DIM;
-    const w = Math.min(GROUP_DIM, width - x0), h = Math.min(GROUP_DIM, height - y0);
-    for (let y = 0; y < h; y++) for (let x = 0, at = y * w, i = ((y0 + y) * width + x0) * 4; x < w; x++, at++, i += 4) {
-      if (palette) planes[0][at] = palette.index.get(palette.key(i));
-      else if (channels >= 3) {
-        const co = rgba[i] - rgba[i + 2], tmp = rgba[i + 2] + (co >> 1), cg = rgba[i + 1] - tmp;
-        planes[0][at] = tmp + (cg >> 1); planes[1][at] = co; planes[2][at] = cg;
-        if (channels === 4) planes[3][at] = rgba[i + 3];
-      } else { planes[0][at] = rgba[i]; if (channels === 2) planes[1][at] = rgba[i + 3]; }
-    }
-    const picture = plansOf(planes, w, h, rung);
-    const plans = palette && layout.single ? [...palettePlans, ...picture] : picture;
-    const section = layout.single ? global : new BitWriter(w * h * planes.length + 256);
-    if (!layout.single) writeModularHeader(section, {useGlobalTree: false});
-    const write = writeModel(section, plans);
-    if (layout.single) writeModularHeader(section, {transforms});
-    write(); appendSection(section);
-    if (yield (g + 1) / groups) return null;
+  let write;
+  if (palettePlans) write = writeModel(global, palettePlans);
+  else {
+    const leaves = Array.from({length: channels}, () => leaf(5));
+    writeChannelHistograms(global, writeTree(global, channelTree(leaves)), leaves.map(() => new Uint32Array(ALPHABET)), l => leaves.indexOf(l));
   }
+  writeModularHeader(global, {transforms});
+  if (write) write();
+  appendSection(global.finish());
+  for (let i = 0; i < layout.dcGroupsX * layout.dcGroupsY + 1; i++) sections.push(new Uint8Array(0));
+  const group = localGroup(setup);
+  if ((yield* groupPass({pooled, kind: 'local', setup, at: g => (g + 1) / groups, stop: () => true},
+    groups, g => appendSection(group(rgba, width, ...groupRect(layout, width, height, g))), (g, bytes) => appendSection(bytes))) === null) return null;
   return assembleCodestream(header, sections);
 }

package/lossless-coding.mjs

@@ -0,0 +1,30 @@
+// Rapier's JPEG XL encoder: exact hybrid-integer prices for lossless residuals. MIT (LICENSE).
+// Raw literal counts retain the low-bit distribution that an exponent-only histogram throws away. The
+// run-length alphabet is separate while counting; projection restores it at the standard LZ77 boundary.
+import {BitWriter, floorLog2} from './bits.mjs';
+import {uintConfig, hybridToken, buildCode, writePrefixCode, writeUintConfig} from './prefix.mjs';
+import {ALPHABET} from './modular.mjs';
+
+const LOSSLESS_INTEGER_CONFIGS = [uintConfig(0), uintConfig(4), uintConfig(4, 1, 1), uintConfig(3, 0, 1)];
+
+export function losslessCoding(raw) {
+  const end = raw.length - 33, token = [0, 0, 0];
+  let original, best;
+  for (const config of LOSSLESS_INTEGER_CONFIGS) {
+    const freqs = new Uint32Array(ALPHABET);
+    let extra = 0;
+    for (let value = 0; value < end; value++) if (raw[value]) {
+      hybridToken(config, value, token);
+      freqs[token[0]] += raw[value]; extra += raw[value] * token[1];
+    }
+    for (let s = 0; s < 33; s++) { freqs[224 + s] = raw[end + s]; extra += raw[end + s] * Math.max(0, s - 12); }
+    const code = buildCode(freqs), w = new BitWriter(128);
+    writeUintConfig(w, config); writePrefixCode(w, code);
+    let bits = w.bitLength + extra + (code.alphabetSize === 1 ? 1 : 5 + floorLog2(code.alphabetSize - 1));
+    for (let s = 0; s < freqs.length; s++) if (freqs[s]) bits += freqs[s] * code.lengths[s];
+    const model = {config, freqs, bits, extra};
+    if (!original) original = model;
+    if (!best || bits < best.bits) best = model;
+  }
+  return [original, best];
+}