fix: consolidated codec correctness fixes (supersedes #71)

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/codecFactory.js

@@ -203,38 +203,42 @@ function getImageFrame(typedArray) {
 function encode(context, codecConfig, imageFrame, imageInfo, options = {}) {
   const { iterations = 1 } = options;
   const encoderInstance = new codecConfig.Encoder();
-  const decodedTypedArray = encoderInstance.getDecodedBuffer(imageInfo);
-  decodedTypedArray.set(imageFrame);
+  try {
+    const decodedTypedArray = encoderInstance.getDecodedBuffer(imageInfo);
+    decodedTypedArray.set(imageFrame);
 
-  const { beforeEncode = () => {} } = options;
+    const { beforeEncode = () => {} } = options;
 
-  beforeEncode(encoderInstance, codecConfig);
+    beforeEncode(encoderInstance, codecConfig);
 
-  context.timer.init("To encode length: " + imageFrame.length);
-  for (let i = 0; i < iterations; i++) {
-    encoderInstance.encode();
-  }
+    context.timer.init("To encode length: " + imageFrame.length);
+    for (let i = 0; i < iterations; i++) {
+      encoderInstance.encode();
+    }
 
-  context.timer.end();
+    context.timer.end();
 
-  const encodedTypedArray = encoderInstance.getEncodedBuffer();
-  context.logger.log("Encoded length:" + encodedTypedArray.length);
-  context.logger.log(
-    "Encoded is a Typed array of: " + encodedTypedArray.constructor.name
-  );
+    const encodedTypedArray = encoderInstance.getEncodedBuffer();
+    context.logger.log("Encoded length:" + encodedTypedArray.length);
+    context.logger.log(
+      "Encoded is a Typed array of: " + encodedTypedArray.constructor.name
+    );
 
-  // cleanup allocated memory
-  encoderInstance.delete();
+    const imageFrameOut = getImageFrame(encodedTypedArray);
 
-  const processInfo = {
-    duration: context.timer.getDuration(),
-  };
+    const processInfo = {
+      duration: context.timer.getDuration(),
+    };
 
-  return {
-    imageFrame: getImageFrame(encodedTypedArray),
-    imageInfo: getTargetImageInfo(imageInfo, imageInfo),
-    processInfo,
-  };
+    return {
+      imageFrame: imageFrameOut,
+      imageInfo: getTargetImageInfo(imageInfo, imageInfo),
+      processInfo,
+    };
+  } finally {
+    // cleanup allocated memory
+    encoderInstance.delete();
+  }
 }
 
 /**
@@ -255,40 +259,44 @@ function decode(context, codecConfig, imageFrame, imageInfo) {
   }
   const decoderInstance = new codecConfig.Decoder();
 
-  const { length } = imageFrame;
-  // get pointer to the source/encoded bit stream buffer in WASM memory
-  // that can hold the encoded bitstream
-  const encodedTypedArray = decoderInstance.getEncodedBuffer(length);
-
-  // copy the encoded bitstream into WASM memory buffer
-  encodedTypedArray.set(imageFrame);
-  context.timer.init("To decode length: " + length);
-  // decode it
-  decoderInstance.decode();
-  context.timer.end();
+  try {
+    const { length } = imageFrame;
+    // get pointer to the source/encoded bit stream buffer in WASM memory
+    // that can hold the encoded bitstream
+    const encodedTypedArray = decoderInstance.getEncodedBuffer(length);
+
+    // copy the encoded bitstream into WASM memory buffer
+    encodedTypedArray.set(imageFrame);
+    context.timer.init("To decode length: " + length);
+    // decode it
+    decoderInstance.decode();
+    context.timer.end();
+
+    const decodedTypedArray = decoderInstance.getDecodedBuffer();
+
+    context.logger.log("Decoded length:" + decodedTypedArray.length);
+    context.logger.log(
+      "Decoded is a Typed array of: " + decodedTypedArray.constructor.name
+    );
 
-  const decodedTypedArray = decoderInstance.getDecodedBuffer();
+    // get information about the decoded image
+    const decodedImageInfo = decoderInstance.getFrameInfo();
 
-  context.logger.log("Decoded length:" + decodedTypedArray.length);
-  context.logger.log(
-    "Decoded is a Typed array of: " + decodedTypedArray.constructor.name
-  );
+    const imageFrameOut = getImageFrame(decodedTypedArray);
 
-  // get information about the decoded image
-  const decodedImageInfo = decoderInstance.getFrameInfo();
+    const processInfo = {
+      duration: context.timer.getDuration(),
+    };
 
-  // cleanup allocated memory
-  decoderInstance.delete();
-
-  const processInfo = {
-    duration: context.timer.getDuration(),
-  };
-
-  return {
-    imageFrame: getImageFrame(decodedTypedArray),
-    imageInfo: getTargetImageInfo(imageInfo, decodedImageInfo),
-    processInfo,
-  };
+    return {
+      imageFrame: imageFrameOut,
+      imageInfo: getTargetImageInfo(imageInfo, decodedImageInfo),
+      processInfo,
+    };
+  } finally {
+    // cleanup allocated memory
+    decoderInstance.delete();
+  }
 }
 
 exports.runProcess = runProcess;

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/libjpegTurbo12bit.js

@@ -1,35 +1,53 @@
+const codecModule = require("@cornerstonejs/codec-libjpeg-turbo-12bit");
+const codecWasmModule = require("@cornerstonejs/codec-libjpeg-turbo-12bit/wasmjs");
+const codecFactory = require("./codecFactory");
+
 /**
  * @type {CodecWrapper}
  */
 const codecWrapper = {
-  // assign it and prevent initialization
   codec: undefined,
   Decoder: undefined,
   Encoder: undefined,
-  decoderName: "codec libjpeg turbo 12bit",
-  encoderName: "codec libjpeg turbo 12bit",
+  encoderName: "JPEGEncoder",
+  decoderName: "JPEGDecoder",
 };
 
+/**
+ * Decode imageFrame using libjpegTurbo 12bit decoder.
+ *
+ * @param {TypedArray} imageFrame to decode.
+ * @param {ExtendedImageInfo} imageInfo image info options.
+ * @returns Object containing decoded image frame and imageInfo (current) data.
+ */
 async function decode(imageFrame, imageInfo) {
-  throw Error("Decoder not found for codec:" + codecWrapper.encoderName);
+  return codecFactory.runProcess(
+    codecWrapper,
+    codecModule,
+    codecWasmModule,
+    codecWrapper.decoderName,
+    (context) => {
+      return codecFactory.decode(context, codecWrapper, imageFrame, imageInfo);
+    }
+  );
 }
 
 /**
- * <<Not available yet>> Encode imageFrame to libjpegTurbo 12bits format.
+ * <<Not available>> The libjpeg-turbo 12bit build does not expose an
+ * encoder (see src/jslib.cpp — the JPEGEncoder bindings are disabled), so
+ * encoding is not supported for this codec.
  *
  * @param {TypedArray} imageFrame to encode.
  * @param {ExtendedImageInfo} imageInfo image info options.
  * @param {Object} options encode option.
  * @returns Object containing encoded image frame and imageInfo (current) data
  */
 async function encode(imageFrame, imageInfo, options = {}) {
-  throw Error("Encoder not found for codec:" + codecWrapper.encoderName);
+  throw Error("Encoder not supported for codec: libjpeg-turbo 12bit");
 }
 
 function getPixelData(imageFrame, imageInfo) {
-  throw Error(
-    "GetPixel not found or not applied for codec:" + codecWrapper.encoderName
-  );
+  return codecFactory.getPixelData(imageFrame, imageInfo);
 }
 
 exports.decode = decode;