JPEG XL: CMYK images as their colors times black

The black extra channel was ignored, so black ink came out white. Without
applying the CMYK profile, the color channels (1 - ink) are multiplied by black,
like CMYK JPEGs. scripts/jxl-cmyk.c writes a small CMYK test file with libjxl,
since cjxl reads no CMYK input.

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

Author: matmen

CHANGELOG.md

@@ -26,15 +26,16 @@
   whose shown layer is inter coded the highest intra coded layer is shown if it has the image's size (else they
   throw).
 - `Image.decode` reads JPEG XLs, `Animation.decode` their animations (composited frames, durations, loop count), and
-  `ImageType` recognizes them (`'jxl'`, `ImageType.isJXL`). Ported from jxl-oxide and libjxl: bare codestreams and
-  the container (`jxlc`, `jxlp`), Modular (meta-adaptive trees, every predictor including the self-correcting one,
-  reversible color transforms, palettes with delta and implicit colors, squeeze, LZ77) and VarDCT (every varblock
-  type, chroma from luma, adaptive LF smoothing, chroma subsampled JPEG recompression), progressive passes and LF
-  frames, Gaborish and the edge-preserving filter, patches, splines, noise, upsampling, cropped and blended frames
-  and reference frames, alpha (also premultiplied), spot colors, the orientation. XYB images are rendered to sRGB, HDR
-  ones (PQ, HLG, or brighter than SDR white) tone mapped with `toneMapping`; others stay in their color space. Every
-  file of the JPEG XL conformance suite decodes within 1 of libjxl's djxl (as 8-bit sRGB). Not supported: ICC
-  profiles aren't applied (CMYK images aren't converted), previews are skipped.
+  `ImageType` recognizes them (`'jxl'`, `ImageType.isJXL`). Ported from jxl-oxide and libjxl: bare codestreams and the
+  container (`jxlc`, `jxlp`), Modular (meta-adaptive trees, every predictor including the self-correcting one,
+  reversible color transforms, palettes with delta and implicit colors, squeeze, LZ77) and VarDCT (every varblock type,
+  chroma from luma, adaptive LF smoothing, chroma subsampled JPEG recompression), progressive passes and LF frames,
+  Gaborish and the edge-preserving filter, patches, splines, noise, upsampling, cropped and blended frames and reference
+  frames, alpha (also premultiplied), spot colors, CMYK, the orientation. XYB images are rendered to sRGB, HDR ones (PQ,
+  HLG, or brighter than SDR white) tone mapped with `toneMapping`; others stay in their color space, CMYK ones become
+  their colors times black (like CMYK JPEGs). Every file of the JPEG XL conformance suite decodes within 1 of libjxl's
+  djxl (as 8-bit sRGB; but djxl ignores black without a CMS). Not supported: ICC profiles aren't applied, previews are
+  skipped.
 - `Image.encodeWebP({ quality })` encodes lossy WebPs (VP8, with a losslessly compressed alpha plane if the image
   isn't opaque): ported from libwebp's encoder with its default settings, the VP8 bitstream is byte for byte the one
   cwebp writes for the same quality (0-100). `effort` (0-6, default 4) is cwebp's `-m`: 0-2 decide by distortion only

README.md

@@ -36,8 +36,9 @@ deno add jsr:@matmen/imagescript     # Deno (npm:imagescript works too)
   - AVIFs (4:2:0, 4:2:2, 4:4:4 and monochrome, 8-12 bit; grids, alpha, crop, rotation and mirroring; the first frame
     of image sequences; bit-exact with dav1d and libavif), HDR ones (PQ, HLG) tone mapped to sRGB
   - JPEG XLs (Modular and VarDCT, lossless and lossy, every coding tool: progressive passes and LF frames, patches,
-    splines, noise, restoration filters, upsampling, JPEG recompression, layers and blending, alpha and spot colors;
-    animations; within 1 of libjxl's djxl on the conformance suite), XYB ones as sRGB, HDR ones tone mapped to sRGB
+    splines, noise, restoration filters, upsampling, JPEG recompression, layers and blending, alpha and spot colors,
+    CMYK; animations; within 1 of libjxl's djxl on the conformance suite), XYB ones as sRGB, HDR ones tone mapped to
+    sRGB
   - JPEGs, TIFFs, PNGs and WebPs are rotated as their Exif (or, for PNGs, XMP) orientation says
   - images larger than 268 megapixels (`maxPixels`) are rejected before decoding, so small files declaring huge images
     can't exhaust the memory

scripts/jxl-cmyk.c

@@ -0,0 +1,50 @@
+// Encodes a small lossless CMYK JPEG XL for tests/jxl (cjxl can't: it reads no CMYK input). Reads width * height
+// samples of C, M, Y, K (8-bit, 1 - ink, interleaved) from stdin, writes the JPEG XL to stdout: the color channels with
+// a black extra channel and, to keep the file small, the sRGB color encoding instead of a CMYK profile. Built and run by
+// scripts/jxl-fixtures.py:
+//   cc -o jxl-cmyk scripts/jxl-cmyk.c -ljxl && ./jxl-cmyk 32 32 < cmyk.raw > cmyk.jxl
+#include <jxl/encode.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+    if (argc < 3) return 2;
+    const uint32_t w = atoi(argv[1]), h = atoi(argv[2]);
+    uint8_t *in = malloc(w * h * 4), *color = malloc(w * h * 3), *black = malloc(w * h);
+    if (fread(in, 4, w * h, stdin) != w * h) return 1;
+    for (size_t i = 0; i < w * h; i++) {
+        for (int c = 0; c < 3; c++) color[3 * i + c] = in[4 * i + c];
+        black[i] = in[4 * i + 3];
+    }
+
+    JxlEncoder *enc = JxlEncoderCreate(NULL);
+    JxlBasicInfo info;
+    JxlEncoderInitBasicInfo(&info);
+    info.xsize = w;
+    info.ysize = h;
+    info.bits_per_sample = 8;
+    info.num_extra_channels = 1;
+    info.uses_original_profile = JXL_TRUE;
+    if (JxlEncoderSetBasicInfo(enc, &info)) return 1;
+    JxlExtraChannelInfo ec;
+    JxlEncoderInitExtraChannelInfo(JXL_CHANNEL_BLACK, &ec);
+    ec.bits_per_sample = 8;
+    if (JxlEncoderSetExtraChannelInfo(enc, 0, &ec)) return 1;
+    JxlColorEncoding srgb;
+    JxlColorEncodingSetToSRGB(&srgb, JXL_FALSE);
+    if (JxlEncoderSetColorEncoding(enc, &srgb)) return 1;
+
+    JxlEncoderFrameSettings *settings = JxlEncoderFrameSettingsCreate(enc, NULL);
+    JxlEncoderSetFrameLossless(settings, JXL_TRUE);
+    JxlPixelFormat rgb = {3, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN, 0}, grey = {1, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN, 0};
+    if (JxlEncoderAddImageFrame(settings, &rgb, color, w * h * 3)) return 1;
+    if (JxlEncoderSetExtraChannelBuffer(settings, &grey, black, w * h, 0)) return 1;
+    JxlEncoderCloseInput(enc);
+
+    uint8_t out[1 << 16], *next = out;
+    size_t avail = sizeof out;
+    if (JxlEncoderProcessOutput(enc, &next, &avail) != JXL_ENC_SUCCESS) return 1;
+    fwrite(out, 1, next - out, stdout);
+    JxlEncoderDestroy(enc);
+    return 0;
+}

scripts/jxl-fixtures.py

@@ -83,6 +83,16 @@ def write_pfm(path, im):
 frames[0].save(tmp / 'anim.png', save_all=True, append_images=frames[1:], duration=[40, 80, 40, 120], loop=0)
 encode('animation', tmp / 'anim.png', '-d', '0')
 encode('animation-lossy', tmp / 'anim.png', '-d', '2')
+# CMYK (scripts/jxl-cmyk.c, a black channel): the reference is the color times black, which djxl ignores without a
+# CMYK profile
+# (1 - ink: black is the darkest channel, the colors are divided by it)
+rgb = np.asarray(photo(32, 32), np.float64)
+k = np.maximum(rgb.max(axis=2, keepdims=True), 1)
+cmyk = np.round(np.dstack([rgb / k * 255, k])).astype(np.uint8)
+subprocess.run(['cc', '-o', str(tmp / 'jxl-cmyk'), str(root / 'scripts' / 'jxl-cmyk.c'), '-ljxl'], check=True)
+(out / 'cmyk.jxl').write_bytes(subprocess.run([str(tmp / 'jxl-cmyk'), '32', '32'], input=cmyk.tobytes(), check=True,
+                                              stdout=subprocess.PIPE).stdout)
+
 # conformance files: the step of the reference's samples
 conformances = {'alpha_nonpremultiplied': 4, 'alpha_premultiplied': 8, 'blendmodes': 8, 'mul_no_extra_channels': 1,
                 'animation_spline': 4}
@@ -93,6 +103,10 @@ def write_pfm(path, im):
 manifest = {}
 for jxl in sorted(out.glob('*.jxl')):
     png = jxl.with_suffix('.png')
+    if jxl.stem == 'cmyk':
+        Image.fromarray(np.round(cmyk[..., :3] * (cmyk[..., 3:] / 255)).astype(np.uint8)).save(png)
+        print(jxl.name, jxl.stat().st_size, png.stat().st_size)
+        continue
     subprocess.run([DJXL, str(jxl), str(png), '--bits_per_sample=8', '--color_space=RGB_D65_SRG_Rel_SRG', '--quiet'],
                    check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     step = conformances.get(jxl.stem.replace('-', '_'))

src/codecs/jxl/color.ts

@@ -3,7 +3,7 @@
  * (jxl-oxide's crates/jxl-color/src/ycbcr.rs); and the decoded image as 8-bit RGBA. Copyright (c) the JPEG XL Project
  * Authors, BSD-3-Clause License; Copyright (c) Wonwoo Choi, MIT License (see THIRD_PARTY_NOTICES.md)
  */
-import { ImageHeader, TF_PQ, TF_HLG, PRI_BT2100, PRI_P3, EXTRA_ALPHA, EXTRA_SPOT } from './headers.ts';
+import { ImageHeader, TF_PQ, TF_HLG, PRI_BT2100, PRI_P3, EXTRA_ALPHA, EXTRA_SPOT, EXTRA_BLACK } from './headers.ts';
 import { toSRGB, hdrToLinear, ToneMapping, REFERENCE_WHITE } from '../hdr.ts';
 import type { Planes } from './frame.ts';
 
@@ -67,6 +67,21 @@ export class ColorOutput {
         const n = p.width * p.height, ch = p.channels, image = this.image;
         const numColor = ch.length - image.extraChannels.length, grey = numColor === 1;
         let [r, g, b] = grey ? [ch[0], ch[0], ch[0]] : ch;
+        // CMYK (a black channel): the color channels and black are stored as 1 - ink, the color becomes their product
+        // (without the CMYK profile, like JPEGs' CMYK)
+        const black = image.extraChannels.findIndex(e => e.type === EXTRA_BLACK);
+        if (black >= 0) {
+            const k = ch[numColor + black];
+            if (grey) r = g = b = r.slice();
+            else [r, g, b] = [r.slice(), g.slice(), b.slice()];
+            for (let i = 0; i < n; i++) {
+                r[i] *= k[i];
+                if (!grey) {
+                    g[i] *= k[i];
+                    b[i] *= k[i];
+                }
+            }
+        }
         // spot colors (onto color images), mixed in by their solidity
         image.extraChannels.forEach((e, i) => {
             if (e.type !== EXTRA_SPOT || grey) return;