rapier-jxl 1.1.16

package/jpeg.mjs

@@ -0,0 +1,260 @@
+// Rapier's JPEG XL encoder: reading a JPEG's coefficients. MIT (LICENSE).
+// A JPEG is not decoded to pixels here: its quantised DCT coefficients are recovered from the Huffman-coded scans
+// (baseline, extended sequential and progressive, 8-bit, grey or three components) so they can be carried into a
+// JPEG XL frame as they are. Anything else (arithmetic coding, 12-bit, lossless, hierarchical, four components, a
+// height left to a DNL marker) is refused with JXL_JPEG and the picture takes the ordinary path instead.
+
+export const ZIGZAG = [0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
+  35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63];
+
+export function jpegError(message) { return Object.assign(new Error('JPEG: ' + message), {code: 'JXL_JPEG'}); }
+
+// A 16-bit lookup: entry = (code length << 8) | symbol, 0 for no code.
+function buildHuffman(counts, symbols) {
+  const lookup = new Uint16Array(65536);
+  let code = 0, k = 0;
+  for (let length = 1; length <= 16; length++) {
+    for (let i = 0; i < counts[length - 1]; i++) {
+      const symbol = symbols[k++], start = code << (16 - length), n = 1 << (16 - length);
+      if (start + n > 65536) throw jpegError('bad Huffman table');
+      lookup.fill((length << 8) | symbol, start, start + n);
+      code++;
+    }
+    code <<= 1;
+  }
+  return lookup;
+}
+
+export function parseJPEG(bytes) {
+  if (!(bytes.length > 4) || bytes[0] !== 0xFF || bytes[1] !== 0xD8) throw jpegError('not a JPEG');
+  const quant = [], huffman = [[], []];
+  let frame = null, restartInterval = 0, adobeTransform = -1, jfif = false, orientation = 1, pos = 2;
+  const u16 = at => (bytes[at] << 8) | bytes[at + 1];
+  for (;;) {
+    if (pos >= bytes.length) { if (frame && frame.scans) break; throw jpegError('truncated'); }
+    if (bytes[pos] !== 0xFF) throw jpegError('marker expected');
+    while (bytes[pos] === 0xFF) pos++;
+    const marker = bytes[pos++];
+    if (marker === 0xD9) break;
+    if (marker === 0xD8) throw jpegError('a second start');
+    if ((marker >= 0xD0 && marker <= 0xD7) || marker === 0x01) continue;
+    if (pos + 2 > bytes.length) throw jpegError('truncated');
+    const length = u16(pos), segment = pos + 2, end = pos + length;
+    if (length < 2 || end > bytes.length) throw jpegError('bad segment');
+    pos = end;
+    if (marker === 0xDB) {
+      for (let at = segment; at < end;) {
+        const pq = bytes[at] >> 4, tq = bytes[at] & 15;
+        if (pq > 1 || tq > 3) throw jpegError('bad quantisation table');
+        at++;
+        const table = new Int32Array(64);
+        for (let k = 0; k < 64; k++) { table[ZIGZAG[k]] = pq ? u16(at) : bytes[at]; at += pq ? 2 : 1; }
+        quant[tq] = table;
+      }
+    } else if (marker === 0xC4) {
+      for (let at = segment; at < end;) {
+        const tc = bytes[at] >> 4, th = bytes[at] & 15;
+        if (tc > 1 || th > 3) throw jpegError('bad Huffman table');
+        at++;
+        const counts = bytes.subarray(at, at + 16);
+        let total = 0;
+        for (const c of counts) total += c;
+        huffman[tc][th] = buildHuffman(counts, bytes.subarray(at + 16, at + 16 + total));
+        at += 16 + total;
+      }
+    } else if (marker === 0xC0 || marker === 0xC1 || marker === 0xC2) {
+      if (frame) throw jpegError('two frames');
+      if (bytes[segment] !== 8) throw jpegError('only 8-bit samples');
+      const height = u16(segment + 1), width = u16(segment + 3), count = bytes[segment + 5];
+      if (!width || !height) throw jpegError('a height left to a DNL marker');
+      if (count !== 1 && count !== 3) throw jpegError('only grey or three components');
+      const components = [];
+      for (let i = 0, at = segment + 6; i < count; i++, at += 3) {
+        const h = bytes[at + 1] >> 4, v = bytes[at + 1] & 15;
+        if (h < 1 || h > 4 || v < 1 || v > 4) throw jpegError('bad sampling');
+        components.push({id: bytes[at], h, v, tq: bytes[at + 2], pred: 0});
+      }
+      const hmax = Math.max(...components.map(c => c.h)), vmax = Math.max(...components.map(c => c.v));
+      const mcusX = Math.ceil(width / (8 * hmax)), mcusY = Math.ceil(height / (8 * vmax));
+      for (const c of components) {
+        c.blocksW = Math.ceil(Math.ceil(width * c.h / hmax) / 8); c.blocksH = Math.ceil(Math.ceil(height * c.v / vmax) / 8);
+        c.stride = mcusX * c.h; c.rows = mcusY * c.v;
+        c.coeffs = new Int16Array(c.stride * c.rows * 64);
+      }
+      frame = {progressive: marker === 0xC2, width, height, components, hmax, vmax, mcusX, mcusY, scans: 0};
+    } else if (marker === 0xC3 || (marker >= 0xC5 && marker <= 0xC7) || (marker >= 0xC9 && marker <= 0xCB) || (marker >= 0xCD && marker <= 0xCF)) {
+      throw jpegError('lossless, hierarchical or arithmetic coding');
+    } else if (marker === 0xDD) restartInterval = u16(segment);
+    else if (marker === 0xDC) throw jpegError('a DNL marker');
+    else if (marker === 0xDA) {
+      if (!frame) throw jpegError('a scan before the frame');
+      const n = bytes[segment], scan = [];
+      let at = segment + 1;
+      for (let i = 0; i < n; i++, at += 2) {
+        const component = frame.components.find(c => c.id === bytes[at]);
+        if (!component) throw jpegError('a scan of an unknown component');
+        scan.push({component, dc: huffman[0][bytes[at + 1] >> 4], ac: huffman[1][bytes[at + 1] & 15]});
+      }
+      const ss = bytes[at], se = bytes[at + 1], ah = bytes[at + 2] >> 4, al = bytes[at + 2] & 15;
+      pos = decodeScan(bytes, end, frame, scan, ss, se, ah, al, restartInterval);
+      frame.scans++;
+    } else if (marker === 0xE0) {
+      if (bytes[segment] === 0x4A && bytes[segment + 1] === 0x46 && bytes[segment + 2] === 0x49 && bytes[segment + 3] === 0x46) jfif = true;
+    } else if (marker === 0xE1) {
+      if (orientation === 1 && bytes[segment] === 0x45 && bytes[segment + 1] === 0x78 && bytes[segment + 2] === 0x69 && bytes[segment + 3] === 0x66) orientation = exifOrientation(bytes, segment + 6, end);
+    } else if (marker === 0xEE) {
+      if (length >= 14 && bytes[segment] === 0x41 && bytes[segment + 1] === 0x64 && bytes[segment + 2] === 0x6F && bytes[segment + 3] === 0x62 && bytes[segment + 4] === 0x65) adobeTransform = bytes[segment + 11];
+    }
+  }
+  if (!frame || !frame.scans) throw jpegError('no picture');
+  for (const c of frame.components) { if (!quant[c.tq]) throw jpegError('a component without its quantisation table'); c.quant = quant[c.tq]; }
+  // Colour as libjxl reads it: JFIF means YCbCr; else an Adobe marker decides; else component ids spelling RGB.
+  let rgb = false;
+  if (frame.components.length === 3 && !jfif) {
+    if (adobeTransform >= 0) rgb = adobeTransform === 0;
+    else rgb = frame.components[0].id === 0x52 && frame.components[1].id === 0x47 && frame.components[2].id === 0x42;
+  }
+  return {width: frame.width, height: frame.height, components: frame.components, progressive: frame.progressive, ycbcr: !rgb, orientation};
+}
+
+// The Exif orientation tag (0x0112) of the first image directory, 1 when absent or unreadable.
+function exifOrientation(bytes, start, end) {
+  const big = bytes[start] === 0x4D && bytes[start + 1] === 0x4D;
+  if (!big && !(bytes[start] === 0x49 && bytes[start + 1] === 0x49)) return 1;
+  const u16 = at => at + 2 > end ? 0 : big ? (bytes[at] << 8) | bytes[at + 1] : bytes[at] | (bytes[at + 1] << 8);
+  const u32 = at => at + 4 > end ? 0 : big ? ((bytes[at] << 24) | (bytes[at + 1] << 16) | (bytes[at + 2] << 8) | bytes[at + 3]) >>> 0 : (bytes[at] | (bytes[at + 1] << 8) | (bytes[at + 2] << 16) | (bytes[at + 3] << 24)) >>> 0;
+  if (u16(start + 2) !== 42) return 1;
+  const ifd = start + u32(start + 4), entries = u16(ifd);
+  for (let i = 0, at = ifd + 2; i < entries && at + 12 <= end; i++, at += 12) {
+    if (u16(at) !== 0x0112) continue;
+    const value = u16(at + 8);
+    return value >= 1 && value <= 8 ? value : 1;
+  }
+  return 1;
+}
+
+function decodeScan(bytes, start, frame, scan, ss, se, ah, al, restartInterval) {
+  let pos = start, buffer = 0, count = 0, marker = false;
+  const fill = () => {
+    while (count <= 24) {
+      let byte = 0;
+      if (!marker) {
+        if (pos >= bytes.length) marker = true;
+        else {
+          byte = bytes[pos];
+          if (byte === 0xFF) {
+            const next = bytes[pos + 1];
+            if (next === 0) pos += 2;
+            else if (next === 0xFF) { pos++; continue; }
+            else { marker = true; byte = 0; }
+          } else pos++;
+        }
+      }
+      buffer = ((buffer << 8) | byte) >>> 0; count += 8;
+    }
+  };
+  const receive = n => { if (!n) return 0; fill(); const value = (buffer >>> (count - n)) & ((1 << n) - 1); count -= n; return value; };
+  const extend = (value, n) => value < (1 << (n - 1)) ? value - (1 << n) + 1 : value;
+  const decode = table => {
+    if (!table) throw jpegError('a scan without its Huffman table');
+    fill();
+    const entry = table[(buffer >>> (count - 16)) & 0xFFFF];
+    if (!entry) throw jpegError('bad Huffman code');
+    count -= entry >> 8;
+    return entry & 255;
+  };
+  const restart = () => {
+    buffer = 0; count = 0; marker = false;
+    while (pos < bytes.length && !(bytes[pos] === 0xFF && bytes[pos + 1] >= 0xD0 && bytes[pos + 1] <= 0xD7)) pos++;
+    if (pos >= bytes.length) throw jpegError('a restart marker missing');
+    pos += 2;
+    for (const s of scan) s.component.pred = 0;
+    eobrun = 0;
+  };
+  let eobrun = 0;
+  const single = scan.length === 1, progressive = frame.progressive;
+  const baseline = (s, coeffs, at) => {
+    const t = decode(s.dc), diff = t ? extend(receive(t), t) : 0;
+    s.component.pred += diff;
+    coeffs[at] = s.component.pred;
+    for (let k = 1; k < 64;) {
+      const rs = decode(s.ac), r = rs >> 4, size = rs & 15;
+      if (!size) { if (r === 15) { k += 16; continue; } break; }
+      k += r;
+      if (k > 63) throw jpegError('coefficients past the block');
+      coeffs[at + ZIGZAG[k]] = extend(receive(size), size);
+      k++;
+    }
+  };
+  const dcFirst = (s, coeffs, at) => {
+    const t = decode(s.dc), diff = t ? extend(receive(t), t) : 0;
+    s.component.pred += diff;
+    coeffs[at] = s.component.pred << al;
+  };
+  const dcRefine = (s, coeffs, at) => { if (receive(1)) coeffs[at] |= 1 << al; };
+  const acFirst = (s, coeffs, at) => {
+    if (eobrun > 0) { eobrun--; return; }
+    for (let k = ss; k <= se;) {
+      const rs = decode(s.ac), r = rs >> 4, size = rs & 15;
+      if (!size) {
+        if (r < 15) { eobrun = (1 << r) - 1 + (r ? receive(r) : 0); break; }
+        k += 16; continue;
+      }
+      k += r;
+      if (k > 63) throw jpegError('coefficients past the block');
+      coeffs[at + ZIGZAG[k]] = extend(receive(size), size) * (1 << al);
+      k++;
+    }
+  };
+  const acRefine = (s, coeffs, at) => {
+    const p1 = 1 << al, m1 = -1 << al;
+    let k = ss;
+    if (eobrun <= 0) {
+      for (; k <= se; k++) {
+        const rs = decode(s.ac);
+        let r = rs >> 4, value = 0;
+        const size = rs & 15;
+        if (size) { if (size !== 1) throw jpegError('a bad refinement code'); value = receive(1) ? p1 : m1; }
+        else if (r !== 15) { eobrun = 1 << r; if (r) eobrun += receive(r); break; }
+        for (; k <= se; k++) {
+          const z = at + ZIGZAG[k];
+          if (coeffs[z] !== 0) { if (receive(1) && (coeffs[z] & p1) === 0) coeffs[z] += coeffs[z] >= 0 ? p1 : m1; }
+          else if (--r < 0) break;
+        }
+        if (value && k <= se) coeffs[at + ZIGZAG[k]] = value;
+      }
+    }
+    if (eobrun > 0) {
+      for (; k <= se; k++) {
+        const z = at + ZIGZAG[k];
+        if (coeffs[z] !== 0 && receive(1) && (coeffs[z] & p1) === 0) coeffs[z] += coeffs[z] >= 0 ? p1 : m1;
+      }
+      eobrun--;
+    }
+  };
+  const block = !progressive ? baseline : ss === 0 ? (ah === 0 ? dcFirst : dcRefine) : (ah === 0 ? acFirst : acRefine);
+  if (progressive && ss > 0 && !single) throw jpegError('an interleaved AC scan');
+  if (progressive && (se > 63 || ss > se)) throw jpegError('a bad spectral selection');
+  for (const s of scan) s.component.pred = 0;
+  const first = scan[0].component;
+  const total = single ? first.blocksW * first.blocksH : frame.mcusX * frame.mcusY;
+  for (let unit = 0; unit < total; unit++) {
+    if (restartInterval && unit > 0 && unit % restartInterval === 0) restart();
+    if (single) {
+      const by = (unit / first.blocksW) | 0, bx = unit - by * first.blocksW;
+      block(scan[0], first.coeffs, (by * first.stride + bx) * 64);
+    } else {
+      const my = (unit / frame.mcusX) | 0, mx = unit - my * frame.mcusX;
+      for (const s of scan) {
+        const c = s.component;
+        for (let v = 0; v < c.v; v++) for (let h = 0; h < c.h; h++) block(s, c.coeffs, ((my * c.v + v) * c.stride + mx * c.h + h) * 64);
+      }
+    }
+  }
+  // Past the scan's data to the next marker.
+  while (pos < bytes.length) {
+    if (bytes[pos] === 0xFF && bytes[pos + 1] !== 0 && bytes[pos + 1] !== 0xFF && !(bytes[pos + 1] >= 0xD0 && bytes[pos + 1] <= 0xD7)) break;
+    pos++;
+  }
+  return pos;
+}

