rapier-jxl 1.1.21 → 2.1.0

package/jpeg.mjs

@@ -1,382 +1,15 @@
-// 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, a colour profile other than sRGB) is refused with JXL_JPEG and the picture takes the
-// ordinary path instead. So is a JPEG cut short, a scan with bytes missing or left over, a restart marker out of
-// order, or a progressive file whose scans do not finish every coefficient: nothing here invents pixels a file lost.
-// The frame's dimensions are admitted against LIMITS before a coefficient plane is allocated, so a header naming a
-// picture the module would never encode costs nothing.
-import {LIMITS} from './bits.mjs';
-
-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, code = 'JXL_JPEG') { return Object.assign(new Error('JPEG: ' + message), {code}); }
-
-// 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);
-      // An all-ones code would turn the required scan padding into a symbol.
-      if (start + n >= 65536) throw jpegError('bad Huffman table');
-      lookup.fill((length << 8) | symbol, start, start + n);
-      code++;
-    }
-    code <<= 1;
-  }
-  return lookup;
-}
-
-// The ICC profile a JPEG carries in its APP2 segments says sRGB (or the grey of the same curve), or the picture is
-// refused: the frame declares sRGB, and a profile this module does not carry must not change what the colours mean.
-function profileIsSRGB(chunks) {
-  const parts = [];
-  for (let i = 1; i <= chunks.count; i++) { if (!chunks.parts[i]) throw jpegError('a colour profile cut short'); parts.push(chunks.parts[i]); }
-  const size = parts.reduce((n, p) => n + p.length, 0), profile = new Uint8Array(size);
-  for (let i = 0, at = 0; i < parts.length; at += parts[i].length, i++) profile.set(parts[i], at);
-  const u32 = at => at + 4 <= size ? ((profile[at] << 24) | (profile[at + 1] << 16) | (profile[at + 2] << 8) | profile[at + 3]) >>> 0 : 0;
-  const sig = at => at + 4 <= size ? String.fromCharCode(profile[at], profile[at + 1], profile[at + 2], profile[at + 3]) : '';
-  const tags = u32(128);
-  if (size < 132 || 132 + tags * 12 > size) return false;
-  for (let i = 0; i < tags; i++) {
-    const at = 132 + i * 12;
-    if (sig(at) !== 'desc') continue;
-    const offset = u32(at + 4), length = u32(at + 8);
-    if (offset + length > size || length < 16) return false;
-    let text = '';
-    if (sig(offset) === 'desc') { const n = Math.min(u32(offset + 8), length - 12); for (let j = 0; j < n; j++) text += String.fromCharCode(profile[offset + 12 + j]); }
-    else if (sig(offset) === 'mluc') {
-      if (!u32(offset + 8) || length < 28) return false;
-      const n = u32(offset + 20), start = offset + u32(offset + 24);
-      if (start + n > size) return false;
-      for (let j = 0; j + 1 < n; j += 2) text += String.fromCharCode((profile[start + j] << 8) | profile[start + j + 1]);
-    } else return false;
-    return /sRGB|sGray|IEC ?61966/i.test(text);
-  }
-  return false;
-}
-
-export function parseJPEG(bytes) {
-  if (!(bytes.length > 4) || bytes[0] !== 0xFF || bytes[1] !== 0xD8) throw jpegError('not a JPEG');
-  const quant = [], huffman = [[], []], badDC = new Set(), icc = {count: 0, parts: []};
-  let frame = null, restartInterval = 0, adobeTransform = -1, jfif = false, orientation = 1, pos = 2;
-  const u16 = at => (bytes[at] << 8) | bytes[at + 1];
-  const signatureAt = (at, signature) => {
-    for (let i = 0; i < signature.length; i++) if (bytes[at + i] !== signature.charCodeAt(i)) return false;
-    return true;
-  };
-  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) throw jpegError('a restart marker outside a scan');
-    if (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 || at + 1 + (pq ? 128 : 64) > end) 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; if (!table[ZIGZAG[k]]) throw jpegError('a zero quantisation step'); }
-        if (frame?.progressive && frame.components.some(c => c.tq === tq && c.quant && c.coverage.some(v => v !== 0) && c.quant.some((v, k) => v !== table[k]))) throw jpegError('a quantisation table changed between progressive scans');
-        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 || at + 17 > end) throw jpegError('bad Huffman table');
-        at++;
-        const counts = bytes.subarray(at, at + 16);
-        let total = 0;
-        for (const c of counts) total += c;
-        if (total > 256 || at + 16 + total > end) throw jpegError('bad Huffman table');
-        const symbols = bytes.subarray(at + 16, at + 16 + total);
-        huffman[tc][th] = buildHuffman(counts, symbols);
-        // libjpeg refuses a DC table naming a symbol above 15 when a scan first reads DC through it, used or not.
-        if (tc === 0) { if (symbols.some(s => s > 15)) badDC.add(th); else badDC.delete(th); }
-        at += 16 + total;
-      }
-    } else if (marker === 0xC0 || marker === 0xC1 || marker === 0xC2) {
-      if (frame) throw jpegError('two frames');
-      if (end - segment < 6) throw jpegError('bad frame header');
-      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');
-      if (end - segment < 6 + count * 3) throw jpegError('bad frame header');
-      // Admitted before a plane is allocated: the limits are the module's, the same the checked API keeps.
-      if (width > LIMITS.edge || height > LIMITS.edge) throw jpegError('a picture past ' + LIMITS.edge + ' pixels on a side', 'JXL_DIMENSIONS');
-      if (width * height > LIMITS.pixels) throw jpegError('a picture past ' + LIMITS.pixels + ' pixels', 'JXL_DIMENSIONS');
-      const components = [];
-      let blocksPerMcu = 0;
-      for (let i = 0, at = segment + 6; i < count; i++, at += 3) {
-        const h = bytes[at + 1] >> 4, v = bytes[at + 1] & 15, tq = bytes[at + 2];
-        if (h < 1 || h > 4 || v < 1 || v > 4) throw jpegError('bad sampling');
-        if (tq > 3) throw jpegError('bad quantisation table');
-        if (components.some(c => c.id === bytes[at])) throw jpegError('two components with one id');
-        blocksPerMcu += h * v;
-        components.push({id: bytes[at], h, v, tq, pred: 0, coverage: new Int8Array(64).fill(-1)});
-      }
-      if (blocksPerMcu > 10) throw jpegError('bad sampling');
-      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) { if (length < 4) throw jpegError('bad segment'); 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 = [];
-      if (n < 1 || n > 4 || segment + 1 + n * 2 + 3 > end) throw jpegError('bad scan header');
-      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');
-        if (scan.some(s => s.component === component)) throw jpegError('a component twice in one scan');
-        // A table may be reused for another component after this one's scans. Keep the table that actually
-        // decoded each component, not whatever happens to occupy its slot at the end of the file.
-        if (!component.quant) component.quant = quant[component.tq];
-        if (!component.quant) throw jpegError('a scan without its quantisation table');
-        scan.push({component, dc: huffman[0][bytes[at + 1] >> 4], ac: huffman[1][bytes[at + 1] & 15], dcSlot: bytes[at + 1] >> 4});
-      }
-      const ss = bytes[at], se = bytes[at + 1], ah = bytes[at + 2] >> 4, al = bytes[at + 2] & 15;
-      if ((!frame.progressive || (ss === 0 && ah === 0)) && scan.some(s => badDC.has(s.dcSlot))) throw jpegError('bad Huffman table');
-      pos = decodeScan(bytes, end, frame, scan, ss, se, ah, al, restartInterval);
-      frame.scans++;
-    } else if (marker === 0xE0) {
-      if (signatureAt(segment, 'JFIF')) jfif = true;
-    } else if (marker === 0xE1) {
-      if (orientation === 1 && signatureAt(segment, 'Exif')) orientation = exifOrientation(bytes, segment + 6, end);
-    } else if (marker === 0xE2) {
-      if (length >= 16 && signatureAt(segment, 'ICC_PROFILE\0')) {
-        const seq = bytes[segment + 12], count = bytes[segment + 13];
-        if (!seq || !count || seq > count || (icc.count && icc.count !== count) || icc.parts[seq]) throw jpegError('a colour profile cut short');
-        icc.count = count; icc.parts[seq] = bytes.subarray(segment + 14, end);
-      }
-    } else if (marker === 0xEE) {
-      if (length >= 14 && signatureAt(segment, 'Adobe')) adobeTransform = bytes[segment + 11];
-    }
-  }
-  if (!frame || !frame.scans) throw jpegError('no picture');
-  for (const c of frame.components) {
-    for (let k = 0; k < 64; k++) if (c.coverage[k] !== 0) throw jpegError(frame.progressive ? 'a progressive JPEG whose scans do not finish every coefficient' : 'a component without its scan');
-  }
-  if (icc.count && !profileIsSRGB(icc)) throw jpegError('a colour profile other than sRGB (decode the picture and encode its pixels)');
-  // 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;
-}
-
-// What a scan may be, and what it leaves coded: sequential scans code a component whole at once; progressive scans
-// code the DC first, then AC bands, each bit plane once, from the top down. `coverage[k]` is the lowest bit plane
-// coefficient k has been coded to (-1 never), and the picture is complete only when every one reaches 0.
-function admitScan(frame, scan, ss, se, ah, al) {
-  const progressive = frame.progressive;
-  if (!progressive) {
-    if (ss !== 0 || se !== 63 || ah !== 0 || al !== 0) throw jpegError('a bad spectral selection');
-    for (const s of scan) { if (s.component.coverage.some(v => v !== -1)) throw jpegError('a component coded twice'); s.component.coverage.fill(0); }
-    return;
-  }
-  if (al > 13 || (ah && ah !== al + 1)) throw jpegError('a bad successive approximation');
-  if (ss === 0) {
-    if (se !== 0) throw jpegError('a bad spectral selection');
-    for (const {component} of scan) {
-      if (component.coverage[0] !== (ah ? ah : -1)) throw jpegError(ah ? 'a refinement scan out of order' : 'a DC scan twice');
-      component.coverage[0] = al;
-    }
-    return;
-  }
-  if (scan.length !== 1) throw jpegError('an interleaved AC scan');
-  if (se > 63 || ss > se) throw jpegError('a bad spectral selection');
-  const {coverage} = scan[0].component;
-  if (coverage[0] === -1) throw jpegError('an AC scan before the DC scan');
-  for (let k = ss; k <= se; k++) {
-    if (coverage[k] !== (ah ? ah : -1)) throw jpegError(ah ? 'a refinement scan out of order' : 'a band coded twice');
-    coverage[k] = al;
-  }
-}
-
-function decodeScan(bytes, start, frame, scan, ss, se, ah, al, restartInterval) {
-  admitScan(frame, scan, ss, se, ah, al);
-  // `pad` counts the bits in `buffer` that are not the file's: zero bytes fed once a marker or the end is reached, so
-  // the lookahead always holds 24 bits. A code or a value that would take them is a scan cut short.
-  let pos = start, buffer = 0, count = 0, pad = 0, marker = false;
-  const fill = () => {
-    while (count <= 24) {
-      let byte = 0;
-      if (marker || pos >= bytes.length) { marker = true; pad += 8; }
-      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; pad += 8; }
-        } else pos++;
-      }
-      buffer = ((buffer << 8) | byte) >>> 0; count += 8;
-    }
-  };
-  const short = () => jpegError('a scan cut short');
-  const receive = n => { if (!n) return 0; fill(); if (n > count - pad) throw short(); 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');
-    if ((entry >> 8) > count - pad) throw short();
-    count -= entry >> 8;
-    return entry & 255;
-  };
-  // The bytes of an interval are consumed whole but for the last one's padding bits; then its marker, in order.
-  const atMarker = () => {
-    const remaining = count - pad;
-    if (remaining >= 8) throw jpegError('bytes left over in a scan');
-    if (eobrun) throw jpegError('an end-of-band run past its interval');
-    if (remaining && ((buffer >>> pad) & ((1 << remaining) - 1)) !== (1 << remaining) - 1) throw jpegError('bad scan padding');
-    while (pos + 1 < bytes.length && bytes[pos] === 0xFF && bytes[pos + 1] === 0xFF) pos++;
-  };
-  const restart = index => {
-    atMarker();
-    if (!(bytes[pos] === 0xFF && bytes[pos + 1] === 0xD0 + (index & 7))) throw jpegError('a restart marker missing or out of order');
-    pos += 2; buffer = 0; count = 0; pad = 0; marker = false;
-    for (const s of scan) s.component.pred = 0;
-    eobrun = 0;
-  };
-  const dcValue = (s, t) => {
-    if (t > 11) throw jpegError('a DC value out of range');
-    const diff = t ? extend(receive(t), t) : 0;
-    s.component.pred += diff;
-    if (s.component.pred > 2047 || s.component.pred < -2048) throw jpegError('a DC value out of range');
-    return s.component.pred;
-  };
-  const acValue = (size, shift) => {
-    if (size > 10) throw jpegError('an AC value out of range');
-    const value = extend(receive(size), size) * (1 << shift);
-    if (value > 1023 || value < -1023) throw jpegError('an AC value out of range');
-    return value;
-  };
-  let eobrun = 0;
-  const single = scan.length === 1, progressive = frame.progressive;
-  const baseline = (s, coeffs, at) => {
-    coeffs[at] = dcValue(s, decode(s.dc));
-    acFirst(s, coeffs, at);
-  };
-  const dcFirst = (s, coeffs, at) => {
-    const value = dcValue(s, decode(s.dc)) * (1 << al);
-    if (value > 2047 || value < -2048) throw jpegError('a DC value out of range');
-    coeffs[at] = value;
-  };
-  const dcRefine = (s, coeffs, at) => { if (receive(1)) coeffs[at] |= 1 << al; };
-  const pastBand = () => jpegError('coefficients past the ' + (progressive ? 'band' : 'block'));
-  // Sequential scans use this same first AC pass after their DC: admission fixes ss=0, se=63, al=0. Only a
-  // progressive scan may carry an end-of-band run across blocks; a sequential nonzero run still refuses here.
-  const acFirst = (s, coeffs, at) => {
-    if (eobrun > 0) { eobrun--; return; }
-    for (let k = ss || 1; k <= se;) {
-      const rs = decode(s.ac), r = rs >> 4, size = rs & 15;
-      if (!size) {
-        if (r < 15) {
-          if (r && !progressive) throw jpegError('an end-of-band run in a sequential scan');
-          eobrun = (1 << r) - 1 + (r ? receive(r) : 0); break;
-        }
-        k += 16; if (k > se + 1) throw pastBand(); continue;
-      }
-      k += r;
-      if (k > se) throw pastBand();
-      coeffs[at + ZIGZAG[k]] = acValue(size, 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 (r >= 0 || (value && k > se)) throw jpegError('coefficients past the band');
-        if (value) 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);
-  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(unit / restartInterval - 1);
-    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);
-      }
-    }
-  }
-  // The scan ends at a marker or EOF. A final complete interval may carry its next restart marker, once.
-  atMarker();
-  if (bytes[pos] === 0xFF && bytes[pos + 1] >= 0xD0 && bytes[pos + 1] <= 0xD7) {
-    if (!restartInterval || total % restartInterval || bytes[pos + 1] !== 0xD0 + ((total / restartInterval - 1) & 7)) throw jpegError('a restart marker out of order');
-    pos += 2;
-    while (pos + 1 < bytes.length && bytes[pos] === 0xFF && bytes[pos + 1] === 0xFF) pos++;
-  }
-  if (pos < bytes.length && !(bytes[pos] === 0xFF && pos + 1 < bytes.length && bytes[pos + 1] !== 0 && bytes[pos + 1] !== 0xFF)) throw jpegError('bytes left over after a scan');
-  return pos;
-}
+// SPDX-License-Identifier: MIT
+// Rapier JXL's JPEG door: a JPEG carried as its quantised DCT coefficients,
+// quantisation tables, colour and subsampling, with only the entropy coding changed.
+// Baseline, extended sequential and progressive scans, restarts; 8-bit grey, YCbCr or RGB;
+// Exif orientation and an admitted sRGB or Display P3 declaration are kept.
+// Not carried: JPEG reconstruction data, ICC bytes, Exif beyond orientation or XMP.
+// Arithmetic, 12-bit, lossless, CMYK, DNL, another colour profile, truncation or a table
+// libjpeg refuses is JXL_JPEG: decode it and encode its pixels instead.
+import {JPEG_LIMITS} from './bits.mjs';
+import {jpegAnswer, jpegJob} from './jpeg-job.mjs';
+import {coefficientEffortSteps} from './coefficient-effort.mjs';
+
+export {JPEG_LIMITS as LIMITS};
+export function transcode(jpeg, options) { return jpegAnswer(transcodeSteps(jpeg, options)); }
+export function transcodeSteps(jpeg, options) { return jpegJob(jpeg, options, coefficientEffortSteps); }

