@photivra/engine 2.21.0 → 2.22.0

package/dist/capture/dng-import.d.ts

@@ -1,10 +1,19 @@
-export declare const DNG_IMPORT_SCHEMA_VERSION: "1.0.0";
-/** Upper bound for `maximumPixels`. 200 MP (megapixels) of 16-bit codes is 400 MB. */
+import { type DngJpegXlDecoder } from "./jpeg-xl-tiles.js";
+import { type DngOpcode } from "./dng-opcodes.js";
+import { type DngProfileGainTableMap, type DngRgbTables } from "./dng-profile-maps.js";
+/** 1.1.0 (2.22.0): lossy JPEG and JPEG XL raw data, opcode lists, profile maps, semantic masks, `scale`, `assumptions`. */
+export declare const DNG_IMPORT_SCHEMA_VERSION: "1.1.0";
+/**
+ * Upper bound for `maximumPixels`: 200 MP (megapixels) of 16-bit codes is 400 MB. `maximumBytes` bounds the estimated peak memory
+ * of the import (default 1 GiB, at most 4 GiB).
+ */
 export declare const DNG_IMPORT_LIMITS: Readonly<{
     defaultMaximumPixels: 64000000;
     maximumPixels: 200000000;
     defaultMaximumIfds: 64;
     maximumIfds: 1024;
+    defaultMaximumBytes: 1073741824;
+    maximumBytes: 4294967296;
 }>;
 export interface DngImportInput {
     bytes: Uint8Array;
@@ -12,6 +21,32 @@ export interface DngImportInput {
     maximumPixels?: number;
     /** Total IFDs (main chain plus SubIFDs) visited. Default 64, at most 1024. */
     maximumIfds?: number;
+    /**
+     * Estimated peak memory of the import, bytes (the codes, the largest strip or tile's decode buffers and its decoder's working
+     * memory; see docs/IMPORT_AND_PNG.md, "Memory"), checked before any image allocation. Default 1 073 741 824 (1 GiB), at most 4 GiB.
+     */
+    maximumBytes?: number;
+    /**
+     * "half": a half-size preview of a LinearRaw image, each output pixel the rounded mean of a 2 × 2 block of stored codes, decoded
+     * strip by strip (a quarter of the codes' memory). Areas, crops and black-level deltas are halved; CFA images are refused.
+     * Default "full".
+     */
+    size?: "full" | "half";
+}
+/** {@link importDngRawImage}'s input: {@link DngImportInput} plus the JPEG XL decoder a 52546 file needs. */
+export interface DngImportAsyncInput extends DngImportInput {
+    /** Decodes one JPEG XL strip or tile to PNG (`createJxlOxideDngDecoder`). Needed only for JPEG XL raw data or masks. */
+    jpegXlDecoder?: DngJpegXlDecoder;
+}
+/** A decoded semantic mask (DNG 1.6 SemanticName, NewSubFileType 0x10004, PhotometricInterpretation 52527). */
+export interface ImportedDngSemanticMask {
+    name: string;
+    /** SemanticInstanceID, or null. */
+    instanceId: string | null;
+    width: number;
+    height: number;
+    /** Mask values 0..1 (code / (2^bits − 1)), row-major. */
+    data: Float32Array;
 }
 /** Repeating CFA pattern. Its origin is the top-left corner of `activeArea` (DNG 1.7.1.0, PhotometricInterpretation). */
 export interface ImportedDngCfa {
@@ -54,7 +89,14 @@ export interface ImportedDngRaw {
     height: number;
     samplesPerPixel: number;
     bitsPerSample: number;
-    compression: "uncompressed" | "lossless-jpeg";
+    compression: "uncompressed" | "lossless-jpeg" | "lossy-jpeg" | "jpeg-xl";
+    /**
+     * True when the raw data went through a lossy coder: lossy JPEG always; JPEG XL when JXLDistance (52553) is above 0 or absent
+     * (the file then does not say it is lossless).
+     */
+    lossySource: boolean;
+    /** 1, or 0.5 for a `size: "half"` preview (every geometry field is already halved). */
+    scale: 1 | 0.5;
     photometricInterpretation: "cfa" | "linear-raw";
     /** Stored raw codes, row-major then sample, length width x height x samplesPerPixel. */
     codes: Uint16Array;
@@ -78,14 +120,37 @@ export interface ImportedDngRaw {
     asShotNeutral: number[] | null;
     /** RawDataUniqueID as 32 lowercase hex digits, or null. */
     rawDataUniqueId: string | null;
+    /** ForwardMatrix1/2 (white-balanced camera → XYZ D50), row-major 3 x colorPlanes, or null. */
+    forwardMatrix1: number[] | null;
+    forwardMatrix2: number[] | null;
+    /** BaselineExposure plus BaselineExposureOffset (stops), or null when neither is present. */
+    baselineExposure: number | null;
+    /** OpcodeList1/2/3 (raw IFD), parsed but not applied (`developDngStageImage` applies them), or null when absent. */
+    opcodeList1: DngOpcode[] | null;
+    opcodeList2: DngOpcode[] | null;
+    opcodeList3: DngOpcode[] | null;
+    /** ProfileGainTableMap2 (IFD 0), else ProfileGainTableMap (raw IFD), or null; applied by `applyDngProfileGainTableMap`. */
+    profileGainTableMap: DngProfileGainTableMap | null;
+    /** RGBTables (IFD 0), or null; applied by `applyDngRgbTables`. */
+    rgbTables: DngRgbTables | null;
+    /** Decoded semantic masks, for `applyDngRgbTables`. */
+    semanticMasks: ImportedDngSemanticMask[];
+    /** What the import did not do: tags present but not returned or applied, masks not decoded, lossy sources, inferred layouts. */
+    assumptions: string[];
 }
 /**
- * Parse one DNG or TIFF-EP file and decode its primary CFA or LinearRaw image (the first IFD with
- * NewSubFileType 0 and PhotometricInterpretation 32803 or 34892, in IFD-chain then SubIFD order).
+ * Parse one DNG or TIFF-EP file and decode its primary CFA or LinearRaw image (the first IFD with NewSubFileType 0 and
+ * PhotometricInterpretation 32803 or 34892, in IFD-chain then SubIFD order), synchronously.
  *
- * Supported raw data: Compression 1 at 8..16 bits/sample (8 bits as bytes, 16 bits in the file byte
- * order, other depths packed MSB-first with byte-aligned rows, per DNG BitsPerSample) and Compression 7
- * lossless Huffman JPEG (T.81 Annex H) in strips or tiles, chunky planar configuration only.
+ * Supported raw data: Compression 1 at 8..16 bits/sample (8 bits as bytes, 16 bits in the file byte order, other depths packed
+ * MSB-first with byte-aligned rows, per DNG BitsPerSample), Compression 7 lossless Huffman JPEG (T.81 Annex H) and Compression 34892
+ * 8-bit lossy JPEG (T.81 sequential DCT), in strips or tiles, chunky planar configuration only. JPEG XL (52546) needs
+ * {@link importDngRawImage}; a JPEG XL semantic mask is skipped here and named in `assumptions`.
  * @returns Owned typed arrays and plain metadata; nothing is applied to the codes.
  */
 export declare function parseDngRawImage(input: DngImportInput): ImportedDngRaw;
+/**
+ * {@link parseDngRawImage} for every supported compression, JPEG XL included: each JPEG XL strip or tile goes to `jpegXlDecoder` in
+ * turn (one at a time, so only one tile's decoder memory is held), and its PNG is read at the DNG's bit depth (jpeg-xl-tiles.ts).
+ */
+export declare function importDngRawImage(input: DngImportAsyncInput): Promise<ImportedDngRaw>;

package/dist/capture/dng-import.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // This product includes DNG technology under license by Adobe.
 /**
- * Browser-safe reader for DNG and TIFF-EP raw files with a CFA (colour filter array) mosaic.
+ * Browser-safe reader for DNG and TIFF-EP raw files with a CFA (colour filter array) mosaic or LinearRaw data.
  *
  * It was written independently from the published TIFF 6.0 tag definitions, the Adobe Digital
  * Negative (DNG) Specification 1.7.1.0 and the Exif 2.32/3.0 CFAPattern definition (CIPA DC-008;
@@ -10,7 +10,12 @@
  * It returns the stored raw codes plus the metadata the engine's RAW development needs: CFA
  * pattern, black and white levels, active area, default crop, colour matrices, as-shot neutral,
  * calibration illuminants and orientation. It never applies linearization, black subtraction,
- * white balance, demosaicing or colour transforms.
+ * white balance, demosaicing or colour transforms (`developDngStageImage` does the DNG stages).
+ *
+ * 2.22.0 (#598, phone RAW files): lossy JPEG (Compression 34892, DNG 1.4.0.0) and JPEG XL (52546, DNG 1.7.0.0) raw data,
+ * Row/ColumnInterleaveFactor, the opcode lists, the profile gain table map, RGBTables and semantic masks, a `maximumBytes` memory
+ * pre-check and a half-size LinearRaw preview. Every DNG 1.5–1.7 tag that would change the rendering and is not returned or
+ * applied is named in `assumptions`; none of them fails an import.
  *
  * Input is untrusted. Every offset, count, IFD (image file directory) chain, strip or tile table
  * and decoded size is checked against the buffer and explicit limits before allocation. IFD loops,
@@ -20,9 +25,18 @@
  */
 import { InvalidConfigurationError } from "../core/configuration-error.js";
 import { parseLosslessJpeg } from "./lossless-jpeg.js";
-export const DNG_IMPORT_SCHEMA_VERSION = "1.0.0";
-/** Upper bound for `maximumPixels`. 200 MP (megapixels) of 16-bit codes is 400 MB. */
-export const DNG_IMPORT_LIMITS = /* @__PURE__ */ Object.freeze({ defaultMaximumPixels: 64_000_000, maximumPixels: 200_000_000, defaultMaximumIfds: 64, maximumIfds: 1024 });
+import { parseLossyJpeg } from "./lossy-jpeg.js";
+import { readJpegXlTilePng } from "./jpeg-xl-tiles.js";
+import { parseDngOpcodeList } from "./dng-opcodes.js";
+import { parseDngProfileGainTableMap, parseDngRgbTables } from "./dng-profile-maps.js";
+/** 1.1.0 (2.22.0): lossy JPEG and JPEG XL raw data, opcode lists, profile maps, semantic masks, `scale`, `assumptions`. */
+export const DNG_IMPORT_SCHEMA_VERSION = "1.1.0";
+/**
+ * Upper bound for `maximumPixels`: 200 MP (megapixels) of 16-bit codes is 400 MB. `maximumBytes` bounds the estimated peak memory
+ * of the import (default 1 GiB, at most 4 GiB).
+ */
+export const DNG_IMPORT_LIMITS = /* @__PURE__ */ Object.freeze({ defaultMaximumPixels: 64_000_000, maximumPixels: 200_000_000, defaultMaximumIfds: 64, maximumIfds: 1024,
+    defaultMaximumBytes: 1_073_741_824, maximumBytes: 4_294_967_296 });
 const TYPE_SIZES = [0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4];
 function fail(message) { throw new InvalidConfigurationError("DNG import: " + message); }
 function limit(value, fallback, max, name) {
@@ -32,26 +46,27 @@ function limit(value, fallback, max, name) {
         fail(name + " must be an integer from 1 to " + max + ".");
     return value;
 }
-/**
- * Parse one DNG or TIFF-EP file and decode its primary CFA or LinearRaw image (the first IFD with
- * NewSubFileType 0 and PhotometricInterpretation 32803 or 34892, in IFD-chain then SubIFD order).
- *
- * Supported raw data: Compression 1 at 8..16 bits/sample (8 bits as bytes, 16 bits in the file byte
- * order, other depths packed MSB-first with byte-aligned rows, per DNG BitsPerSample) and Compression 7
- * lossless Huffman JPEG (T.81 Annex H) in strips or tiles, chunky planar configuration only.
- * @returns Owned typed arrays and plain metadata; nothing is applied to the codes.
- */
-export function parseDngRawImage(input) {
+/** Rendering-relevant tags that are not returned or applied, by tag id (DNG 1.4–1.7 tag names). */
+const UNAPPLIED_TAGS = [[50938, "ProfileHueSatMapData1"], [50939, "ProfileHueSatMapData2"], [50940, "ProfileToneCurve"], [50982, "ProfileLookTableData"],
+    [51110, "DefaultBlackRender"], [52529, "CalibrationIlluminant3"], [52531, "ColorMatrix3"], [52532, "ForwardMatrix3"], [52533, "IlluminantData1"], [52534, "IlluminantData2"],
+    [52535, "IlluminantData3"], [52551, "ProfileDynamicRange"], [51182, "EnhanceParams"], [52545, "JUMBF (C2PA)"], [52539, "RGBTables (draft)"]];
+/** Estimated JPEG XL decoder working memory per sample, bytes (an estimate, not measured: 32-bit channels, a float render and the PNG). */
+const JXL_WORKING_BYTES_PER_SAMPLE = 16;
+function prepare(input, keys) {
     if (input === null || typeof input !== "object")
         fail("input must be an object.");
     for (const key of Object.keys(input))
-        if (!["bytes", "maximumPixels", "maximumIfds"].includes(key))
+        if (!keys.includes(key))
             fail(`unknown input field. Unknown field ${JSON.stringify(key)}.`);
     const bytes = input.bytes;
     if (!(bytes instanceof Uint8Array))
         fail("bytes must be a Uint8Array.");
     const maximumPixels = limit(input.maximumPixels, DNG_IMPORT_LIMITS.defaultMaximumPixels, DNG_IMPORT_LIMITS.maximumPixels, "maximumPixels");
     const maximumIfds = limit(input.maximumIfds, DNG_IMPORT_LIMITS.defaultMaximumIfds, DNG_IMPORT_LIMITS.maximumIfds, "maximumIfds");
+    const maximumBytes = limit(input.maximumBytes, DNG_IMPORT_LIMITS.defaultMaximumBytes, DNG_IMPORT_LIMITS.maximumBytes, "maximumBytes");
+    if (input.size !== undefined && input.size !== "full" && input.size !== "half")
+        fail('size must be "full" or "half".');
+    const half = input.size === "half";
     const n = bytes.length, view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     if (n < 8)
         fail("file is too short.");
@@ -163,7 +178,7 @@ export function parseDngRawImage(input) {
     const ascii = (entry) => {
         if (!entry)
             return null;
-        if (entry.type !== 2 || entry.count > 4096)
+        if ((entry.type !== 2 && entry.type !== 1) || entry.count > 4096)
             fail("invalid ASCII tag.");
         let s = "";
         for (let i = 0; i < entry.count && bytes[entry.at + i] !== 0; i++)
@@ -174,74 +189,103 @@ export function parseDngRawImage(input) {
         const v = integers(ifd.get(id), 1, [3, 4]);
         return v ? v[0] : fallback;
     };
+    const blob = (entry) => entry ? bytes.subarray(entry.at, entry.at + entry.count * TYPE_SIZES[entry.type]) : null;
     const raw = ifds.find((ifd) => one(ifd, 254, 0) === 0 && [32803, 34892].includes(one(ifd, 262, -1)));
     if (!raw)
         fail("no primary CFA or LinearRaw image IFD.");
     const ifd0 = ifds[0];
     // DNG places camera-level tags in IFD 0; TIFF-EP files may carry them only in the raw IFD.
     const pick = (id) => ifd0.get(id) ?? raw.get(id);
-    const width = one(raw, 256, 0), height = one(raw, 257, 0), spp = one(raw, 277, 1), compressionCode = one(raw, 259, 1), photometric = one(raw, 262, 0);
-    if (width < 1 || height < 1 || width > 65535 * 4 || height > 65535 * 4)
-        fail("invalid image dimensions.");
-    if (width * height > maximumPixels)
-        fail("image exceeds the pixel limit.");
-    const cfaImage = photometric === 32803;
-    if (cfaImage ? spp !== 1 : spp < 1 || spp > 4)
-        fail("unsupported SamplesPerPixel.");
-    if (spp > 1 && one(raw, 284, 1) !== 1)
-        fail("only chunky PlanarConfiguration is supported.");
-    const bps = integers(raw.get(258), spp, [3]) ?? [1];
-    if (bps.length !== spp || bps.some((b) => b !== bps[0]))
-        fail("BitsPerSample must be equal for every sample.");
-    const bitsPerSample = bps[0];
-    if (bitsPerSample < 8 || bitsPerSample > 16)
-        fail("only 8 to 16 bits per sample are supported.");
-    if (one(raw, 339, 1) !== 1)
-        fail("only unsigned integer samples are supported.");
-    if (compressionCode !== 1 && compressionCode !== 7)
-        fail("only uncompressed and lossless JPEG raw data are supported.");
     const dngVersionTag = integers(ifd0.get(50706), 4, [1]);
     const dngVersion = dngVersionTag && dngVersionTag.length === 4 ? dngVersionTag : null;
     if (dngVersionTag && !dngVersion)
         fail("invalid DNGVersion.");
-    // Strip or tile layout.
-    const tiled = raw.has(322) || raw.has(324);
-    const tileWidth = tiled ? one(raw, 322, 0) : width, tileLength = tiled ? one(raw, 323, 0) : Math.min(height, one(raw, 278, 0xffffffff));
-    if (tileWidth < 1 || tileLength < 1 || tileWidth > 65535 * 4 || tileLength > 65535 * 4 || (tiled && tileWidth * tileLength > maximumPixels))
-        fail("invalid strip or tile size.");
-    const across = Math.ceil(width / tileWidth), down = Math.ceil(height / tileLength), chunks = across * down;
-    const offsets = integers(raw.get(tiled ? 324 : 273), chunks, [3, 4]), counts = integers(raw.get(tiled ? 325 : 279), chunks, [3, 4]);
-    if (!offsets || !counts || offsets.length !== chunks || counts.length !== chunks)
-        fail("strip or tile tables do not match the image layout.");
-    for (let i = 0; i < chunks; i++)
-        if (offsets[i] + counts[i] > n)
-            fail("strip or tile data exceeds the file.");
-    const codes = new Uint16Array(width * height * spp), maxCode = 2 ** bitsPerSample - 1;
-    for (let ty = 0; ty < down; ty++)
-        for (let tx = 0; tx < across; tx++) {
-            const index = ty * across + tx, start = offsets[index], data = bytes.subarray(start, start + counts[index]);
+    const assumptions = [];
+    /** Plans one image IFD (the raw image or a mask): layout checks and the strip or tile table. */
+    const plan = (ifd, kind) => {
+        const width = one(ifd, 256, 0), height = one(ifd, 257, 0), spp = one(ifd, 277, 1), code = one(ifd, 259, 1), photometric = one(ifd, 262, 0);
+        if (width < 1 || height < 1 || width > 65535 * 4 || height > 65535 * 4)
+            fail("invalid image dimensions.");
+        if (width * height > maximumPixels)
+            fail("image exceeds the pixel limit.");
+        if (kind === "mask" ? spp !== 1 : photometric === 32803 ? spp !== 1 : spp < 1 || spp > 4)
+            fail("unsupported SamplesPerPixel.");
+        if (spp > 1 && one(ifd, 284, 1) !== 1)
+            fail("only chunky PlanarConfiguration is supported.");
+        const bps = integers(ifd.get(258), spp, [3]) ?? [1];
+        if (bps.length !== spp || bps.some((b) => b !== bps[0]))
+            fail("BitsPerSample must be equal for every sample.");
+        const bits = bps[0];
+        if (bits < 8 || bits > 16)
+            fail("only 8 to 16 bits per sample are supported.");
+        if (one(ifd, 339, 1) !== 1)
+            fail("only unsigned integer samples are supported.");
+        if (![1, 7, 34892, 52546].includes(code))
+            fail("Compression " + code + " is not supported (supported: 1 uncompressed, 7 lossless JPEG, 34892 lossy JPEG, 52546 JPEG XL).");
+        if (code === 34892 && (bits !== 8 || photometric === 32803))
+            fail("lossy JPEG (Compression 34892) raw data must be 8-bit LinearRaw or a mask (DNG 1.4.0.0).");
+        const tiled = ifd.has(322) || ifd.has(324);
+        const tileWidth = tiled ? one(ifd, 322, 0) : width, tileLength = tiled ? one(ifd, 323, 0) : Math.min(height, one(ifd, 278, 0xffffffff));
+        if (tileWidth < 1 || tileLength < 1 || tileWidth > 65535 * 4 || tileLength > 65535 * 4 || (tiled && tileWidth * tileLength > maximumPixels))
+            fail("invalid strip or tile size.");
+        const across = Math.ceil(width / tileWidth), down = Math.ceil(height / tileLength), count = across * down;
+        const offsets = integers(ifd.get(tiled ? 324 : 273), count, [3, 4]), counts = integers(ifd.get(tiled ? 325 : 279), count, [3, 4]);
+        if (!offsets || !counts || offsets.length !== count || counts.length !== count)
+            fail("strip or tile tables do not match the image layout.");
+        const chunks = [];
+        for (let i = 0; i < count; i++) {
+            if (offsets[i] + counts[i] > n)
+                fail("strip or tile data exceeds the file.");
+            const tx = i % across, ty = Math.floor(i / across);
             // Strips cover whole rows (the last may be short); tiles are always full-size and clipped on copy.
-            const chunkWidth = tiled ? tileWidth : width, chunkRows = tiled ? tileLength : Math.min(tileLength, height - ty * tileLength);
-            const chunkSamples = chunkWidth * chunkRows * spp, x0 = tx * tileWidth, y0 = ty * tileLength;
-            let samples;
-            if (compressionCode === 7) {
-                const image = parseLosslessJpeg(data, { maximumSamples: chunkSamples, legacySixteenBitDifference: dngVersion !== null && (dngVersion[0] < 1 || (dngVersion[0] === 1 && dngVersion[1] < 1)) });
-                if (image.width * image.height * image.components !== chunkSamples)
-                    fail("lossless JPEG sample count does not match the strip or tile.");
-                samples = image.samples;
-            }
-            else
-                samples = unpack(data, chunkWidth * spp, chunkRows, bitsPerSample, little);
-            for (let y = 0; y < chunkRows && y0 + y < height; y++) {
-                const columns = Math.min(chunkWidth, width - x0) * spp, from = y * chunkWidth * spp, to = ((y0 + y) * width + x0) * spp;
+            chunks.push({ data: bytes.subarray(offsets[i], offsets[i] + counts[i]), x0: tx * tileWidth, y0: ty * tileLength, width: tiled ? tileWidth : width, rows: tiled ? tileLength : Math.min(tileLength, height - ty * tileLength) });
+        }
+        return { width, height, spp, bits, code, chunks, jpegTables: blob(ifd.get(347)) ?? undefined, legacy: dngVersion !== null && (dngVersion[0] < 1 || (dngVersion[0] === 1 && dngVersion[1] < 1)) };
+    };
+    const image = plan(raw, "raw"), { width, height, spp, bits: bitsPerSample, code: compressionCode } = image;
+    const photometric = one(raw, 262, 0), cfaImage = photometric === 32803;
+    const rowInterleave = one(raw, 50975, 1), columnInterleave = one(raw, 52547, 1);
+    if (rowInterleave < 1 || rowInterleave > height || columnInterleave < 1 || columnInterleave > width)
+        fail("invalid RowInterleaveFactor or ColumnInterleaveFactor.");
+    const interleaved = rowInterleave > 1 || columnInterleave > 1;
+    if (half && cfaImage)
+        fail('size "half" needs LinearRaw data; this file is a CFA mosaic.');
+    if (half && interleaved)
+        fail('size "half" is not available for row- or column-interleaved data.');
+    if (interleaved)
+        assumptions.push("dngImport.interleave: RowInterleaveFactor " + rowInterleave + " and ColumnInterleaveFactor " + columnInterleave + " undone; the stored order (each field of rows or columns stored together, field by field) is inferred from the DNG SDK, not yet verified on a phone file.");
+    // Memory pre-check (estimates, docs/IMPORT_AND_PNG.md "Memory"): output codes (plus the half-size sums), one chunk's decoded
+    // samples twice (decode buffer and copy), and its decoder's working memory.
+    const outWidth = half ? Math.ceil(width / 2) : width, outHeight = half ? Math.ceil(height / 2) : height;
+    const largest = Math.max(...image.chunks.map((c) => c.width * c.rows)) * spp;
+    const decoderBytes = compressionCode === 52546 ? largest * JXL_WORKING_BYTES_PER_SAMPLE : compressionCode === 34892 ? largest * 2 + largest : largest * 2;
+    const estimate = outWidth * outHeight * spp * 2 + (half ? outWidth * outHeight * spp * 4 : 0) + (interleaved ? width * height * spp * 2 : 0) + largest * 4 + decoderBytes;
+    if (estimate > maximumBytes)
+        fail("the import needs an estimated " + Math.ceil(estimate / 1048576) + " MiB, above maximumBytes (" + Math.floor(maximumBytes / 1048576) + " MiB); raise maximumBytes or use size \"half\" for a LinearRaw preview.");
+    const maxCode = 2 ** bitsPerSample - 1, codes = new Uint16Array(outWidth * outHeight * spp), sums = half ? new Uint32Array(outWidth * outHeight * spp) : null;
+    const write = (chunk, samples) => {
+        for (let y = 0; y < chunk.rows && chunk.y0 + y < height; y++) {
+            const columns = Math.min(chunk.width, width - chunk.x0) * spp, from = y * chunk.width * spp;
+            if (sums) {
+                const row = ((chunk.y0 + y) >> 1) * outWidth;
                 for (let i = 0; i < columns; i++) {
                     const v = samples[from + i];
                     if (v > maxCode)
                         fail("raw code exceeds BitsPerSample.");
-                    codes[to + i] = v;
+                    const x = chunk.x0 + Math.floor(i / spp), at = (row + (x >> 1)) * spp + (i % spp);
+                    sums[at] = sums[at] + v;
                 }
+                continue;
+            }
+            const to = ((chunk.y0 + y) * width + chunk.x0) * spp;
+            for (let i = 0; i < columns; i++) {
+                const v = samples[from + i];
+                if (v > maxCode)
+                    fail("raw code exceeds BitsPerSample.");
+                codes[to + i] = v;
             }
         }
+    };
     // CFA description.
     let cfa = null, colorPlanes = spp;
     if (cfaImage) {
@@ -280,10 +324,10 @@ export function parseDngRawImage(input) {
     if (origin.length !== 2 || size.length !== 2 || size[0] <= 0 || size[1] <= 0 || origin[0] < 0 || origin[1] < 0)
         fail("invalid default crop.");
     const linear = integers(raw.get(50712), 65536, [3]);
-    const matrix = (id) => {
+    const matrix = (id, transpose = false) => {
         const m = integers(pick(id), colorPlanes * 3, [10]);
         if (m && m.length !== colorPlanes * 3)
-            fail("ColorMatrix count does not match the colour planes.");
+            fail((transpose ? "ForwardMatrix" : "ColorMatrix") + " count does not match the colour planes.");
         return m;
     };
     const neutral = integers(pick(50728), colorPlanes, [3, 5]);
@@ -296,18 +340,209 @@ export function parseDngRawImage(input) {
     const orientation = one(ifd0.has(274) ? ifd0 : raw, 274, 1);
     if (orientation < 1 || orientation > 8)
         fail("invalid Orientation.");
-    return {
-        schemaVersion: DNG_IMPORT_SCHEMA_VERSION, byteOrder: little ? "little-endian" : "big-endian", dngVersion,
-        make: ascii(pick(271)), model: ascii(pick(272)), uniqueCameraModel: ascii(pick(50708)), orientation,
-        width, height, samplesPerPixel: spp, bitsPerSample, compression: compressionCode === 1 ? "uncompressed" : "lossless-jpeg",
-        photometricInterpretation: cfaImage ? "cfa" : "linear-raw", codes, cfa,
-        linearizationTable: linear ? Uint16Array.from(linear) : null,
-        blackLevel: { repeatRows: repeat[0], repeatColumns: repeat[1], values: black, deltaH, deltaV },
-        whiteLevel, activeArea, defaultCrop: { x: origin[0], y: origin[1], width: size[0], height: size[1] },
-        colorMatrix1: matrix(50721), colorMatrix2: matrix(50722),
-        calibrationIlluminant1: illuminant(50778), calibrationIlluminant2: illuminant(50779), asShotNeutral: neutral,
-        rawDataUniqueId: uniqueId ? uniqueId.map((b) => b.toString(16).padStart(2, "0")).join("") : null
+    // Phone tags (#598): parsed when present; a malformed one is reported, never a failure.
+    const optional = (name, read) => {
+        try {
+            return read();
+        }
+        catch (error) {
+            if (!(error instanceof InvalidConfigurationError))
+                throw error;
+            assumptions.push("dngImport.ignored: " + name + " is malformed and was ignored (" + error.message + ").");
+            return null;
+        }
     };
+    const opcodes = (id, name) => { const b = blob(raw.get(id)); return b ? optional(name, () => parseDngOpcodeList(b)) : null; };
+    const opcodeList1 = opcodes(51008, "OpcodeList1"), opcodeList2 = opcodes(51009, "OpcodeList2"), opcodeList3 = opcodes(51022, "OpcodeList3");
+    const pgtm2 = blob(ifd0.get(52544)), pgtm1 = blob(raw.get(52525));
+    const profileGainTableMap = (pgtm2 ? optional("ProfileGainTableMap2", () => parseDngProfileGainTableMap(pgtm2, little, 2)) : null)
+        ?? (pgtm1 ? optional("ProfileGainTableMap", () => parseDngProfileGainTableMap(pgtm1, little, 1)) : null);
+    const rgbBlob = blob(ifd0.get(52543)), rgbTables = rgbBlob ? optional("RGBTables", () => parseDngRgbTables(rgbBlob, little)) : null;
+    const exposure = integers(pick(50730), 1, [10]), exposureOffset = integers(pick(51109), 1, [10]);
+    const baselineExposure = exposure || exposureOffset ? (exposure?.[0] ?? 0) + (exposureOffset?.[0] ?? 0) : null;
+    for (const [id, name] of UNAPPLIED_TAGS)
+        if (ifd0.has(id) || raw.has(id))
+            assumptions.push("dngImport.notApplied: " + name + " (" + id + ") is present and not applied.");
+    for (const ifd of ifds) {
+        const type = one(ifd, 254, 0);
+        if (type === 8 || type === 9)
+            assumptions.push("dngImport.notApplied: a depth map IFD is present and not decoded.");
+        if (type === 16)
+            assumptions.push("dngImport.notApplied: an enhanced-image IFD (NewSubFileType 16) is present and not decoded; the raw image is used.");
+        if (type === 32 || one(ifd, 262, 0) === 52553)
+            assumptions.push("dngImport.notApplied: a gain-map image IFD (NewSubFileType 32) is present and not applied.");
+    }
+    if (compressionCode === 34892)
+        assumptions.push("dngImport.lossySource: the raw data is lossy JPEG (Compression 34892), 8-bit and gamma-coded; OpcodeList2 or the LinearizationTable makes it linear.");
+    const jxlDistance = integers(ifd0.get(52553) ?? raw.get(52553), 1, [11, 12]);
+    const lossyJxl = compressionCode === 52546 && !(jxlDistance && jxlDistance[0] <= 0);
+    if (lossyJxl)
+        assumptions.push("dngImport.lossySource: the JPEG XL raw data is " + (jxlDistance ? "lossy (JXLDistance " + jxlDistance[0] + ")." : "not marked lossless (no JXLDistance tag)."));
+    if (linear)
+        assumptions.push("dngImport.linearizationTable: returned, not applied to codes (developDngStageImage applies it).");
+    if (opcodeList1 || opcodeList2 || opcodeList3)
+        assumptions.push("dngImport.opcodes: the opcode lists are returned, not applied to codes (developDngStageImage applies them).");
+    if (profileGainTableMap)
+        assumptions.push("dngImport.profileGainTableMap: returned (version " + profileGainTableMap.version + "); applyDngProfileGainTableMap applies it in a development.");
+    if (rgbTables)
+        assumptions.push("dngImport.rgbTables: returned (" + rgbTables.tables.length + " tables); applyDngRgbTables applies them in a development.");
+    // Semantic masks (DNG 1.6): planned here, decoded with the image.
+    const masks = ifds.filter((ifd) => one(ifd, 254, 0) === 0x10004 && one(ifd, 262, 0) === 52527).map((ifd) => {
+        if (ifd.has(52536))
+            assumptions.push("dngImport.semanticMask: MaskSubArea is present; the mask is returned as stored and spans the whole image in applyDngRgbTables.");
+        return { name: ascii(ifd.get(52526)) ?? "", instanceId: ascii(ifd.get(52528)), ifd };
+    });
+    const halve = (r) => half ? { x: r.x / 2, y: r.y / 2, width: r.width / 2, height: r.height / 2 } : r;
+    const pairMean = (values) => values && half ? Array.from({ length: Math.ceil(values.length / 2) }, (_, i) => (values[2 * i] + (values[2 * i + 1] ?? values[2 * i])) / 2) : values;
+    const halfActive = half ? { x: Math.floor(activeArea.x / 2), y: Math.floor(activeArea.y / 2), width: Math.ceil((activeArea.x + activeArea.width) / 2) - Math.floor(activeArea.x / 2), height: Math.ceil((activeArea.y + activeArea.height) / 2) - Math.floor(activeArea.y / 2) } : activeArea;
+    let blackLevel = { repeatRows: repeat[0], repeatColumns: repeat[1], values: black, deltaH, deltaV };
+    if (half) {
+        // Half size: the black pattern is averaged over its repeat (a LinearRaw file normally has a 1 x 1 repeat), the deltas pairwise.
+        const mean = Array.from({ length: spp }, (_, s) => { let t = 0; for (let k = 0; k < repeat[0] * repeat[1]; k++)
+            t += black[k * spp + s]; return t / (repeat[0] * repeat[1]); });
+        blackLevel = { repeatRows: 1, repeatColumns: 1, values: mean, deltaH: pairMean(deltaH), deltaV: pairMean(deltaV) };
+        if (repeat[0] * repeat[1] > 1)
+            assumptions.push("dngImport.halfSize: the BlackLevel repeat pattern was averaged to one value per sample.");
+        assumptions.push("dngImport.halfSize: a half-size preview; each code is the rounded mean of a 2 x 2 block of stored codes.");
+    }
+    const finish = (semanticMasks) => {
+        if (sums)
+            for (let y = 0; y < outHeight; y++)
+                for (let x = 0; x < outWidth; x++) {
+                    const count = (Math.min(2, height - 2 * y)) * (Math.min(2, width - 2 * x));
+                    for (let s = 0; s < spp; s++) {
+                        const at = (y * outWidth + x) * spp + s;
+                        codes[at] = Math.round(sums[at] / count);
+                    }
+                }
+        const out = interleaved ? deinterleave(codes, width, height, spp, rowInterleave, columnInterleave) : codes;
+        return {
+            schemaVersion: DNG_IMPORT_SCHEMA_VERSION, byteOrder: little ? "little-endian" : "big-endian", dngVersion,
+            make: ascii(pick(271)), model: ascii(pick(272)), uniqueCameraModel: ascii(pick(50708)), orientation,
+            width: outWidth, height: outHeight, samplesPerPixel: spp, bitsPerSample,
+            compression: compressionCode === 1 ? "uncompressed" : compressionCode === 7 ? "lossless-jpeg" : compressionCode === 34892 ? "lossy-jpeg" : "jpeg-xl",
+            lossySource: compressionCode === 34892 || lossyJxl, scale: half ? 0.5 : 1,
+            photometricInterpretation: cfaImage ? "cfa" : "linear-raw", codes: out, cfa,
+            linearizationTable: linear ? Uint16Array.from(linear) : null,
+            blackLevel, whiteLevel, activeArea: halfActive, defaultCrop: halve({ x: origin[0], y: origin[1], width: size[0], height: size[1] }),
+            colorMatrix1: matrix(50721), colorMatrix2: matrix(50722),
+            calibrationIlluminant1: illuminant(50778), calibrationIlluminant2: illuminant(50779), asShotNeutral: neutral,
+            rawDataUniqueId: uniqueId ? uniqueId.map((b) => b.toString(16).padStart(2, "0")).join("") : null,
+            forwardMatrix1: matrix(50964, true), forwardMatrix2: matrix(50965, true), baselineExposure,
+            opcodeList1, opcodeList2, opcodeList3, profileGainTableMap, rgbTables, semanticMasks, assumptions
+        };
+    };
+    return { image, write, finish, masks, plan, assumptions, little };
+}
+/** Decodes one chunk without a JPEG XL decoder; null for JPEG XL data. */
+function decodeChunkSync(p, chunk, little) {
+    const samples = chunk.width * chunk.rows * p.spp;
+    if (p.code === 7) {
+        const image = parseLosslessJpeg(chunk.data, { maximumSamples: samples, legacySixteenBitDifference: p.legacy });
+        if (image.width * image.height * image.components !== samples)
+            fail("lossless JPEG sample count does not match the strip or tile.");
+        return image.samples;
+    }
+    if (p.code === 34892) {
+        const image = parseLossyJpeg(chunk.data, { maximumSamples: samples, ...(p.jpegTables ? { tables: p.jpegTables } : {}) });
+        if (image.width !== chunk.width || image.height !== chunk.rows || image.components !== p.spp)
+            fail("lossy JPEG size or components do not match the strip or tile.");
+        return Uint16Array.from(image.samples);
+    }
+    if (p.code === 52546)
+        return null;
+    return unpack(chunk.data, chunk.width * p.spp, chunk.rows, p.bits, little);
+}
+async function decodeChunk(p, chunk, little, decoder) {
+    const sync = decodeChunkSync(p, chunk, little);
+    if (sync)
+        return sync;
+    if (!decoder)
+        fail("JPEG XL (Compression 52546) data needs a jpegXlDecoder (importDngRawImage).");
+    return readJpegXlTilePng(await decoder(chunk.data), chunk.width, chunk.rows, p.spp, p.bits);
+}
+/** Copies decoded chunks into a mask's 0..1 values. */
+function maskValues(p, decoded) {
+    const out = new Float32Array(p.width * p.height), scale = 1 / (2 ** p.bits - 1);
+    p.chunks.forEach((chunk, k) => {
+        for (let y = 0; y < chunk.rows && chunk.y0 + y < p.height; y++)
+            for (let x = 0; x < chunk.width && chunk.x0 + x < p.width; x++)
+                out[(chunk.y0 + y) * p.width + chunk.x0 + x] = Math.min(1, decoded[k][y * chunk.width + x] * scale);
+    });
+    return out;
+}
+/**
+ * Undoes Row/ColumnInterleaveFactor (DNG 1.7.0.0): stored row s of a factor-R image holds image row (s mod ⌈H/R⌉)·R + ⌊s/⌈H/R⌉⌋
+ * (each field of every R-th row stored together, field by field), and likewise for columns. Inferred from the DNG SDK's
+ * `Interleave2D`; to be verified on a phone file.
+ */
+function deinterleave(codes, width, height, spp, rows, columns) {
+    const out = new Uint16Array(codes.length), fieldRows = Math.ceil(height / rows), fieldColumns = Math.ceil(width / columns);
+    for (let s = 0; s < height; s++) {
+        const y = (s % fieldRows) * rows + Math.floor(s / fieldRows);
+        if (y >= height)
+            fail("RowInterleaveFactor does not divide the stored rows into whole fields.");
+        for (let t = 0; t < width; t++) {
+            const x = (t % fieldColumns) * columns + Math.floor(t / fieldColumns);
+            if (x >= width)
+                fail("ColumnInterleaveFactor does not divide the stored columns into whole fields.");
+            for (let c = 0; c < spp; c++)
+                out[(y * width + x) * spp + c] = codes[(s * width + t) * spp + c];
+        }
+    }
+    return out;
+}
+/**
+ * Parse one DNG or TIFF-EP file and decode its primary CFA or LinearRaw image (the first IFD with NewSubFileType 0 and
+ * PhotometricInterpretation 32803 or 34892, in IFD-chain then SubIFD order), synchronously.
+ *
+ * Supported raw data: Compression 1 at 8..16 bits/sample (8 bits as bytes, 16 bits in the file byte order, other depths packed
+ * MSB-first with byte-aligned rows, per DNG BitsPerSample), Compression 7 lossless Huffman JPEG (T.81 Annex H) and Compression 34892
+ * 8-bit lossy JPEG (T.81 sequential DCT), in strips or tiles, chunky planar configuration only. JPEG XL (52546) needs
+ * {@link importDngRawImage}; a JPEG XL semantic mask is skipped here and named in `assumptions`.
+ * @returns Owned typed arrays and plain metadata; nothing is applied to the codes.
+ */
+export function parseDngRawImage(input) {
+    const ctx = prepare(input, ["bytes", "maximumPixels", "maximumIfds", "maximumBytes", "size"]);
+    if (ctx.image.code === 52546)
+        fail("JPEG XL (Compression 52546) raw data needs importDngRawImage with a jpegXlDecoder.");
+    for (const chunk of ctx.image.chunks)
+        ctx.write(chunk, decodeChunkSync(ctx.image, chunk, ctx.little));
+    const masks = [];
+    for (const m of ctx.masks) {
+        const p = ctx.plan(m.ifd, "mask");
+        if (p.code === 52546) {
+            ctx.assumptions.push("dngImport.semanticMask: mask " + JSON.stringify(m.name) + " is JPEG XL and was not decoded (use importDngRawImage).");
+            continue;
+        }
+        masks.push({ name: m.name, instanceId: m.instanceId, width: p.width, height: p.height, data: maskValues(p, p.chunks.map((c) => decodeChunkSync(p, c, ctx.little))) });
+    }
+    return ctx.finish(masks);
+}
+/**
+ * {@link parseDngRawImage} for every supported compression, JPEG XL included: each JPEG XL strip or tile goes to `jpegXlDecoder` in
+ * turn (one at a time, so only one tile's decoder memory is held), and its PNG is read at the DNG's bit depth (jpeg-xl-tiles.ts).
+ */
+export async function importDngRawImage(input) {
+    const ctx = prepare(input, ["bytes", "maximumPixels", "maximumIfds", "maximumBytes", "size", "jpegXlDecoder"]);
+    const decoder = input.jpegXlDecoder;
+    if (decoder !== undefined && typeof decoder !== "function")
+        fail("jpegXlDecoder must be a function.");
+    for (const chunk of ctx.image.chunks)
+        ctx.write(chunk, await decodeChunk(ctx.image, chunk, ctx.little, decoder));
+    const masks = [];
+    for (const m of ctx.masks) {
+        const p = ctx.plan(m.ifd, "mask");
+        if (p.code === 52546 && !decoder) {
+            ctx.assumptions.push("dngImport.semanticMask: mask " + JSON.stringify(m.name) + " is JPEG XL and no jpegXlDecoder was given.");
+            continue;
+        }
+        const decoded = [];
+        for (const c of p.chunks)
+            decoded.push(await decodeChunk(p, c, ctx.little, decoder));
+        masks.push({ name: m.name, instanceId: m.instanceId, width: p.width, height: p.height, data: maskValues(p, decoded) });
+    }
+    return ctx.finish(masks);
 }
 /** Unpack uncompressed rows: 8-bit bytes, 16-bit words in file byte order, other depths MSB-first with byte-aligned rows. */
 function unpack(data, rowSamples, rows, bits, little) {