package/lossless.mjs

@@ -0,0 +1,131 @@
+// Rapier's JPEG XL encoder: lossless pictures. MIT (LICENSE).
+// The design of libjxl's fast lossless path, written for Rapier: 8-bit grey, grey+alpha, RGB or RGBA; an opaque
+// alpha is dropped and a grey picture keeps one channel; up to 512 colours become a palette; colour goes through
+// the reversible YCoCg transform; every channel is predicted by the clamped gradient and coded with one prefix
+// code per channel, zero runs as LZ77 copies; groups of 256x256 pixels, each an independent section.
+import {BitWriter} from './bits.mjs';
+import {writeImageHeader, writeModularFrameHeader, groupLayout, assembleCodestream, GROUP_DIM} from './frame.mjs';
+import {PREDICTOR, ALPHABET, leaf, channelTree, writeTree, writeModularHeader, writeChannelHistograms, codeChannel} from './modular.mjs';
+
+const MAX_PALETTE = 512;
+
+// What the picture is: which channels it needs and, when few colours, its palette.
+export function inspectPixels(rgba, width, height, {palette: wantPalette = true} = {}) {
+  const pixels = width * height;
+  let opaque = true, grey = true;
+  for (let i = 0, p = 0; p < pixels; p++, i += 4) {
+    if (rgba[i + 3] !== 255) { opaque = false; if (!grey) break; }
+    if (rgba[i] !== rgba[i + 1] || rgba[i] !== rgba[i + 2]) { grey = false; if (!opaque) break; }
+  }
+  const colour = grey ? 1 : 3, alpha = !opaque, channels = colour + (alpha ? 1 : 0);
+  // The packed colour of a pixel: channel c in byte c, as the palette rows are laid out.
+  const key = i => grey
+    ? (alpha ? rgba[i] + rgba[i + 3] * 256 : rgba[i])
+    : rgba[i] + rgba[i + 1] * 256 + rgba[i + 2] * 65536 + (alpha ? rgba[i + 3] * 16777216 : 0);
+  const seen = new Map();
+  let palette = null;
+  for (let i = 0, p = 0; wantPalette && p < pixels; p++, i += 4) {
+    const k = key(i);
+    if (k === 0 || seen.has(k)) continue;
+    seen.set(k, 1);
+    if (seen.size >= MAX_PALETTE) break;
+  }
+  if (wantPalette && seen.size < MAX_PALETTE) {
+    const entries = [...seen.keys()];
+    const byte = (k, c) => Math.floor(k / 256 ** c) % 256;
+    let lowest = 255, highest = 0;
+    for (const k of entries) { const g = byte(k, 1); if (g < lowest) lowest = g; if (g > highest) highest = g; }
+    // A grey ramp without holes gains nothing from a palette.
+    const ramp = colour === 1 && !alpha && (() => { let lo = 255, hi = 0; for (const k of entries) { if (k < lo) lo = k; if (k > hi) hi = k; } return hi - lo < entries.length * 1.4; })();
+    if (!ramp) {
+      const weight = k => (0.299 * byte(k, 0) + 0.587 * byte(k, 1) + 0.114 * byte(k, 2) + 0.01) * (channels === 4 ? byte(k, 3) : 1);
+      entries.sort((a, b) => weight(a) - weight(b));
+      const index = new Map([[0, 0]]);
+      entries.forEach((k, at) => index.set(k, at + 1));
+      palette = {colours: [0, ...entries], index, key, byte};
+    }
+  }
+  return {colour, alpha, channels, palette};
+}
+
+export function encodeLossless(rgba, width, height, {shape = inspectPixels(rgba, width, height)} = {}) {
+  const {channels, palette} = shape;
+  const layout = groupLayout(width, height);
+  const streamChannels = palette ? 2 : channels;  // the palette's meta channel and the index channel
+  const leaves = Array.from({length: streamChannels}, () => leaf(PREDICTOR.gradient));
+  const tree = channelTree(leaves);
+  const transforms = palette
+    ? [{type: 'palette', beginC: 0, numC: channels, nbColors: palette.colours.length}]
+    : channels >= 3 ? [{type: 'rct', beginC: 0, rctType: 6}] : [];
+
+  // Channel planes of a group rectangle, computed straight from the pixels.
+  const planes = Array.from({length: streamChannels}, () => new Int32Array(GROUP_DIM * GROUP_DIM));
+  const fill = (x0, y0, w, h) => {
+    for (let y = 0; y < h; y++) {
+      let i = ((y0 + y) * width + x0) * 4, at = y * w;
+      for (let x = 0; x < w; x++, i += 4, at++) {
+        if (palette) { planes[0][at] = palette.index.get(palette.key(i)); continue; }
+        if (channels >= 3) {
+          const r = rgba[i], g = rgba[i + 1], b = rgba[i + 2];
+          const co = r - b, tmp = b + (co >> 1), cg = g - 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]; }
+      }
+    }
+  };
+  // The palette meta channel: one row per channel, one column per colour.
+  let paletteRows = null;
+  if (palette) {
+    const n = palette.colours.length;
+    paletteRows = new Int32Array(n * channels);
+    palette.colours.forEach((k, at) => { for (let c = 0; c < channels; c++) paletteRows[c * n + at] = palette.byte(k, c); });
+  }
+  // The image channels of a section: in the global section they follow the meta channel; in a group they start at 0.
+  const pictureLeaf = c => leaves[palette ? (layout.single ? 1 : 0) : c];
+  const pictureChannels = palette ? 1 : channels;
+
+  const forGroups = visit => {
+    for (let gy = 0; gy < layout.groupsY; gy++) for (let gx = 0; gx < layout.groupsX; gx++) {
+      const x0 = gx * GROUP_DIM, y0 = gy * GROUP_DIM, w = Math.min(GROUP_DIM, width - x0), h = Math.min(GROUP_DIM, height - y0);
+      fill(x0, y0, w, h);
+      visit(gy * layout.groupsX + gx, w, h);
+    }
+  };
+
+  // Pass one: token histograms per leaf.
+  const freqs = leaves.map(() => new Uint32Array(ALPHABET)), freqOf = l => freqs[leaves.indexOf(l)];
+  if (paletteRows) codeChannel(null, freqOf(leaves[0]), paletteRows, palette.colours.length, channels, leaves[0]);
+  forGroups((g, w, h) => { for (let c = 0; c < pictureChannels; c++) codeChannel(null, freqOf(pictureLeaf(c)), planes[c], w, h, pictureLeaf(c)); });
+
+  // Pass two: the sections.
+  const header = new BitWriter(256);
+  writeImageHeader(header, width, height, shape.colour, shape.alpha);
+  writeModularFrameHeader(header, {alpha: shape.alpha});
+  const global = new BitWriter(4096);
+  global.write(1, 1);  // default DC quantisation
+  global.write(1, 1);  // a global tree
+  const ordered = writeTree(global, tree);
+  const histograms = writeChannelHistograms(global, ordered, freqs, l => leaves.indexOf(l));
+  const codeOf = l => histograms[leaves.indexOf(l) + 1].code;
+  writeModularHeader(global, {useGlobalTree: true, transforms});
+  if (paletteRows) codeChannel(global, codeOf(leaves[0]), paletteRows, palette.colours.length, channels, leaves[0]);
+  const sections = [];
+  if (layout.single) {
+    forGroups((g, w, h) => { for (let c = 0; c < pictureChannels; c++) codeChannel(global, codeOf(pictureLeaf(c)), planes[c], w, h, pictureLeaf(c)); });
+    global.zeroPadToByte();
+    sections.push(global.finish());
+  } else {
+    global.zeroPadToByte();
+    sections.push(global.finish());
+    for (let i = 0; i < layout.dcGroupsX * layout.dcGroupsY + 1; i++) sections.push(new Uint8Array(0));
+    forGroups((g, w, h) => {
+      const section = new BitWriter(w * h * pictureChannels + 64);
+      writeModularHeader(section, {useGlobalTree: true, transforms: []});
+      for (let c = 0; c < pictureChannels; c++) codeChannel(section, codeOf(pictureLeaf(c)), planes[c], w, h, pictureLeaf(c));
+      section.zeroPadToByte();
+      sections.push(section.finish());
+    });
+  }
+  return assembleCodestream(header, sections);
+}