package/local.mjs

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: MIT
+// 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 {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';
+
+const localRaw = s => Math.max(0, s < 224 ? s - 1 : s - 236);
+const price = freqs => {
+  const code = buildCode(freqs), writer = new BitWriter(128);
+  writePrefixCode(writer, code);
+  let bits = writer.bitLength;
+  for (let s = 0; s < freqs.length; s++) if (freqs[s]) bits += freqs[s] * (code.lengths[s] + localRaw(s));
+  return bits;
+};
+
+// Residuals are exactly the decoder's unsigned values before entropy coding, including RGB under zero alpha.
+function residuals(plane, width, height, predictor, properties) {
+  const out = new Uint32Array(width * height);
+  if (predictor === 6) { codeWeighted(null, null, plane, width, height, 0, undefined, out, properties); return out; }
+  for (let y = 0, i = 0; y < height; y++) for (let x = 0; x < width; x++, i++) {
+    const left = x ? plane[i - 1] : y ? plane[i - width] : 0, top = y ? plane[i - width] : left;
+    const nw = x && y ? plane[i - width - 1] : left;
+    const prediction = predictor === 3 ? ((left + top) / 2) | 0 : Math.max(Math.min(left, top), Math.min(Math.max(left, top), left + top - nw));
+    out[i] = packSigned(plane[i] - prediction);
+  }
+  return out;
+}
+
+function tokens(values, contexts, count = 1) {
+  const freqs = Array.from({length: count}, () => new Uint32Array(ALPHABET)), pieces = [];
+  const emit = (i, value, base = 0) => {
+    const context = contexts ? contexts[i] : 0;
+    pieces.push(value, base, context); countToken(base ? LZ77.lengthConfig : RESIDUAL_CONFIG, value, freqs[context], base);
+  };
+  // A zero run can cross a tree leaf or row. Its first literal and copy use their own samples' contexts.
+  for (let i = 0; i < values.length;) {
+    let run = 1;
+    if (!values[i]) while (i + run < values.length && !values[i + run]) run++;
+    emit(i, values[i]);
+    if (run > LZ77.minLength) {
+      emit(i + 1, run - 1 - LZ77.minLength, LZ77.minSymbol);
+    } else for (let n = 1; n < run; n++) emit(i + n, 0);
+    i += run;
+  }
+  return {freqs, pieces};
+}
+
+function intervalPlan(values, properties, predictor, property, cuts) {
+  const contexts = Uint8Array.from(properties, value => {
+    let lo = 0, hi = cuts.length;
+    while (lo < hi) { const mid = (lo + hi) >> 1; if (value > cuts[mid]) lo = mid + 1; else hi = mid; }
+    return lo;
+  });
+  const coded = tokens(values, contexts, cuts.length + 1), count = coded.freqs.length, filled = coded.freqs.map(freq => freq.some(n => n));
+  const costs = new Float64Array(count + 1).fill(Infinity), from = new Uint8Array(count + 1);
+  costs[0] = 0;
+  for (let end = 1; end <= count; end++) {
+    const freq = new Uint32Array(ALPHABET);
+    let own = 0;
+    for (let start = end - 1; start >= 0; start--) {
+      if (filled[start]) { for (let s = 0; s < ALPHABET; s++) freq[s] += coded.freqs[start][s]; own = price(freq); }
+      const bits = costs[start] + own + 24;
+      if (bits < costs[end]) { costs[end] = bits; from[end] = start; }
+    }
+  }
+  const spans = [];
+  for (let end = count; end; end = from[end]) spans.unshift([from[end], end]);
+  const leaves = spans.map(() => leaf(predictor)), mapping = new Uint8Array(count);
+  const freqs = spans.map(([start, end], index) => {
+    const freq = new Uint32Array(ALPHABET);
+    for (let k = start; k < end; k++) { mapping[k] = index; for (let s = 0; s < ALPHABET; s++) freq[s] += coded.freqs[k][s]; }
+    return freq;
+  });
+  for (let i = 2; i < coded.pieces.length; i += 3) coded.pieces[i] = mapping[coded.pieces[i]];
+  const tree = (lo, hi) => {
+    if (lo === hi) return leaves[lo];
+    const mid = (lo + hi) >> 1;
+    return split(property, cuts[spans[mid][1] - 1], tree(mid + 1, hi), tree(lo, mid));
+  };
+  return {leaves, tree: tree(0, spans.length - 1), freqs, pieces: coded.pieces};
+}
+
+const WEIGHTED_LOCAL_CUTS = [-127, -31, -7, -1, 0, 1, 7, 31, 127];
+const GRADIENT_CUTS = [-191, -127, -63, -31, -7, -1, 0, 7, 31, 63, 127, 191, 255];
+function localProperties(plane, width, height, property) {
+  const out = new Int32Array(width * height);
+  for (let y = 0, i = 0; y < height; y++) for (let x = 0; x < width; x++, i++) {
+    const left = x ? plane[i - 1] : y ? plane[i - width] : 0, top = y ? plane[i - width] : left;
+    const nw = x && y ? plane[i - width - 1] : left;
+    out[i] = property === 9 ? left + top - nw : left - nw;
+  }
+  return out;
+}
+function planPrice(plan) {
+  const writer = new BitWriter(512);
+  const histograms = writeChannelHistograms(writer, writeTree(writer, plan.tree), plan.freqs, l => plan.leaves.indexOf(l));
+  let bits = writer.bitLength;
+  plan.freqs.forEach((freq, i) => { const {lengths} = histograms[i + 1].code; for (let s = 0; s < freq.length; s++) bits += freq[s] * ((lengths[s] || 0) + localRaw(s)); });
+  return bits;
+}
+
+function plansOf(planes, width, height, rung) {
+  return planes.map(plane => {
+    let best;
+    for (const predictor of [5, 3, 6]) {
+      const properties = predictor === 6 ? new Int32Array(width * height) : null;
+      const values = residuals(plane, width, height, predictor, properties), one = leaf(predictor);
+      const candidates = [{...tokens(values), leaves: [one], tree: one}];
+      if (properties) candidates.push(intervalPlan(values, properties, predictor, 15, WEIGHTED_LOCAL_CUTS));
+      // Property 9 is the unclamped gradient; property 10 is W - NW. Signed cuts let the latter separate both
+      // tails around a flat neighbourhood without treating a high-magnitude negative edge as a small one.
+      if (rung >= 6 && predictor === 5) for (const property of [9, 10]) {
+        const local = localProperties(plane, width, height, property), cuts = property === 9 ? GRADIENT_CUTS : WEIGHTED_LOCAL_CUTS;
+        candidates.push(intervalPlan(values, local, predictor, property, cuts));
+      }
+      for (const plan of candidates) { const bits = planPrice(plan); if (!best || bits < best.bits) best = {...plan, bits}; }
+    }
+    return best;
+  });
+}
+
+function writeModel(writer, plans) {
+  const leaves = plans.flatMap(plan => plan.leaves);
+  const histograms = writeChannelHistograms(writer, writeTree(writer, channelTree(plans.map(plan => plan.tree))), plans.flatMap(plan => plan.freqs), l => leaves.indexOf(l));
+  return () => {
+    for (let c = 0; c < plans.length; c++) {
+      const {pieces} = plans[c], codes = plans[c].leaves.map(l => histograms[leaves.indexOf(l) + 1].code);
+      for (let i = 0; i < pieces.length; i += 3) {
+        const base = pieces[i + 1];
+        writeHybrid(writer, codes[pieces[i + 2]], base ? LZ77.lengthConfig : RESIDUAL_CONFIG, pieces[i], base);
+      }
+    }
+  };
+}
+
+export function* localSteps(rgba, width, height, shape, colorSpace, rung = 4, usePalette = false) {
+  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 header = new BitWriter(256);
+  writeImageHeader(header, width, height, shape.colour, shape.alpha, {colorSpace});
+  writeModularFrameHeader(header, {alpha: shape.alpha});
+  const transforms = palette ? [{type: 'palette', beginC: 0, numC: channels, nbColors: palette.colours.length}] : channels >= 3 ? [{type: 'rct', beginC: 0, rctType: 6}] : [];
+  // The palette's meta channel precedes the picture in the global section; local AC groups contain only indices.
+  let palettePlans;
+  if (palette) {
+    const count = palette.colours.length, values = new Int16Array(count * channels);
+    palette.colours.forEach((colour, i) => { for (let c = 0; c < channels; c++) values[c * count + i] = palette.byte(colour, c); });
+    palettePlans = plansOf([values], count, channels, rung);
+  }
+  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());
+  };
+  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));
+    }
+    writeModularHeader(global, {transforms});
+    if (write) write();
+    appendSection(global);
+    for (let i = 0; i < layout.dcGroupsX * layout.dcGroupsY + 1; i++) sections.push(new Uint8Array(0));
+  }
+  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;
+  }
+  return assembleCodestream(header, sections);
+}