@woosh/meep-engine 3.9.0 → 3.11.0

package/src/engine/asset/loaders/image/jpeg/JpegFrame.d.ts

@@ -29,10 +29,12 @@ export class JpegFrame {
     mcusPerLine: number;
     mcusPerColumn: number;
     /**
-     *
-     * @type {Object<JpegFrameComponent>}
+     * Frame components by the id the `SOF` marker gave them. A `Map` rather than an object: the
+     * ids are numbers, and an object would coerce them to strings on the way in and back on the
+     * way out.
+     * @type {Map<number, JpegFrameComponent>}
      */
-    components: any;
+    components: Map<number, JpegFrameComponent>;
     /**
      *
      * @type {number[]}

package/src/engine/asset/loaders/image/jpeg/JpegFrame.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JpegFrame.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegFrame.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,UAFU,OAAO,CAEA;IACjB;;;OAGG;IACH,aAFU,OAAO,CAEG;IACpB;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB,aAAS;IACT,aAAS;IAET,oBAAgB;IAChB,sBAAkB;IAElB;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEG;CACxB"}
+{"version":3,"file":"JpegFrame.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegFrame.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,UAFU,OAAO,CAEA;IACjB;;;OAGG;IACH,aAFU,OAAO,CAEG;IACpB;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB,aAAS;IACT,aAAS;IAET,oBAAgB;IAChB,sBAAkB;IAElB;;;;;OAKG;IACH,YAFU,IAAI,MAAM,qBAAqB,CAElB;IAEvB;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEG;CACxB"}

package/src/engine/asset/loaders/image/jpeg/JpegFrame.js

@@ -32,10 +32,12 @@ export class JpegFrame {
     mcusPerColumn = 0;
 
     /**
-     *
-     * @type {Object<JpegFrameComponent>}
+     * Frame components by the id the `SOF` marker gave them. A `Map` rather than an object: the
+     * ids are numbers, and an object would coerce them to strings on the way in and back on the
+     * way out.
+     * @type {Map<number, JpegFrameComponent>}
      */
-    components = {};
+    components = new Map();
 
     /**
      *

package/src/engine/asset/loaders/image/jpeg/JpegFrameComponent.d.ts

@@ -20,7 +20,8 @@ export class JpegFrameComponent {
     blocksPerLine: number;
     blocksPerColumn: number;
     /**
-     *
+     * Index of this component's quantization table within the `DQT` tables of the file. Set to
+     * `-1` once {@link quantizationTable} has been resolved from it.
      * @type {number}
      */
     quantizationIdx: number;

package/src/engine/asset/loaders/image/jpeg/JpegFrameComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JpegFrameComponent.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegFrameComponent.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,GAFU,MAAM,CAEX;IACL;;;OAGG;IACH,GAFU,MAAM,CAEX;IAEL;;OAEG;IACH,MAFU,MAAM,CAER;IAER;;OAEG;IACH,QAFU,UAAU,EAAE,EAAE,CAElB;IAEN,sBAAiB;IACjB,wBAAmB;IAEnB;;;OAGG;IACH,iBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,mBAFU,UAAU,CAEF;IAElB;;;OAGG;IACH,gBAFU,EAAE,CAEE;IAEd;;;OAGG;IACH,gBAFU,EAAE,CAEE;CACjB"}
+{"version":3,"file":"JpegFrameComponent.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegFrameComponent.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,GAFU,MAAM,CAEX;IACL;;;OAGG;IACH,GAFU,MAAM,CAEX;IAEL;;OAEG;IACH,MAFU,MAAM,CAER;IAER;;OAEG;IACH,QAFU,UAAU,EAAE,EAAE,CAElB;IAEN,sBAAiB;IACjB,wBAAmB;IAEnB;;;;OAIG;IACH,iBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,mBAFU,UAAU,CAEF;IAElB;;;OAGG;IACH,gBAFU,EAAE,CAEE;IAEd;;;OAGG;IACH,gBAFU,EAAE,CAEE;CACjB"}

package/src/engine/asset/loaders/image/jpeg/JpegFrameComponent.js

@@ -24,7 +24,8 @@ export class JpegFrameComponent {
     blocksPerColumn = 0
 
     /**
-     *
+     * Index of this component's quantization table within the `DQT` tables of the file. Set to
+     * `-1` once {@link quantizationTable} has been resolved from it.
      * @type {number}
      */
     quantizationIdx = 0

package/src/engine/asset/loaders/image/jpeg/JpegImage.d.ts

@@ -40,6 +40,23 @@ export class JpegImage {
         scaleY: number;
     }[];
     /**
+     * Whether the three or four component cases should be read as YCbCr rather than as the channels
+     * they nominally are.
+     *
+     * Three components default to transformed, four to not; an Adobe marker overrides either, and
+     * an explicit option overrides that.
+     *
+     * @param {boolean} fallback what to assume when nothing says
+     * @returns {boolean}
+     * @private
+     */
+    private __color_transform;
+    /**
+     * Interleave the components at the requested size.
+     *
+     * Sampling every component up to full width happens once per row, in
+     * {@link jpeg_component_row}; what is left here is the arithmetic that differs between
+     * component counts, which is the only thing that ever did.
      *
      * @param {number} width
      * @param {number} height

package/src/engine/asset/loaders/image/jpeg/JpegImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JpegImage.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegImage.js"],"names":[],"mappings":"AA0CA;IAEI;;;OAGG;IACH,YAFW,UAAU,QA8WpB;IAxRG;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEA;IA0DE,uBAAqD;IAuMzE,cAAiC;IACjC,eAA6B;IAC7B;;;;;;;;;;;MAAgB;IAChB;;;;;MAAkB;IAElB;;;OAGG;IACH,YAFU;QAAC,KAAK,EAAC,UAAU,EAAE,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAA;KAAC,EAAE,CAE1C;IAYxB;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACL,UAAU,CAuIrB;IAED;;;;OAIG;IACH;cAHiB,UAAU;eAAQ,MAAM;gBAAS,MAAM;sBAC7C,OAAO,QA+DjB;CACJ"}
+{"version":3,"file":"JpegImage.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegImage.js"],"names":[],"mappings":"AA6IA;IAEI;;;OAGG;IACH,YAFW,UAAU,QAyWpB;IAvRG;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEA;IA0DE,uBAAqD;IAsMzE,cAAiC;IACjC,eAA6B;IAC7B;;;;;;;;;;;MAAgB;IAChB;;;;;MAAkB;IAElB;;;OAGG;IACH,YAFU;QAAC,KAAK,EAAC,UAAU,EAAE,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAA;KAAC,EAAE,CAE1C;IAYxB;;;;;;;;;;OAUG;IACH,0BAUC;IAED;;;;;;;;;;OAUG;IACH,eAJW,MAAM,UACN,MAAM,GACL,UAAU,CAqDrB;IAED;;;;OAIG;IACH;cAHiB,UAAU;eAAQ,MAAM;gBAAS,MAAM;sBAC7C,OAAO,QA+DjB;CACJ"}

package/src/engine/asset/loaders/image/jpeg/JpegImage.js

@@ -1,3 +1,5 @@
+import { clamp } from "../../../../../core/math/clamp.js";
+import { jpeg_component_row } from "./jpeg_component_row.js";
 import { buildComponentData } from "./buildComponentData.js";
 import { buildHuffmanTable } from "./buildHuffmanTable.js";
 import { dctZigZag, decodeScan } from "./decodeScan.js";
@@ -32,12 +34,109 @@ import { JpegFrameComponent } from "./JpegFrameComponent.js";
 //   (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf)
 
 /**
+ * Value {@link JpegFrameComponent#quantizationIdx} takes once the index has been resolved into
+ * `quantizationTable`. The index is a position in a table list that does not outlive `parse`, so
+ * keeping it afterwards would be keeping a dangling reference.
+ * @type {number}
+ */
+const QUANTIZATION_INDEX_RESOLVED = -1;
+
+/**
+ * Constrain a sample to the 8-bit range. Does not round: every caller writes into a `Uint8Array`,
+ * which truncates, and rounding here would change the decoded values.
  *
  * @param {number} a
  * @return {number}
  */
-function clampTo8bit(a) {
-    return a < 0 ? 0 : a > 255 ? 255 : a;
+function clamp_to_8bit(a) {
+    return clamp(a, 0, 255);
+}
+
+/**
+ * Write one row of three-component data as RGB.
+ *
+ * @param {Uint8Array[]} rows one full-width row per component
+ * @param {number} width
+ * @param {boolean} colorTransform whether the components are YCbCr rather than RGB
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @returns {number} the offset after the row
+ */
+function write_rgb_row(rows, width, colorTransform, data, offset) {
+    const row0 = rows[0];
+    const row1 = rows[1];
+    const row2 = rows[2];
+
+    if (!colorTransform) {
+        for (let x = 0; x < width; x++) {
+            data[offset++] = row0[x];
+            data[offset++] = row1[x];
+            data[offset++] = row2[x];
+        }
+
+        return offset;
+    }
+
+    for (let x = 0; x < width; x++) {
+        const Y = row0[x];
+        const Cb = row1[x];
+        const Cr = row2[x];
+
+        data[offset++] = clamp_to_8bit(Y + 1.402 * (Cr - 128));
+        data[offset++] = clamp_to_8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
+        data[offset++] = clamp_to_8bit(Y + 1.772 * (Cb - 128));
+    }
+
+    return offset;
+}
+
+/**
+ * Write one row of four-component data as CMYK.
+ *
+ * The channels are stored inverted, as Adobe writes them, which is why each one is subtracted from
+ * 255 on the way out whether or not it went through the colour transform.
+ *
+ * @param {Uint8Array[]} rows one full-width row per component
+ * @param {number} width
+ * @param {boolean} colorTransform whether the first three components are YCbCr rather than CMY
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @returns {number} the offset after the row
+ */
+function write_cmyk_row(rows, width, colorTransform, data, offset) {
+    const row0 = rows[0];
+    const row1 = rows[1];
+    const row2 = rows[2];
+    const row3 = rows[3];
+
+    for (let x = 0; x < width; x++) {
+        const K = row3[x];
+
+        let C;
+        let M;
+        let Ye;
+
+        if (!colorTransform) {
+            C = row0[x];
+            M = row1[x];
+            Ye = row2[x];
+        } else {
+            const Y = row0[x];
+            const Cb = row1[x];
+            const Cr = row2[x];
+
+            C = 255 - clamp_to_8bit(Y + 1.402 * (Cr - 128));
+            M = 255 - clamp_to_8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
+            Ye = 255 - clamp_to_8bit(Y + 1.772 * (Cb - 128));
+        }
+
+        data[offset++] = 255 - C;
+        data[offset++] = 255 - M;
+        data[offset++] = 255 - Ye;
+        data[offset++] = 255 - K;
+    }
+
+    return offset;
 }
 
 export class JpegImage {
@@ -70,38 +169,34 @@ export class JpegImage {
             // According to the JPEG standard, the sampling factor must be between 1 and 4
             // See https://github.com/libjpeg-turbo/libjpeg-turbo/blob/9abeff46d87bd201a952e276f3e4339556a403a3/libjpeg.txt#L1138-L1146
             let maxH = 1, maxV = 1;
-            let component, componentId;
-            for (componentId in frame.components) {
-                if (frame.components.hasOwnProperty(componentId)) {
-                    component = frame.components[componentId];
-                    if (maxH < component.h) maxH = component.h;
-                    if (maxV < component.v) maxV = component.v;
-                }
+
+            for (const component of frame.components.values()) {
+                if (maxH < component.h) maxH = component.h;
+                if (maxV < component.v) maxV = component.v;
             }
+
             const mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
             const mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
-            for (componentId in frame.components) {
-                if (frame.components.hasOwnProperty(componentId)) {
-                    component = frame.components[componentId];
-                    const blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
-                    const blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
-                    const blocksPerLineForMcu = mcusPerLine * component.h;
-                    const blocksPerColumnForMcu = mcusPerColumn * component.v;
-                    const blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
-                    const blocks = [];
-
-                    // Each block is a Int32Array of length 64 (4 x 64 = 256 bytes)
-
-                    for (let i = 0; i < blocksPerColumnForMcu; i++) {
-                        const row = [];
-                        for (let j = 0; j < blocksPerLineForMcu; j++)
-                            row.push(new Int32Array(64));
-                        blocks.push(row);
-                    }
-                    component.blocksPerLine = blocksPerLine;
-                    component.blocksPerColumn = blocksPerColumn;
-                    component.blocks = blocks;
+
+            for (const component of frame.components.values()) {
+                const blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
+                const blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
+                const blocksPerLineForMcu = mcusPerLine * component.h;
+                const blocksPerColumnForMcu = mcusPerColumn * component.v;
+                const blocks = [];
+
+                // Each block is a Int32Array of length 64 (4 x 64 = 256 bytes)
+
+                for (let i = 0; i < blocksPerColumnForMcu; i++) {
+                    const row = [];
+                    for (let j = 0; j < blocksPerLineForMcu; j++)
+                        row.push(new Int32Array(64));
+                    blocks.push(row);
                 }
+
+                component.blocksPerLine = blocksPerLine;
+                component.blocksPerColumn = blocksPerColumn;
+                component.blocks = blocks;
             }
             frame.maxH = maxH;
             frame.maxV = maxV;
@@ -249,7 +344,7 @@ export class JpegImage {
                     frame.precision = data[offset++];
                     frame.scanLines = readUint16();
                     frame.samplesPerLine = readUint16();
-                    frame.components = {};
+                    frame.components = new Map();
                     frame.componentsOrder = [];
 
                     let componentsCount = data[offset++], componentId;
@@ -270,7 +365,7 @@ export class JpegImage {
                         component.v = v;
                         component.quantizationIdx = qId;
 
-                        frame.components[componentId] = component;
+                        frame.components.set(componentId, component);
                         offset += 3;
                     }
                     prepareComponents(frame);
@@ -326,7 +421,7 @@ export class JpegImage {
                     const components = [];
                     let component;
                     for (i = 0; i < selectorsCount; i++) {
-                        component = frame.components[data[offset++]];
+                        component = frame.components.get(data[offset++]);
                         const tableSpec = data[offset++];
                         component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
                         component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
@@ -382,12 +477,11 @@ export class JpegImage {
         if (frames.length !== 1)
             throw new Error("only single frame JPEGs supported");
 
-        // set each frame's components quantization table
+        // resolve each frame's components quantization table
         for (let i = 0; i < frames.length; i++) {
-            const cp = frames[i].components;
-            for (let j in cp) {
-                cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx];
-                delete cp[j].quantizationIdx;
+            for (const component of frames[i].components.values()) {
+                component.quantizationTable = quantizationTables[component.quantizationIdx];
+                component.quantizationIdx = QUANTIZATION_INDEX_RESOLVED;
             }
         }
 
@@ -403,7 +497,7 @@ export class JpegImage {
         this.components = [];
 
         for (let i = 0; i < frame.componentsOrder.length; i++) {
-            const component = frame.components[frame.componentsOrder[i]];
+            const component = frame.components.get(frame.componentsOrder[i]);
             this.components.push({
                 lines: buildComponentData(component),
                 scaleX: component.h / frame.maxH,
@@ -413,6 +507,34 @@ export class JpegImage {
     }
 
     /**
+     * Whether the three or four component cases should be read as YCbCr rather than as the channels
+     * they nominally are.
+     *
+     * Three components default to transformed, four to not; an Adobe marker overrides either, and
+     * an explicit option overrides that.
+     *
+     * @param {boolean} fallback what to assume when nothing says
+     * @returns {boolean}
+     * @private
+     */
+    __color_transform(fallback) {
+        if (this.adobe && this.adobe.transformCode) {
+            return true;
+        }
+
+        if (typeof this.opts.colorTransform !== 'undefined') {
+            return !!this.opts.colorTransform;
+        }
+
+        return fallback;
+    }
+
+    /**
+     * Interleave the components at the requested size.
+     *
+     * Sampling every component up to full width happens once per row, in
+     * {@link jpeg_component_row}; what is left here is the arithmetic that differs between
+     * component counts, which is the only thing that ever did.
      *
      * @param {number} width
      * @param {number} height
@@ -422,134 +544,52 @@ export class JpegImage {
         const scaleX = this.width / width;
         const scaleY = this.height / height;
 
-        let component1, component2, component3, component4;
-        let component1Line, component2Line, component3Line, component4Line;
-        let x, y;
-        let offset = 0;
-        let Y, Cb, Cr, K, C, M, Ye, R, G, B;
-        let colorTransform;
-        const dataLength = width * height * this.components.length;
+        const components = this.components;
+        const component_count = components.length;
 
-        const data = new Uint8Array(dataLength);
-        switch (this.components.length) {
-            case 1:
-                component1 = this.components[0];
-                const lines = component1.lines;
-                for (y = 0; y < height; y++) {
-                    component1Line = lines[0 | (y * component1.scaleY * scaleY)];
-                    for (x = 0; x < width; x++) {
-                        Y = component1Line[0 | (x * component1.scaleX * scaleX)];
+        if (component_count < 1 || component_count > 4) {
+            throw new Error('Unsupported color mode');
+        }
 
-                        data[offset++] = Y;
-                    }
-                }
-                break;
-            case 2:
-                // PDF might compress two component data in custom colorspace
-                component1 = this.components[0];
-                component2 = this.components[1];
-                for (y = 0; y < height; y++) {
-                    component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)];
-                    component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)];
-                    for (x = 0; x < width; x++) {
-                        Y = component1Line[0 | (x * component1.scaleX * scaleX)];
-                        data[offset++] = Y;
-                        Y = component2Line[0 | (x * component2.scaleX * scaleX)];
-                        data[offset++] = Y;
-                    }
-                }
-                break;
-            case 3:
-                // The default transform for three components is true
-                colorTransform = true;
-                // The adobe transform marker overrides any previous setting
-                if (this.adobe && this.adobe.transformCode)
-                    colorTransform = true;
-                else if (typeof this.opts.colorTransform !== 'undefined') {
-                    colorTransform = !!this.opts.colorTransform;
-                }
+        if (component_count === 4 && !this.adobe) {
+            throw new Error('Unsupported color mode (4 components)');
+        }
 
-                component1 = this.components[0];
-                component2 = this.components[1];
-                component3 = this.components[2];
-                for (y = 0; y < height; y++) {
+        const data = new Uint8Array(width * height * component_count);
 
-                    component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)];
-                    component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)];
-                    component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)];
-                    for (x = 0; x < width; x++) {
+        // one full-width row per component, reused down the image
+        const rows = [];
 
-                        if (!colorTransform) {
-                            R = component1Line[0 | (x * component1.scaleX * scaleX)];
-                            G = component2Line[0 | (x * component2.scaleX * scaleX)];
-                            B = component3Line[0 | (x * component3.scaleX * scaleX)];
-                        } else {
-                            Y = component1Line[0 | (x * component1.scaleX * scaleX)];
-                            Cb = component2Line[0 | (x * component2.scaleX * scaleX)];
-                            Cr = component3Line[0 | (x * component3.scaleX * scaleX)];
+        for (let i = 0; i < component_count; i++) {
+            rows.push(new Uint8Array(width));
+        }
 
-                            R = clampTo8bit(Y + 1.402 * (Cr - 128));
-                            G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
-                            B = clampTo8bit(Y + 1.772 * (Cb - 128));
-                        }
+        // three components are YCbCr unless told otherwise, four are CMYK unless told otherwise
+        const colorTransform = component_count >= 3 && this.__color_transform(component_count === 3);
 
-                        data[offset++] = R;
-                        data[offset++] = G;
-                        data[offset++] = B;
-                    }
-                }
-                break;
-            case 4:
-                if (!this.adobe)
-                    throw new Error('Unsupported color mode (4 components)');
-                // The default transform for four components is false
-                colorTransform = false;
-                // The adobe transform marker overrides any previous setting
-                if (this.adobe && this.adobe.transformCode)
-                    colorTransform = true;
-                else if (typeof this.opts.colorTransform !== 'undefined')
-                    colorTransform = !!this.opts.colorTransform;
-
-                component1 = this.components[0];
-                component2 = this.components[1];
-                component3 = this.components[2];
-                component4 = this.components[3];
-                for (y = 0; y < height; y++) {
-                    const _y = y * scaleY;
+        let offset = 0;
 
-                    component1Line = component1.lines[0 | (_y * component1.scaleY)];
-                    component2Line = component2.lines[0 | (_y * component2.scaleY)];
-                    component3Line = component3.lines[0 | (_y * component3.scaleY)];
-                    component4Line = component4.lines[0 | (_y * component4.scaleY)];
-                    for (x = 0; x < width; x++) {
-                        const _x = x * scaleX;
+        for (let y = 0; y < height; y++) {
 
-                        if (!colorTransform) {
-                            C = component1Line[0 | (_x * component1.scaleX)];
-                            M = component2Line[0 | (_x * component2.scaleX)];
-                            Ye = component3Line[0 | (_x * component3.scaleX)];
-                            K = component4Line[0 | (_x * component4.scaleX)];
-                        } else {
-                            Y = component1Line[0 | (_x * component1.scaleX)];
-                            Cb = component2Line[0 | (_x * component2.scaleX)];
-                            Cr = component3Line[0 | (_x * component3.scaleX)];
-                            K = component4Line[0 | (_x * component4.scaleX)];
-
-                            C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128));
-                            M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
-                            Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128));
-                        }
+            for (let i = 0; i < component_count; i++) {
+                jpeg_component_row(components[i], y, scaleX, scaleY, width, rows[i]);
+            }
 
-                        data[offset++] = 255 - C;
-                        data[offset++] = 255 - M;
-                        data[offset++] = 255 - Ye;
-                        data[offset++] = 255 - K;
+            if (component_count === 3) {
+                offset = write_rgb_row(rows, width, colorTransform, data, offset);
+            } else if (component_count === 4) {
+                offset = write_cmyk_row(rows, width, colorTransform, data, offset);
+            } else {
+                // one or two components, carried through as they are: greyscale, or the pair a PDF
+                // may have compressed in a colour space of its own
+                for (let x = 0; x < width; x++) {
+                    for (let i = 0; i < component_count; i++) {
+                        data[offset++] = rows[i][x];
                     }
                 }
-                break;
-            default:
-                throw new Error('Unsupported color mode');
+            }
         }
+
         return data;
     }
 
@@ -603,9 +643,9 @@ export class JpegImage {
                         Y = data[i++];
                         K = data[i++];
 
-                        R = 255 - clampTo8bit(C * (1 - K / 255) + K);
-                        G = 255 - clampTo8bit(M * (1 - K / 255) + K);
-                        B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
+                        R = 255 - clamp_to_8bit(C * (1 - K / 255) + K);
+                        G = 255 - clamp_to_8bit(M * (1 - K / 255) + K);
+                        B = 255 - clamp_to_8bit(Y * (1 - K / 255) + K);
 
                         imageDataArray[j++] = R;
                         imageDataArray[j++] = G;

package/src/engine/asset/loaders/image/jpeg/idct8x8_float.d.ts

@@ -3,7 +3,6 @@
  * @param {Int32Array} qt quantization table
  * @param {Int32Array} zz zigzag-ordered DCT coefficients
  * @param {Uint8Array|Uint8ClampedArray} output The output array for the 8x8 block.
- * @see idct8x8_fixed
  */
 export function idct8x8_float(qt: Int32Array, zz: Int32Array, output: Uint8Array | Uint8ClampedArray): void;
 //# sourceMappingURL=idct8x8_float.d.ts.map

package/src/engine/asset/loaders/image/jpeg/idct8x8_float.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"idct8x8_float.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/idct8x8_float.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,kCALW,UAAU,MACV,UAAU,UACV,UAAU,GAAC,iBAAiB,QAuBtC"}
+{"version":3,"file":"idct8x8_float.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/idct8x8_float.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,kCAJW,UAAU,MACV,UAAU,UACV,UAAU,GAAC,iBAAiB,QAsBtC"}

package/src/engine/asset/loaders/image/jpeg/idct8x8_float.js

@@ -7,7 +7,6 @@ const p = new Float64Array(64);
  * @param {Int32Array} qt quantization table
  * @param {Int32Array} zz zigzag-ordered DCT coefficients
  * @param {Uint8Array|Uint8ClampedArray} output The output array for the 8x8 block.
- * @see idct8x8_fixed
  */
 export function idct8x8_float(
     qt,

package/src/engine/asset/loaders/image/jpeg/jpeg_component_row.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Sample one full-width row of a decoded component.
+ *
+ * A JPEG component may be coded at a fraction of the image's resolution — that is what the `h` and
+ * `v` sampling factors mean — and the caller may want the picture at some size other than its coded
+ * one. Both are the same operation: step through the component's own grid at a rate that maps the
+ * output row onto it, taking the nearest sample.
+ *
+ * Nearest, not interpolated. That is what the four component cases of `getData` did, twenty-seven
+ * times over, and changing it would change every decoded picture. `color/upsample_chroma_row.js` in
+ * the AVIF tree does the interpolated version and would be the obvious thing to share, but it
+ * expresses subsampling as a shift — it can say "half" and not "a third" — and JPEG's sampling
+ * factors run from one to four. Generalising it to rational scaling for this caller's sake would
+ * cost the codec that owns it something for nothing.
+ *
+ * @param {{lines: Uint8Array[], scaleX: number, scaleY: number}} component
+ * @param {number} y output row
+ * @param {number} scale_x output-to-image horizontal ratio
+ * @param {number} scale_y output-to-image vertical ratio
+ * @param {number} width output width
+ * @param {Uint8Array} destination at least `width` long
+ */
+export function jpeg_component_row(component: {
+    lines: Uint8Array[];
+    scaleX: number;
+    scaleY: number;
+}, y: number, scale_x: number, scale_y: number, width: number, destination: Uint8Array): void;
+//# sourceMappingURL=jpeg_component_row.d.ts.map

package/src/engine/asset/loaders/image/jpeg/jpeg_component_row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jpeg_component_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/jpeg_component_row.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CAPW;IAAC,KAAK,EAAE,UAAU,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,KACrD,MAAM,WACN,MAAM,WACN,MAAM,SACN,MAAM,eACN,UAAU,QAUpB"}

package/src/engine/asset/loaders/image/jpeg/jpeg_component_row.js

@@ -0,0 +1,31 @@
+/**
+ * Sample one full-width row of a decoded component.
+ *
+ * A JPEG component may be coded at a fraction of the image's resolution — that is what the `h` and
+ * `v` sampling factors mean — and the caller may want the picture at some size other than its coded
+ * one. Both are the same operation: step through the component's own grid at a rate that maps the
+ * output row onto it, taking the nearest sample.
+ *
+ * Nearest, not interpolated. That is what the four component cases of `getData` did, twenty-seven
+ * times over, and changing it would change every decoded picture. `color/upsample_chroma_row.js` in
+ * the AVIF tree does the interpolated version and would be the obvious thing to share, but it
+ * expresses subsampling as a shift — it can say "half" and not "a third" — and JPEG's sampling
+ * factors run from one to four. Generalising it to rational scaling for this caller's sake would
+ * cost the codec that owns it something for nothing.
+ *
+ * @param {{lines: Uint8Array[], scaleX: number, scaleY: number}} component
+ * @param {number} y output row
+ * @param {number} scale_x output-to-image horizontal ratio
+ * @param {number} scale_y output-to-image vertical ratio
+ * @param {number} width output width
+ * @param {Uint8Array} destination at least `width` long
+ */
+export function jpeg_component_row(component, y, scale_x, scale_y, width, destination) {
+    const line = component.lines[0 | (y * component.scaleY * scale_y)];
+
+    const component_scale_x = component.scaleX;
+
+    for (let x = 0; x < width; x++) {
+        destination[x] = line[0 | (x * component_scale_x * scale_x)];
+    }
+}