Encode lossless JPEG XL: libjxl's fast lossless encoder, like cjxl -e 1

Image.encodeJXL ports libjxl's fast lossless encoder (enc_fast_lossless.cc) for
8-bit images, with libjxl's image header: the codestream is byte for byte what
cjxl -e 1 writes on CPUs with AVX2 or NEON (chunks of 16 pixels; the tests also
check the chunks of 8 of builds without SIMD). Palettes are sorted like
libstdc++'s std::sort, so ties end up the same. Unlike libjxl, colors whose
hashes collide within one chunk of the palette detection fall back to YCoCg
(libjxl loses one of them).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Lfv41PqHEGbU7SLg5onpG1

Author: matmen

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 3.5.0
+
+### Features
+
+- `Image.encodeJXL()` encodes lossless JPEG XLs: ported from libjxl's fast lossless encoder, the codestream is byte for
+  byte what `cjxl -e 1` writes on CPUs with AVX2 or NEON (libjxl's output depends on the CPU: it works in chunks of 16
+  pixels there, of 8 without SIMD, of 32 with AVX-512). Images of at most 511 colors besides black get a palette,
+  others YCoCg; greyscale images are encoded as one channel, alpha only if the image has transparency. Unlike libjxl,
+  two colors whose hashes collide within 8 pixels don't end up as one (libjxl then writes a palette that loses one of
+  them; such images are encoded with YCoCg instead).
+
+### Performance
+
+- JPEG XL decoding is about 25% faster: lossy 2048x1536 images take about 0.87 s instead of 1.2 s, lossless ones of
+  the default effort 2.6 s instead of 3.7 s. The output is the same, except for rounding: linear light becomes sRGB
+  like libjxl does (a rational polynomial of the square root instead of a power).
+
 ## 3.4.0
 
 ### Features

README.md

