fix: codec correctness fixes split out of the pixel-correctness test PR

Second-round fixes found by the pixel-correctness suite (#72), split out
so that PR stays a pure test/CI change. First-round fixes (12-bit decode
path, codecFactory instance cleanup, openjpeg decoder guards and
BufferStream bounds) are already in #71 — this PR carries only what the
test branch itself introduced, each fix together with the tests that
fail without it (verified against wasm rebuilt from the fixes branch's
C++ with CI's emsdk 3.1.74 image):

- openjpeg: J2KEncoder throws on setup/compress failure instead of
  silently returning, with the encoded buffer zeroed (callers previously
  read back a garbage pre-sized allocation as a successful encode);
  frees codec/stream/image on every exit path (repeated encodes grew the
  wasm heap monotonically); sizes the output buffer with headroom so
  clamped writes surface as errors instead of truncation. Pinned by the
  encoder-failure-throw tests, the encode/delete heap-stability test,
  and both dicom-codec J2K round-trips (encode .90 and transcode
  .80->.90), which fail byte-exactness without this rework.
- openjphjs: HTJ2KEncoder rounds bytesPerPixel UP; bitsPerSample/8
  truncated to 1 for 9..15-bit samples, halving the row stride so every
  row after the first was read from the wrong offset (12-bit encodes
  corrupted). Pinned by the 12-bit encoder round-trip.
- libjpeg-turbo-12bit: fail closed on multi-component input — forcing
  JCS_GRAYSCALE on a color 12-bit JPEG silently discards chroma and
  reports componentCount=1. Pinned by the multi-component rejection
  test; also adds the CodSpeed bench and its package script.
- dicom-codec: adaptImageInfo preserves planarConfiguration
  (decode8Planar was unreachable; PlanarConfiguration=1 RLE silently
  produced interleaved output). Pinned by the planar RLE test.
- little-endian/big-endian: 32-bit pixel data decodes to
  Uint32Array/Int32Array per pixelRepresentation with Float32Array only
  as the no-pixelRepresentation fallback (review feedback from
  wayfarer3130, matching cornerstone3D's decodeLittleEndian); 32-bit
  views realign to 4-byte boundaries (the old offset % 2 check threw a
  RangeError at offset % 4 == 2); big-endian gains 1-bit passthrough
  and byte-swapped 32-bit support. Same typing fix applied to
  dicom-codec's littleEndian getPixelData.

Author: sedghi

packages/big-endian/src/index.js

@@ -2,18 +2,29 @@
 function swap16(val) {
   return ((val & 0xff) << 8) | ((val >> 8) & 0xff);
 }
-  
+
+function swap32(val) {
+  return (
+    ((val & 0xff) << 24) |
+    ((val & 0xff00) << 8) |
+    ((val >> 8) & 0xff00) |
+    ((val >> 24) & 0xff)
+  );
+}
+
 /**
  * Decodes the provided pixelData and sets the `pixelData` property
  * of the imageFrame object to the decoded representation.
- * 
- * Set pixelData will be `Uint16Array` if `pixelRepresentation` is 0,
- * otherwise it will be an `Int16Array`
- * 
+ *
+ * 16-bit and 32-bit data are byte-swapped and become unsigned
+ * (`pixelRepresentation` 0) or signed (`pixelRepresentation` 1) integer
+ * arrays. 32-bit data with no `pixelRepresentation` is treated as float
+ * (e.g. FloatPixelData), mirroring the little-endian package.
+ *
  * @param {object} imageFrame
- * @param {number} imageFrame.bitsAllocated - 16 or 8
+ * @param {number} imageFrame.bitsAllocated - 32, 16, 8 or 1
  * @param {number} imageFrame.pixelRepresentation - 0 or 1
- * @param {*} pixelData 
+ * @param {*} pixelData
  */
 function decode(imageFrame, pixelData) {
   if (imageFrame.bitsAllocated === 16) {
@@ -38,8 +49,42 @@ function decode(imageFrame, pixelData) {
     for (let i = 0; i < imageFrame.pixelData.length; i++) {
       imageFrame.pixelData[i] = swap16(imageFrame.pixelData[i]);
     }
-  } else if (imageFrame.bitsAllocated === 8) {
+  } else if (imageFrame.bitsAllocated === 8 || imageFrame.bitsAllocated === 1) {
+    // 1-bit data must already be extracted per frame by the caller:
+    // multi-frame 1-bit pixel data is bit-packed across frame boundaries,
+    // so frame extraction cannot happen at this level
     imageFrame.pixelData = pixelData;
+  } else if (imageFrame.bitsAllocated === 32) {
+    let arrayBuffer = pixelData.buffer;
+
+    let offset = pixelData.byteOffset;
+    const length = pixelData.length;
+    // pixelData is typically a view into the full DICOM P10 buffer, so its
+    // byteOffset is even (DICOM guarantees even lengths) but not necessarily
+    // 4-byte aligned; 32-bit typed-array views require 4-byte alignment,
+    // so copy the bytes to a fresh, aligned buffer when needed
+    if (offset % 4) {
+      arrayBuffer = arrayBuffer.slice(offset);
+      offset = 0;
+    }
+
+    // The swap is a pure byte permutation, so it is done through a
+    // Uint32Array view regardless of how the result is interpreted below
+    const swapView = new Uint32Array(arrayBuffer, offset, length / 4);
+    for (let i = 0; i < swapView.length; i++) {
+      swapView[i] = swap32(swapView[i]);
+    }
+
+    // 32-bit PixelData is integer data (signed per pixelRepresentation);
+    // it is only float when pixelRepresentation is absent (e.g. the
+    // FloatPixelData element), matching cornerstone3D's decodeLittleEndian
+    if (imageFrame.pixelRepresentation === 0) {
+      imageFrame.pixelData = swapView;
+    } else if (imageFrame.pixelRepresentation === 1) {
+      imageFrame.pixelData = new Int32Array(arrayBuffer, offset, length / 4);
+    } else {
+      imageFrame.pixelData = new Float32Array(arrayBuffer, offset, length / 4);
+    }
   }
 
   return imageFrame;

packages/big-endian/test/decode.test.js

@@ -43,6 +43,69 @@ describe("big-endian decode", () => {
     expect(Array.from(imageFrame.pixelData)).toEqual([1, 2])
   })
 
+  it("passes 1-bit pixel data through unchanged", () => {
+    const pixelData = new Uint8Array([0b10101010])
+    const imageFrame = { bitsAllocated: 1 }
+
+    decode(imageFrame, pixelData)
+
+    expect(imageFrame.pixelData).toBe(pixelData)
+  })
+
+  it("byte-swaps 32-bit unsigned pixel data into Uint32Array", () => {
+    const source = [1, 2, 0xdeadbeef]
+    // Build the big-endian byte stream for those values
+    const bigEndianBytes = new Uint8Array(source.length * 4)
+    const view = new DataView(bigEndianBytes.buffer)
+    source.forEach((value, i) => view.setUint32(i * 4, value, false))
+    const imageFrame = { bitsAllocated: 32, pixelRepresentation: 0 }
+
+    decode(imageFrame, bigEndianBytes)
+
+    expect(imageFrame.pixelData).toBeInstanceOf(Uint32Array)
+    expect(Array.from(imageFrame.pixelData)).toEqual([1, 2, 0xdeadbeef])
+  })
+
+  it("byte-swaps 32-bit signed pixel data into Int32Array", () => {
+    const source = [-1, 2, -100000]
+    const bigEndianBytes = new Uint8Array(source.length * 4)
+    const view = new DataView(bigEndianBytes.buffer)
+    source.forEach((value, i) => view.setInt32(i * 4, value, false))
+    const imageFrame = { bitsAllocated: 32, pixelRepresentation: 1 }
+
+    decode(imageFrame, bigEndianBytes)
+
+    expect(imageFrame.pixelData).toBeInstanceOf(Int32Array)
+    expect(Array.from(imageFrame.pixelData)).toEqual([-1, 2, -100000])
+  })
+
+  it("byte-swaps 32-bit pixel data into Float32Array when pixelRepresentation is absent", () => {
+    const source = new Float32Array([1.5, -2.25, 3.75])
+    const bigEndianBytes = new Uint8Array(source.length * 4)
+    const view = new DataView(bigEndianBytes.buffer)
+    source.forEach((value, i) => view.setFloat32(i * 4, value, false))
+    const imageFrame = { bitsAllocated: 32 }
+
+    decode(imageFrame, bigEndianBytes)
+
+    expect(imageFrame.pixelData).toBeInstanceOf(Float32Array)
+    expect(Array.from(imageFrame.pixelData)).toEqual([1.5, -2.25, 3.75])
+  })
+
+  it("realigns 32-bit pixel data when byteOffset is not 4-byte aligned", () => {
+    const source = new Float32Array([1.5, -2.25])
+    const padded = new Uint8Array(2 + source.length * 4)
+    const view = new DataView(padded.buffer)
+    source.forEach((value, i) => view.setFloat32(2 + i * 4, value, false))
+    const pixelData = new Uint8Array(padded.buffer, 2, source.length * 4)
+    const imageFrame = { bitsAllocated: 32 }
+
+    decode(imageFrame, pixelData)
+
+    expect(imageFrame.pixelData).toBeInstanceOf(Float32Array)
+    expect(Array.from(imageFrame.pixelData)).toEqual([1.5, -2.25])
+  })
+
   it("returns the same imageFrame object", () => {
     const imageFrame = { bitsAllocated: 8 }
     const result = decode(imageFrame, new Uint8Array([0]))

packages/dicom-codec/src/codecs/index.js

@@ -90,12 +90,18 @@ function getCodec(transferSyntaxUID) {
  * @returns {ExtendedImageInfo} Adapted imageInfo to all codecs.
  */
 function adaptImageInfo(imageInfo) {
-  const { rows, columns, bitsAllocated, signed, samplesPerPixel, pixelRepresentation } = imageInfo;
+  const { rows, columns, bitsAllocated, signed, samplesPerPixel, pixelRepresentation, planarConfiguration } = imageInfo;
 
   return {
     pixelRepresentation,
     bitsAllocated,
     samplesPerPixel,
+    // Must survive adaptation: rleLossless dispatches between interleaved
+    // (decode8) and plane-sequential (decode8Planar) output on this flag.
+    // It was previously dropped here, which made decode8Planar unreachable
+    // through the public decode() API — PlanarConfiguration=1 datasets
+    // silently produced interleaved output.
+    planarConfiguration,
     rows, // Number with the image rows/height
     columns, // Number with the image columns/width
     width: columns,

packages/dicom-codec/src/codecs/littleEndian.js

@@ -82,13 +82,25 @@ function getPixelData(imageFrame, imageInfo) {
   } else if (bitsAllocated === 8 || bitsAllocated === 1) {
     result = imageFrame;
   } else if (bitsAllocated === 32) {
-    // if pixel data is not aligned on even boundary, shift it
-    if (offset % 2) {
+    // imageFrame is typically a view into the full DICOM P10 buffer, so its
+    // byteOffset is even (DICOM guarantees even lengths) but not necessarily
+    // 4-byte aligned; 32-bit typed-array views require 4-byte alignment,
+    // so copy the bytes to a fresh, aligned buffer when needed
+    if (offset % 4) {
       arrayBuffer = arrayBuffer.slice(offset);
       offset = 0;
     }
 
-    result = new Float32Array(arrayBuffer, offset, length / 4);
+    // 32-bit PixelData is integer data (signed per pixelRepresentation);
+    // it is only float when pixelRepresentation is absent (e.g. the
+    // FloatPixelData element), matching cornerstone3D's decodeLittleEndian
+    if (pixelRepresentation === 0) {
+      result = new Uint32Array(arrayBuffer, offset, length / 4);
+    } else if (pixelRepresentation === 1) {
+      result = new Int32Array(arrayBuffer, offset, length / 4);
+    } else {
+      result = new Float32Array(arrayBuffer, offset, length / 4);
+    }
   }
 
   return result;

packages/dicom-codec/test/color-and-depth.test.js

@@ -61,6 +61,26 @@ describe.skipIf(!ALL_BUILT)("dicom-codec color and bit-depth dispatch", () => {
     expect(frameBytes(result.imageFrame).equals(us1)).toBe(true)
   })
 
+  it("decodes color RLE plane-sequential when planarConfiguration is 1", async () => {
+    const rleBytes = readFileSync(
+      resolve(packagesRoot, "dicom-codec/test/fixtures/rle/US1-color.rle")
+    )
+    const result = await dicomCodec.decode(
+      new Uint8Array(rleBytes),
+      { rows: 480, columns: 640, bitsAllocated: 8, samplesPerPixel: 3, planarConfiguration: 1 },
+      "1.2.840.10008.1.2.5"
+    )
+    const out = frameBytes(result.imageFrame)
+    expect(out.length).toBe(us1.length)
+    // expected layout: RRR...GGG...BBB (de-interleaved planes of US1)
+    const frameSize = 640 * 480
+    const planar = Buffer.alloc(us1.length)
+    for (let s = 0; s < 3; s++) {
+      for (let i = 0; i < frameSize; i++) planar[s * frameSize + i] = us1[i * 3 + s]
+    }
+    expect(out.equals(planar)).toBe(true)
+  })
+
   it("decodes an 8-bit JPEG-LS (.80) through the dispatcher losslessly", async () => {
     const jls = readFileSync(resolve(packagesRoot, "charls/test/fixtures/CT2-gray8.jls"))
     const ct2 = readFileSync(resolve(packagesRoot, "charls/test/fixtures/CT2.RAW"))

packages/dicom-codec/test/transcode-and-pixeldata.test.js

@@ -8,6 +8,7 @@ const packagesRoot = resolve(__dirname, "../..")
 
 const REQUIRED = [
   "charls/dist/charlsjs.js",
+  "openjpeg/dist/openjpegjs.js",
 ]
 const ALL_BUILT = REQUIRED.every((p) => existsSync(resolve(packagesRoot, p)))
 
@@ -19,9 +20,10 @@ it.runIf(process.env.CI)("sibling codec dists are present in CI (transcode suite
   expect(ALL_BUILT, "codec dists missing — artifacts not replayed").toBe(true)
 })
 
-describe.skipIf(!ALL_BUILT)("dicom-codec encode", () => {
+describe.skipIf(!ALL_BUILT)("dicom-codec transcode and encode", () => {
   let dicomCodec
   const ct1Raw = readFileSync(resolve(packagesRoot, "openjpeg/test/fixtures/raw/CT1.RAW"))
+  const ct1Jls = readFileSync(resolve(packagesRoot, "charls/test/fixtures/CT1.JLS"))
   const ctImageInfo = {
     rows: 512,
     columns: 512,
@@ -36,11 +38,32 @@ describe.skipIf(!ALL_BUILT)("dicom-codec encode", () => {
     dicomCodec = mod.default ?? mod
   })
 
+  it("encode() to J2K Lossless (.90) round-trips byte-exact", async () => {
+    const encoded = await dicomCodec.encode(new Uint8Array(ct1Raw), ctImageInfo, "1.2.840.10008.1.2.4.90")
+    expect(encoded.imageFrame.byteLength).toBeGreaterThan(0)
+
+    const decoded = await dicomCodec.decode(encoded.imageFrame, ctImageInfo, "1.2.840.10008.1.2.4.90")
+    expect(frameBytes(decoded.imageFrame).equals(ct1Raw)).toBe(true)
+  })
+
   it("encode() to JPEG-LS Lossless (.80) round-trips byte-exact", async () => {
     const encoded = await dicomCodec.encode(new Uint8Array(ct1Raw), ctImageInfo, "1.2.840.10008.1.2.4.80")
     const decoded = await dicomCodec.decode(encoded.imageFrame, ctImageInfo, "1.2.840.10008.1.2.4.80")
     expect(frameBytes(decoded.imageFrame).equals(ct1Raw)).toBe(true)
   })
+
+  it("transcode() JPEG-LS -> J2K preserves the pixels exactly (both lossless)", async () => {
+    const transcoded = await dicomCodec.transcode(
+      ct1Jls,
+      ctImageInfo,
+      "1.2.840.10008.1.2.4.80",
+      "1.2.840.10008.1.2.4.90"
+    )
+    expect(transcoded.imageFrame.byteLength).toBeGreaterThan(0)
+
+    const decoded = await dicomCodec.decode(transcoded.imageFrame, ctImageInfo, "1.2.840.10008.1.2.4.90")
+    expect(frameBytes(decoded.imageFrame).equals(ct1Raw)).toBe(true)
+  })
 })
 
 describe.skipIf(!ALL_BUILT)("dicom-codec getPixelData typed-array contract", () => {

packages/libjpeg-turbo-12bit/bench/decode.bench.js

@@ -0,0 +1,55 @@
+// Cold vs warm decode benches for the 12-bit codec, mirroring the 8-bit
+// package's bench shape (see libjpeg-turbo-8bit/bench/decode.bench.js for
+// the cold/warm methodology notes). Without this file the 12-bit package
+// was invisible to CodSpeed — a toolchain bump's full bench sweep measured
+// nothing for it.
+import { bench, describe } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "../test/fixtures")
+
+const distPath = resolve(distDir, "libjpegturbo12wasm.js")
+const skip = !existsSync(distPath)
+
+const encoded = !skip
+  ? readFileSync(resolve(fixturesDir, "jpeg/CT-512x512-12bit.jpg"))
+  : null
+
+let codec
+let warmDecoder
+
+async function loadCodec() {
+  const mod = await import(distPath)
+  const factory = mod.default ?? mod
+  // Silence wasm stdout/stderr so vitest's console interception never runs
+  // inside a measured bench body (see openjphjs bench for details).
+  return await factory({ print: () => {}, printErr: () => {} })
+}
+
+function decodeOnce(decoder) {
+  decoder.getEncodedBuffer(encoded.length).set(encoded)
+  decoder.decode()
+  return decoder.getDecodedBuffer()
+}
+
+if (!skip) {
+  codec = await loadCodec()
+  warmDecoder = new codec.JPEGDecoder()
+  for (let i = 0; i < 5; i++) decodeOnce(warmDecoder)
+}
+
+describe.skipIf(skip)("libjpeg-turbo-12bit (wasm)", () => {
+  bench("decode CT-512x512-12bit.jpg (512x512x12bit) — cold", () => {
+    const decoder = new codec.JPEGDecoder()
+    decodeOnce(decoder)
+    decoder.delete()
+  })
+
+  bench("decode CT-512x512-12bit.jpg (512x512x12bit) — warm", () => {
+    decodeOnce(warmDecoder)
+  })
+})

packages/libjpeg-turbo-12bit/package.json

@@ -27,7 +27,8 @@
     "test": "vitest run",
     "test:ci": "yarn run test",
     "test:watch": "vitest",
-    "prepublishOnly": "yarn run build"
+    "prepublishOnly": "yarn run build",
+    "bench": "vitest bench --run"
   },
   "author": "",
   "license": "ISC"

packages/libjpeg-turbo-12bit/src/JPEGDecoder.hpp

@@ -6,6 +6,7 @@
 #include <cstdint>
 #include <memory>
 #include <stdexcept>
+#include <string>
 #include <vector>
 // #include "config.h"
 #include "jpeglib.h"
@@ -125,6 +126,16 @@ class JPEGDecoder {
     jpeg_mem_src(&cinfo, encoded_.data(), encoded_.size());
     // Read file header, set default decompression parameters
     jpeg_read_header(&cinfo, TRUE);
+    // Fail closed on multi-component images. This codec only supports
+    // single-component (grayscale) 12-bit JPEGs; forcing JCS_GRAYSCALE on a
+    // color image would make libjpeg silently discard the chroma channels
+    // and report componentCount=1, corrupting color data without any error.
+    if (cinfo.num_components != 1) {
+      jpeg_destroy_decompress(&cinfo);
+      throw std::runtime_error(
+        "Unsupported 12-bit JPEG: expected 1 component (grayscale), got " +
+        std::to_string(cinfo.num_components));
+    }
     // Decode as single-component grayscale. This is a 12-bit-per-sample
     // codec: each output value is a 16-bit-wide JSAMPLE (holding 0..4095),
     // not an 8-bit RGBA quad. Previously this forced a 4-samples-per-pixel