@@ -1,5 +1,15 @@
 # Changelog
 
+## 3.12.0
+
+### Changes
+
+- AVIFs without an ICC profile whose nclx box (or sequence header) gives other color primaries than sRGB's (Display
+  P3, BT.2020, DCI-P3, ...) or a gamma 2.2, 2.8 or linear transfer are converted to sRGB when decoding, like browsers
+  show them (`applyColorProfile: false` keeps the stored values): as a matrix/TRC profile of those primaries,
+  relative colorimetric, within 1 of LittleCMS. Transfers of the BT.709 family are taken as sRGB's curve, so most
+  AVIFs (BT.709 or unspecified primaries) stay the same.
+
 ## 3.11.0
 
 ### Fixes
 
@@ -5,8 +5,10 @@
 # parametric curve, Adobe RGB with a gamma, P3 with a table curve, Rec. 2020 with a type 4 parametric curve, gray), and
 # one that is sRGB (its pixels stay as they are), and a gray one on a color image (not applied). Also JPEG XLs by
 # cjxl: lossless ones (their pixels are in the profile's space) and a lossy one (XYB, decoded to sRGB: its profile is
-# only what the image was before). Needs Pillow (with AVIF), numpy and cjxl (libjxl):
-#   CJXL=path/to/cjxl python scripts/icc-fixtures.py
+# only what the image was before). And lossless AVIFs without a profile but other color primaries in their nclx box
+# (Display P3; BT.2020 with BT.709's transfer, taken as sRGB's curve) by avifenc, with LittleCMS's references of the
+# same primaries. Needs Pillow (with AVIF), numpy, cjxl (libjxl) and avifenc (libavif):
+#   CJXL=path/to/cjxl AVIFENC=path/to/avifenc python scripts/icc-fixtures.py
 import io, os, struct, subprocess
 from pathlib import Path
 import numpy as np
@@ -136,3 +138,16 @@ def convert(im, icc):
 # profile, decoded to sRGB without it)
 for name, distance in [('display-p3', 0), ('gray', 0), ('rec2020', 1)]:
     subprocess.run([os.environ.get('CJXL', 'cjxl'), '-d', str(distance), str(out / f'{name}.png'), str(out / f'{name}{"-xyb" if distance else ""}.jxl')], check=True, capture_output=True)
+
+# AVIFs with nclx primaries instead of a profile (lossless: their pixels are the source's)
+plain = source.copy()
+plain.putalpha(alpha)
+plain.save(out / 'nclx-source.png')
+bt2020 = rgb_profile([(0.708, 0.292), (0.170, 0.797), (0.131, 0.046)], SRGB_TRC, 'BT.2020 with sRGB curve')
+ref = convert(source, bt2020)
+ref.putalpha(alpha)
+ref.save(out / 'bt2020-nclx.ref.png')
+for name, cicp in [('display-p3-nclx', '12/13/0'), ('bt2020-nclx', '9/1/0')]:
+    subprocess.run([os.environ.get('AVIFENC', 'avifenc'), '--lossless', '--cicp', cicp, str(out / 'nclx-source.png'), str(out / f'{name}.avif')], check=True, capture_output=True)
+(out / 'nclx-source.png').unlink()
+
@@ -568,7 +568,7 @@ const MIN_THREADED_PIXELS = 4 << 20, PIXELS_PER_THREAD = 1 << 20;
 const TILES_PER_THREAD = 4;
 
 /** Decodes an AVIF's primary item or first frame, the conversion to RGBA in up to threads worker threads */