@@ -67,6 +67,8 @@ deno add jsr:@matmen/imagescript     # Deno (npm:imagescript works too)
   , [JPEGs](https://imagescript.matmen.dev/classes/Image.html#encodejpeg)
   , lossless and lossy [WebPs](https://imagescript.matmen.dev/classes/Image.html#encodewebp) (lossy ones byte for
   byte like libwebp's cwebp)
+  , lossless [JPEG XLs](https://imagescript.matmen.dev/classes/Image.html#encodejxl) (byte for byte like libjxl's
+  `cjxl -e 1`)
   , [BMPs](https://imagescript.matmen.dev/classes/Image.html#encodebmp)
   , [QOIs](https://imagescript.matmen.dev/classes/Image.html#encodeqoi)
   , [Netpbm images](https://imagescript.matmen.dev/classes/Image.html#encodepnm) (PBM, PGM, PPM or PAM, whichever is
@@ -126,7 +128,8 @@ the text shaping is ported from [HarfBuzz](https://github.com/harfbuzz/harfbuzz)
 [Unicode Character Database](https://www.unicode.org/ucd/). The AV1 decoder is ported from
 [dav1d](https://code.videolan.org/videolan/dav1d), AVIFs are converted to RGB like
 [libavif](https://github.com/AOMediaCodec/libavif) does, the JPEG XL decoder is ported from
-[jxl-oxide](https://github.com/tirr-c/jxl-oxide) and [libjxl](https://github.com/libjxl/libjxl).
+[jxl-oxide](https://github.com/tirr-c/jxl-oxide) and [libjxl](https://github.com/libjxl/libjxl), the JPEG XL encoder
+from libjxl's fast lossless encoder.
 See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for their licenses.
 
 ---

THIRD_PARTY_NOTICES.md

@@ -16,7 +16,7 @@ following projects, under their own licenses. Each derived file says so in its h
 | [dav1d](https://code.videolan.org/videolan/dav1d) by VideoLAN, the dav1d authors and Two Orioles | `src/codecs/av1/*` (the AV1 decoder: bitstream parsing, symbol decoding, prediction, inverse transforms, loop filters, film grain; the tables in `src/codecs/av1/data.ts`, generated from dav1d by `scripts/av1-tables.c`) | BSD-2-Clause |
 | [libavif](https://github.com/AOMediaCodec/libavif) by Joe Drago | `src/codecs/avif.ts` (YUV to RGB conversion with bilinear chroma upsampling, alpha range expansion and unpremultiplication) | BSD-2-Clause |
 | [jxl-oxide](https://github.com/tirr-c/jxl-oxide) by Wonwoo Choi | `src/codecs/jxl/*` (the JPEG XL decoder: bit reader, header and frame header fields, entropy decoding, VarDCT, dequantization matrices, transforms, restoration filters, upsampling, the parsing of patches, splines and noise) | MIT (or Apache-2.0) |
-| [libjxl](https://github.com/libjxl/libjxl) by the JPEG XL Project Authors | `src/codecs/jxl/modular.ts` (Modular decoding: MA trees, predictors, the self-correcting predictor, transforms), `src/codecs/jxl/frame.ts` (the sections of frames, the order of the rendering stages, reference frames), `src/codecs/jxl/blend.ts`, `src/codecs/jxl/color.ts` (XYB to RGB), `src/codecs/jxl/features.ts` (rendering patches, splines and noise) | BSD-3-Clause |
+| [libjxl](https://github.com/libjxl/libjxl) by the JPEG XL Project Authors | `src/codecs/jxl/modular.ts` (Modular decoding: MA trees, predictors, the self-correcting predictor, transforms), `src/codecs/jxl/frame.ts` (the sections of frames, the order of the rendering stages, reference frames), `src/codecs/jxl/blend.ts`, `src/codecs/jxl/color.ts` (XYB to RGB), `src/codecs/jxl/features.ts` (rendering patches, splines and noise), `src/codecs/jxl/fast-lossless.ts` (the lossless encoder: palette detection, YCoCg, the gradient predictor, prefix codes, runs as LZ77, the headers) | BSD-3-Clause |
 | [JPEG XL conformance](https://github.com/libjxl/conformance) by the JPEG XL Project Authors | `tests/jxl/alpha-*.jxl`, `animation-spline.jxl`, `blendmodes.jxl`, `mul-no-extra-channels.jxl` (test files) | BSD-3-Clause |
 | [FreeType](https://freetype.org) | `src/render/hinting.ts` (behavior and parts of the logic of the TrueType interpreter) | FreeType License |
 | [QOI](https://github.com/phoboslab/qoi) by Dominic Szablewski | `src/codecs/qoi.ts` (the reference encoder's choices of operations) | MIT |
@@ -254,7 +254,8 @@ DEALINGS IN THE SOFTWARE.
 ## libjxl, JPEG XL conformance
 
 The Modular decoding, the rendering pipeline, blending, the XYB conversion and the rendering of patches, splines and
-noise follow libjxl, the JPEG XL reference implementation; tests/jxl includes files of its conformance suite. JPEG XL
+noise follow libjxl, the JPEG XL reference implementation, and the lossless encoder is ported from its fast lossless
+encoder; tests/jxl includes files of its conformance suite. JPEG XL
 is covered by Google's patent grant for libjxl (the "Additional IP Rights Grant" in libjxl's PATENTS file).
 
 ```

scripts/jxl-lossless-references.py

@@ -0,0 +1,32 @@
+# Prints the SHA-256 of what cjxl -e 1 (libjxl's fast lossless mode) writes for the images of tests/jxl-encode.js:
+# Image.encodeJXL writes the same. The channels are those encodeJXL picks (grey if every pixel is, alpha if one isn't
+# opaque). libjxl's output depends on the CPU: with AVX2 or NEON it works in chunks of 16 pixels (what encodeJXL does),
+# without SIMD in chunks of 8 (the test checks these too), with AVX-512 in chunks of 32. Needs Pillow and cjxl:
+#   CJXL=path/to/cjxl python scripts/jxl-lossless-references.py
+import hashlib, os, subprocess, tempfile
+from pathlib import Path
+import numpy as np
+from PIL import Image
+
+root = Path(__file__).resolve().parent.parent
+CJXL = os.environ.get('CJXL', 'cjxl')
+tmp = Path(tempfile.mkdtemp())
+
+
+def images():
+    for name in ['external.png', 'circle.png', 'readme.png', 'potato.png']:
+        yield name, np.asarray(Image.open(root / 'tests' / 'targets' / name).convert('RGBA'))
+    # (grey: the red channel)
+    red = np.asarray(Image.open(root / 'tests' / 'targets' / 'external.png').convert('RGBA'))[..., 0]
+    yield 'external.png grey', np.dstack([red, red, red, np.full_like(red, 255)])
+
+
+for name, rgba in images():
+    grey = (rgba[..., 0] == rgba[..., 1]).all() and (rgba[..., 0] == rgba[..., 2]).all()
+    opaque = (rgba[..., 3] == 255).all()
+    channels = [0] if grey else [0, 1, 2]
+    if not opaque: channels.append(3)
+    a = rgba[..., channels]
+    Image.fromarray(a[..., 0] if len(channels) == 1 else a, {1: 'L', 2: 'LA', 3: 'RGB', 4: 'RGBA'}[len(channels)]).save(tmp / 'in.png')
+    subprocess.run([CJXL, '--quiet', str(tmp / 'in.png'), str(tmp / 'out.jxl'), '-d', '0', '-e', '1'], check=True)
+    print(f"    '{name}': '{hashlib.sha256((tmp / 'out.jxl').read_bytes()).hexdigest()}',")

src/codecs/jxl.ts

@@ -10,6 +10,7 @@ import { frameHeader, toc } from './jxl/frame-header.ts';
 import { decodeFrame, DecoderState } from './jxl/frame.ts';
 import { ColorOutput } from './jxl/color.ts';
 import { ToneMapping } from './hdr.ts';
+export { encodeRGBA as encode } from './jxl/fast-lossless.ts';
 
 const CONTAINER = [0, 0, 0, 12, 0x4a, 0x58, 0x4c, 0x20, 0x0d, 0x0a, 0x87, 0x0a];