package/lossy.mjs

@@ -0,0 +1,125 @@
+// Rapier's JPEG XL encoder: lossy pictures. MIT (LICENSE).
+// Lossy modular as libjxl encodes it: the reversible YCoCg transform, the Squeeze transform to its default
+// depth, then each squeezed channel quantised by a step that halves with every level (chroma coarser than luma),
+// carried as the multiplier of that channel's tree leaf so the decoder scales the residuals back. The finest
+// low-pass image is kept exact. Quality maps to libjxl's distance (90 is 1.0).
+import {BitWriter} from './bits.mjs';
+import {writeImageHeader, writeModularFrameHeader, groupLayout, assembleCodestream, GROUP_DIM, DC_GROUP_DIM} from './frame.mjs';
+import {PREDICTOR, ALPHABET, leaf, channelTree, streamTree, writeTree, writeModularHeader, writeChannelHistograms, codeChannel} from './modular.mjs';
+import {forwardSqueeze} from './squeeze.mjs';
+import {inspectPixels} from './lossless.mjs';
+
+const LUMA_STEPS = [163.84, 81.92, 40.96, 20.48, 10.24, 5.12, 2.56, 1.28, 0.64, 0.32, 0.16, 0.08, 0.04, 0.02, 0.01, 0.005];
+const CHROMA_STEPS = [1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1, 0.5, 0.5, 0.5, 0.5, 0.5];
+const QUALITY_FACTOR = 0.35, LUMA_FACTOR = 1.1;
+
+// libjxl's JxlEncoderDistanceFromQuality.
+export function distanceFromQuality(quality) {
+  return quality >= 100 ? 0 : quality >= 30 ? 0.1 + (100 - quality) * 0.09 : 53 / 3000 * quality * quality - 23 / 20 * quality + 25;
+}
+
+// The quantisation step of a squeezed channel: `component` 0 luma, 1-2 chroma, 3 an extra channel.
+export function quantiserFor(component, hshift, vshift, distance) {
+  let shift = Math.min(16, hshift + vshift);
+  if (shift > 0) shift--;
+  // An extra channel (alpha) is quantised at half the colour steps: its edges fringe before colour does.
+  const base = component === 3 ? 0.125 * distance : 0.25 * distance ** 1.2;
+  const q = component === 1 || component === 2 ? base * QUALITY_FACTOR * CHROMA_STEPS[shift] : base * QUALITY_FACTOR * LUMA_FACTOR * LUMA_STEPS[shift];
+  return Math.max(1, Math.floor(q));
+}
+
+export function encodeLossy(rgba, width, height, {quality = 90, shape = inspectPixels(rgba, width, height, {palette: false})} = {}) {
+  const distance = distanceFromQuality(quality);
+  if (!(distance > 0)) throw new Error('lossy encoding needs a quality below 100');
+  const {colour, alpha, channels: count} = shape;
+  const pixels = width * height;
+  // Full planes in the transformed colour space.
+  const planes = Array.from({length: count}, () => new Int16Array(pixels));
+  for (let i = 0, p = 0; p < pixels; p++, i += 4) {
+    if (colour === 3) {
+      const r = rgba[i], g = rgba[i + 1], b = rgba[i + 2], co = r - b, tmp = b + (co >> 1), cg = g - tmp;
+      planes[0][p] = tmp + (cg >> 1); planes[1][p] = co; planes[2][p] = cg;
+    } else planes[0][p] = rgba[i];
+    if (alpha) planes[count - 1][p] = rgba[i + 3];
+  }
+  const channels = planes.map((data, c) => ({w: width, h: height, hshift: 0, vshift: 0, data, component: colour === 3 ? c : c === 0 ? 0 : 3}));
+  const squeezed = forwardSqueeze(channels);
+  const predictorOf = ch => ch.residual ? PREDICTOR.zero : PREDICTOR.gradient;
+  const quantiserOf = ch => quantiserFor(ch.component, ch.hshift, ch.vshift, distance);
+  const transforms = [...(colour === 3 ? [{type: 'rct', beginC: 0, rctType: 6}] : []), {type: 'squeeze', params: []}];
+
+  // The sections and the channel pieces each holds, in the decoder's order: the global section takes the channels
+  // up to the first wider or taller than a group; DC groups take the rest with both shifts of three or more, AC
+  // groups the rest; a piece is the group's rectangle at the channel's scale. A channel's number inside a section
+  // is its place among that section's pieces, so every section gets its own subtree under the stream property.
+  const layout = groupLayout(width, height), dcGroups = layout.dcGroupsX * layout.dcGroupsY, acGroups = layout.groupsX * layout.groupsY;
+  let globalCount = 0;
+  while (globalCount < squeezed.length && squeezed[globalCount].w <= GROUP_DIM && squeezed[globalCount].h <= GROUP_DIM) globalCount++;
+  const rectOf = (ch, x0, y0, dim) => {
+    const x = x0 >> ch.hshift, y = y0 >> ch.vshift;
+    return {x, y, w: Math.min(ch.w, x + (dim >> ch.hshift)) - x, h: Math.min(ch.h, y + (dim >> ch.vshift)) - y};
+  };
+  const sections = [{index: 0, streamId: 0, pieces: []}];
+  for (let c = 0; c < globalCount; c++) sections[0].pieces.push({c, rect: {x: 0, y: 0, w: squeezed[c].w, h: squeezed[c].h}});
+  if (!layout.single) {
+    for (let g = 0; g < dcGroups; g++) {
+      const gx = g % layout.dcGroupsX, gy = (g / layout.dcGroupsX) | 0, section = {index: 1 + g, streamId: 1 + dcGroups + g, pieces: []};
+      for (let c = globalCount; c < squeezed.length; c++) {
+        const ch = squeezed[c];
+        if (Math.min(ch.hshift, ch.vshift) < 3) continue;
+        const rect = rectOf(ch, gx * DC_GROUP_DIM, gy * DC_GROUP_DIM, DC_GROUP_DIM);
+        if (rect.w > 0 && rect.h > 0) section.pieces.push({c, rect});
+      }
+      sections.push(section);
+    }
+    for (let g = 0; g < acGroups; g++) {
+      const gx = g % layout.groupsX, gy = (g / layout.groupsX) | 0, section = {index: 2 + dcGroups + g, streamId: 1 + 3 * dcGroups + 17 + g, pieces: []};
+      for (let c = globalCount; c < squeezed.length; c++) {
+        const ch = squeezed[c];
+        if (Math.min(ch.hshift, ch.vshift) > 2) continue;
+        const rect = rectOf(ch, gx * GROUP_DIM, gy * GROUP_DIM, GROUP_DIM);
+        if (rect.w > 0 && rect.h > 0) section.pieces.push({c, rect});
+      }
+      sections.push(section);
+    }
+  }
+  for (const section of sections) for (const piece of section.pieces) {
+    const ch = squeezed[piece.c];
+    piece.leaf = leaf(predictorOf(ch), 0, quantiserOf(ch)); piece.leaf.channel = piece.c;
+  }
+  const withPieces = sections.filter(section => section.pieces.length);
+  const tree = withPieces.length === 1 ? channelTree(withPieces[0].pieces.map(p => p.leaf))
+    : streamTree(withPieces.map(section => ({streamId: section.streamId, tree: channelTree(section.pieces.map(p => p.leaf))})));
+
+  const scratch = new Int16Array(GROUP_DIM * GROUP_DIM);
+  const dataOf = piece => {
+    const ch = squeezed[piece.c], rect = piece.rect;
+    if (rect.w === ch.w && rect.h === ch.h) return ch.data;
+    for (let y = 0; y < rect.h; y++) scratch.set(ch.data.subarray((rect.y + y) * ch.w + rect.x, (rect.y + y) * ch.w + rect.x + rect.w), y * rect.w);
+    return scratch;
+  };
+  const freqs = squeezed.map(() => new Uint32Array(ALPHABET));
+  for (const section of sections) for (const piece of section.pieces) codeChannel(null, freqs[piece.c], dataOf(piece), piece.rect.w, piece.rect.h, piece.leaf);
+
+  const header = new BitWriter(256);
+  writeImageHeader(header, width, height, colour, alpha);
+  writeModularFrameHeader(header, {alpha});
+  // Section order: DC global, DC groups, AC global (empty), AC groups.
+  const writers = Array.from({length: layout.single ? 1 : 2 + dcGroups + acGroups}, () => null);
+  const global = writers[0] = new BitWriter(65536);
+  global.write(1, 1);  // default DC quantisation
+  global.write(1, 1);  // a global tree
+  const ordered = writeTree(global, tree);
+  const histograms = writeChannelHistograms(global, ordered, freqs, l => l.channel);
+  writeModularHeader(global, {useGlobalTree: true, transforms});
+  for (const section of sections) {
+    let w = writers[section.index];
+    if (!w) {
+      w = writers[section.index] = new BitWriter(4096);
+      if (section.pieces.length) writeModularHeader(w, {useGlobalTree: true, transforms: []});
+    }
+    for (const piece of section.pieces) codeChannel(w, histograms[piece.c + 1].code, dataOf(piece), piece.rect.w, piece.rect.h, piece.leaf);
+  }
+  const out = writers.map(w => w || new BitWriter(16));
+  return assembleCodestream(header, out.map(w => { w.zeroPadToByte(); return w.finish(); }));
+}