-export async function decode(d: Uint8Array, maxPixels = MAX_PIXELS, toneMapping: ToneMapping = 'reinhard', threads = 1): Promise<{ width: number, height: number, pixels: Uint8Array, icc?: Uint8Array }> {
+export async function decode(d: Uint8Array, maxPixels = MAX_PIXELS, toneMapping: ToneMapping = 'reinhard', threads = 1): Promise<{ width: number, height: number, pixels: Uint8Array, icc?: Uint8Array, cicp?: [number, number] }> {
     if (!isAVIF(d)) throw new Error('AVIF: invalid header');
     let meta: Box | undefined, moov: Box | undefined;
     for (const box of boxes(d, 0, d.length)) {
@@ -608,7 +608,7 @@ export async function decode(d: Uint8Array, maxPixels = MAX_PIXELS, toneMapping:
 }
 
 /** Decodes an image item (with its alpha item) and converts it to RGBA, in the threads if there are */
-async function decodeImage(d: Uint8Array, it: Item, items: Map<number, Item>, idat: Box | undefined, alphaItem: Item | undefined, alphaOf: (id: number) => Item | undefined, maxPixels: number, toneMapping: ToneMapping, threads: Thread[] | null): Promise<{ width: number, height: number, pixels: Uint8Array, icc?: Uint8Array }> {
+async function decodeImage(d: Uint8Array, it: Item, items: Map<number, Item>, idat: Box | undefined, alphaItem: Item | undefined, alphaOf: (id: number) => Item | undefined, maxPixels: number, toneMapping: ToneMapping, threads: Thread[] | null): Promise<{ width: number, height: number, pixels: Uint8Array, icc?: Uint8Array, cicp?: [number, number] }> {
     const color = await decodeItem(d, it, items, idat, maxPixels, threads);
     applyColr(d, it, color);
     // an ICC profile describes the RGB values (rather than the primaries and transfer of the nclx box or the
@@ -632,7 +632,8 @@ async function decodeImage(d: Uint8Array, it: Item, items: Map<number, Item>, id
         else if (box.type === 'irot') ({ width, height, pixels } = rotate(pixels, width, height, d[box.start] & 3));
         else if (box.type === 'imir') pixels = mirror(pixels, width, height, d[box.start] & 1);
     }
-    return { width, height, pixels, icc };
+    // (without a profile, the color primaries and transfer of the nclx box or the sequence header: see cicpTransform)
+    return { width, height, pixels, icc, cicp: icc ? undefined : [color.primaries, color.transfer] };
 }
 
 // the ICC profile of a colr box (prof or rICC)
@@ -701,7 +702,7 @@ function mirror(pixels: Uint8Array, width: number, height: number, axis: number)
 }
 
 // the first frame of an image sequence (the color track, and the alpha track that refers to it)
-async function decodeSequence(d: Uint8Array, moov: Box, maxPixels: number, toneMapping: ToneMapping): Promise<{ width: number, height: number, pixels: Uint8Array }> {
+async function decodeSequence(d: Uint8Array, moov: Box, maxPixels: number, toneMapping: ToneMapping): Promise<{ width: number, height: number, pixels: Uint8Array, cicp: [number, number] }> {
     const view = new DataView(d.buffer, d.byteOffset, d.byteLength);
     const tracks: Array<{ id: number, handler: string, auxl: number[], sample: Uint8Array, config: Uint8Array | null }> = [];
     for (const trak of boxes(d, moov.start, moov.end)) {
@@ -744,5 +745,5 @@ async function decodeSequence(d: Uint8Array, moov: Box, maxPixels: number, toneM
         return fromFrame(decodeAV1(data, 0, data.length, { maxPixels }));
     };
     const color = frame(colorTrack);
-    return { width: color.width, height: color.height, pixels: await toRgba(color, alphaTrack ? frame(alphaTrack) : null, toneMapping) };
+    return { width: color.width, height: color.height, pixels: await toRgba(color, alphaTrack ? frame(alphaTrack) : null, toneMapping), cicp: [color.primaries, color.transfer] };
 }
@@ -24,7 +24,7 @@ import * as quantize from './codecs/quantize.ts';
 import * as textRenderer from './render/text.ts';
 import * as svgRenderer from './render/svg.ts';
 import { BinaryData, view } from './util/mem.ts';
-import { profileTransform } from './util/icc.ts';
+import { cicpTransform, profileTransform } from './util/icc.ts';
 import { ImageType } from './image-type.ts';
 import { TextLayout } from './text-layout.ts';
 import { Metadata, resolveMetadata, pngText, exifData } from './metadata.ts';
@@ -199,11 +199,11 @@ export interface DecodeOptions {
     /** Whether to rotate/mirror JPEGs, TIFFs, PNGs and WebPs as their orientation tag (Exif or XMP) says. Default: `true` */
     applyOrientation?: boolean;
     /**
-     * Whether to convert the colors of images with an embedded ICC profile (PNG, JPEG, WebP, AVIF, TIFF) to sRGB, like
-     * browsers show them: wide gamut photos (Display P3 from phones, Adobe RGB, ProPhoto) look as intended instead of
-     * washed out. Matrix/TRC profiles (RGB and gray) are applied, relative colorimetric (colors outside sRGB are
-     * clipped); profiles with only lookup tables, CMYK ones and ones that are sRGB anyway leave the pixels as they are.
-     * Default: `true`
+     * Whether to convert the colors of images with an embedded ICC profile (PNG, JPEG, WebP, AVIF, JPEG XL, TIFF), and
+     * of AVIFs with other color primaries than sRGB's (Display P3, BT.2020), to sRGB, like browsers show them: wide
+     * gamut photos (Display P3 from phones, Adobe RGB, ProPhoto) look as intended instead of washed out. Matrix/TRC
+     * profiles (RGB and gray) are applied, relative colorimetric (colors outside sRGB are clipped); profiles with only
+     * lookup tables, CMYK ones and ones that are sRGB anyway leave the pixels as they are. Default: `true`
      */
     applyColorProfile?: boolean;
     /**
@@ -2257,7 +2257,7 @@ export class Image {
         const data = view(input);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
 
-        const decoded: { width: number, height: number, pixels: Uint8Array, orientation?: number, icc?: Uint8Array } = await decoding(() => {
+        const decoded: { width: number, height: number, pixels: Uint8Array, orientation?: number, icc?: Uint8Array, cicp?: [number, number] } = await decoding(() => {
             if (ImageType.isPNG(dataView)) return png.decode(data, maxPixels);
             if (ImageType.isJPEG(dataView)) return jpeg.decode(data, { maxPixels });
             if (ImageType.isTIFF(dataView)) return tiff.decode(data, maxPixels);
@@ -2283,7 +2283,8 @@ export class Image {
             throw new Error('Unsupported image type');
         });
 
-        if (applyColorProfile && decoded.icc) profileTransform(decoded.icc)?.(decoded.pixels);
+        // (an AVIF without one: its color primaries and transfer)
+        if (applyColorProfile) (decoded.icc ? profileTransform(decoded.icc) : decoded.cicp ? cicpTransform(...decoded.cicp) : null)?.(decoded.pixels);
         // the decoded pixels become the bitmap, without a copy
         const image = new Image(decoded.width, decoded.height);
         image.bitmap = decoded.pixels;
 
@@ -125,7 +125,53 @@ export function profileTransform(icc: Uint8Array): ((rgba: Uint8Array | Uint8Cla
     } catch {
         return null;
     }
-    if (!p || isSRGB(p)) return null;
+    return p && transform(p);
+}
+
+// the primaries (red, green, blue) and white of CICP's color primaries codes (ITU-T H.273) as xy chromaticities
+const CICP_PRIMARIES: Record<number, number[][]> = {
+    1: [[0.64, 0.33], [0.30, 0.60], [0.15, 0.06], [0.3127, 0.3290]],
+    4: [[0.67, 0.33], [0.21, 0.71], [0.14, 0.08], [0.310, 0.316]],
+    5: [[0.64, 0.33], [0.29, 0.60], [0.15, 0.06], [0.3127, 0.3290]],
+    6: [[0.630, 0.340], [0.310, 0.595], [0.155, 0.070], [0.3127, 0.3290]],
+    7: [[0.630, 0.340], [0.310, 0.595], [0.155, 0.070], [0.3127, 0.3290]],
+    8: [[0.681, 0.319], [0.243, 0.692], [0.145, 0.049], [0.310, 0.316]],
+    9: [[0.708, 0.292], [0.170, 0.797], [0.131, 0.046], [0.3127, 0.3290]],
+    11: [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060], [0.314, 0.351]],
+    12: [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060], [0.3127, 0.3290]],
+    22: [[0.630, 0.340], [0.295, 0.605], [0.155, 0.077], [0.3127, 0.3290]],
+};
+const D50 = [0.9642, 1, 0.8249];
+const BRADFORD = [0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296];
+
+/**
+ * The transform of 8-bit RGBA pixels with CICP color primaries and transfer characteristics (like an AVIF's nclx box)
+ * to sRGB, like an ICC profile's: null for sRGB's, unknown primaries and HDR transfers (PQ, HLG). Transfers other than
+ * gamma 2.2, 2.8 and linear are taken as sRGB's (the BT.709 family's curve describes cameras, displays show it as
+ * sRGB)
+ */
+export function cicpTransform(primaries: number, transfer: number): ((rgba: Uint8Array | Uint8ClampedArray) => void) | null {
+    const xy = CICP_PRIMARIES[primaries];
+    if (!xy || transfer === 16 || transfer === 18) return null;
+    const xyz = ([x, y]: number[]): number[] => [x / y, 1, (1 - x - y) / y];
+    // the primaries' XYZ (columns) scaled so they add up to the white, then adapted to D50 by Bradford
+    const p = [0, 1, 2].map(i => xyz(xy[i])), white = xyz(xy[3]);
+    const columns = [p[0][0], p[1][0], p[2][0], p[0][1], p[1][1], p[2][1], p[0][2], p[1][2], p[2][2]];
+    const inverse = invert3(columns);
+    if (!inverse) return null;
+    const scale = [0, 1, 2].map(r => inverse[r * 3] * white[0] + inverse[r * 3 + 1] * white[1] + inverse[r * 3 + 2] * white[2]);
+    const matrix = columns.map((v, i) => v * scale[i % 3]);
+    const cone = (v: number[]): number[] => [0, 1, 2].map(r => BRADFORD[r * 3] * v[0] + BRADFORD[r * 3 + 1] * v[1] + BRADFORD[r * 3 + 2] * v[2]);
+    const from = cone(white), to = cone(D50);
+    const adapt = multiply3(invert3(BRADFORD) as number[], multiply3([to[0] / from[0], 0, 0, 0, to[1] / from[1], 0, 0, 0, to[2] / from[2]], BRADFORD));
+    const curve: Curve = transfer === 4 ? v => v ** 2.2 : transfer === 5 ? v => v ** 2.8 : transfer === 8 ? v => v
+        : v => v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+    return transform({ gray: false, matrix: multiply3(adapt, matrix), curves: [curve, curve, curve] });
+}
+
+// a profile's transform of 8-bit RGBA pixels to sRGB (see profileTransform)
+function transform(p: Profile): ((rgba: Uint8Array | Uint8ClampedArray) => void) | null {
+    if (isSRGB(p)) return null;
 
     // 8-bit values to linear light per channel, linear sRGB to 8 bits through a fine table
     const linear = p.curves.map(c => Float32Array.from({ length: 256 }, (_, i) => c(i / 255)));
 
@@ -23,6 +23,8 @@ const difference = (a, b) => {
         ['display-p3.webp', 'display-p3.ref.png', 1], ['display-p3.tiff', 'display-p3.ref.png', 1],
         ['display-p3.jpg', 'display-p3.jpg.ref.png', 2], ['display-p3.avif', 'display-p3.avif.ref.png', 2],
         ['display-p3.jxl', 'display-p3.ref.png', 1], ['gray.jxl', 'gray.ref.png', 1],
+        // (AVIFs without a profile, their nclx box's color primaries: Display P3, BT.2020)
+        ['display-p3-nclx.avif', 'display-p3.ref.png', 1], ['bt2020-nclx.avif', 'bt2020-nclx.ref.png', 1],
     ];
     for (const [file, reference, tolerance] of cases) {
         const data = await fs.readFile(`./tests/icc/${file}`), ref = await Image.decode(await fs.readFile(`./tests/icc/${reference}`));