fix: Decode partial htj2k stream

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

@@ -249,11 +249,20 @@ function encode(context, codecConfig, imageFrame, imageInfo, options = {}) {
  * @returns Object containing decoded image frame and imageInfo (current) data
  *
  */
-function decode(context, codecConfig, imageFrame, imageInfo) {
+function decode(context, codecConfig, imageFrame, imageInfo, options = {}) {
   if (!imageFrame?.length) {
     throw new Error("Image frame not defined for decoding");
   }
-  const decoderInstance = new codecConfig.Decoder();
+  const reuseDecoder = options.reuseDecoder === true;
+  let decoderInstance;
+  if (reuseDecoder) {
+    if (!codecConfig.reusedDecoder) {
+      codecConfig.reusedDecoder = new codecConfig.Decoder();
+    }
+    decoderInstance = codecConfig.reusedDecoder;
+  } else {
+    decoderInstance = new codecConfig.Decoder();
+  }
 
   const { length } = imageFrame;
   // get pointer to the source/encoded bit stream buffer in WASM memory
@@ -277,8 +286,9 @@ function decode(context, codecConfig, imageFrame, imageInfo) {
   // get information about the decoded image
   const decodedImageInfo = decoderInstance.getFrameInfo();
 
-  // cleanup allocated memory
-  decoderInstance.delete();
+  if (!reuseDecoder) {
+    decoderInstance.delete();
+  }
 
   const processInfo = {
     duration: context.timer.getDuration(),

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

@@ -29,7 +29,9 @@ async function decode(imageFrame, imageInfo) {
     codecWasmModule,
     codecWrapper.decoderName,
     (context) => {
-      return codecFactory.decode(context, codecWrapper, imageFrame, imageInfo);
+      return codecFactory.decode(context, codecWrapper, imageFrame, imageInfo, {
+        reuseDecoder: true,
+      });
     }
   );
 }

packages/openjphjs/bench/decode.bench.js

@@ -8,16 +8,11 @@
 // "warm" = a shared decoder/encoder that has already done 5 decode/encode
 // passes at module load (untimed). The bench body is the 6th+ call.
 //
-// Important caveat for HTJ2K: cornerstone3D's decodeHTJ2K.ts:69 actually
-// creates a fresh `new HTJ2KDecoder()` for every frame (a comment in
-// that file notes reuse is "much slower for some reason"). So for
-// HTJ2K specifically, the production-cost approximation is:
+// HTJ2K production path (dicom-codec / cornerstone codecs) reuses a single
+// HTJ2KDecoder across frames. Per-frame cost ≈ decode — warm.
 //
-//   per-frame cost ≈ instantiate+destroy HTJ2KDecoder + decode — cold
-//
-// The "warm" HTJ2K decode bench remains useful for regression detection
-// on the openjph decoder kernel itself, but isn't what cornerstone3D
-// actually pays per frame.
+// "cold" benches still model a fresh decoder per frame for lifecycle regressions.
+// "warm" benches model the reused-decoder production path.
 //
 // Bench bodies are symmetric between cold and warm — the only difference
 // is module-load state, so the cold/warm delta isolates first-call

packages/openjphjs/src/CMakeLists.txt

@@ -1,7 +1,12 @@
 
 add_executable(openjphjs jslib.cpp)
 
-target_link_libraries(openjphjs PRIVATE openjphsimd)
+target_link_libraries(openjphjs PRIVATE openjph)
+target_include_directories(
+  openjphjs
+  PRIVATE
+    ${PROJECT_SOURCE_DIR}/extern/openjph/src/core/openjph
+)
 target_compile_options(openjphjs PRIVATE -DOJPH_ENABLE_WASM_SIMD -msimd128)
 target_compile_features(openjphjs PUBLIC cxx_std_11)
 set_target_properties(
@@ -11,7 +16,7 @@ set_target_properties(
       -O3 \
       -s WASM=1 \
       --bind \
-      -s DISABLE_EXCEPTION_CATCHING=1 \
+      -s DISABLE_EXCEPTION_CATCHING=0 \
       -s ASSERTIONS=0 \
       -s MODULARIZE=1 \
       -s NO_EXIT_RUNTIME=1 \

packages/openjphjs/src/HTJ2KDecoder.hpp

@@ -118,10 +118,17 @@ class HTJ2KDecoder
   /// </summary>
   void readHeader()
   {
-    ojph::codestream codestream;
-    ojph::mem_infile mem_file;
-    mem_file.open(pEncoded_->data(), pEncoded_->size());
-    readHeader_(codestream, mem_file);
+    try
+    {
+      ojph::codestream codestream;
+      ojph::mem_infile mem_file;
+      mem_file.open(pEncoded_->data(), pEncoded_->size());
+      readHeader_(codestream, mem_file);
+    }
+    catch (const std::exception &e)
+    {
+      OJPH_INFO(0x00010020, "readHeader failed: %s", e.what());
+    }
   }
 
   /// <summary>
@@ -148,11 +155,18 @@ class HTJ2KDecoder
   /// </summary>
   void decode()
   {
-    ojph::codestream codestream;
-    ojph::mem_infile mem_file;
-    mem_file.open(pEncoded_->data(), pEncoded_->size());
-    readHeader_(codestream, mem_file);
-    decode_(codestream, frameInfo_, 0);
+    try
+    {
+      ojph::codestream codestream;
+      ojph::mem_infile mem_file;
+      mem_file.open(pEncoded_->data(), pEncoded_->size());
+      readHeader_(codestream, mem_file);
+      decode_(codestream, frameInfo_, 0);
+    }
+    catch (const std::exception &e)
+    {
+      OJPH_INFO(0x00010021, "decode failed (likely truncated stream): %s", e.what());
+    }
   }
 
   /// <summary>
@@ -163,11 +177,18 @@ class HTJ2KDecoder
   /// </summary>
   void decodeSubResolution(size_t decompositionLevel)
   {
-    ojph::codestream codestream;
-    ojph::mem_infile mem_file;
-    mem_file.open(pEncoded_->data(), pEncoded_->size());
-    readHeader_(codestream, mem_file);
-    decode_(codestream, frameInfo_, decompositionLevel);
+    try
+    {
+      ojph::codestream codestream;
+      ojph::mem_infile mem_file;
+      mem_file.open(pEncoded_->data(), pEncoded_->size());
+      readHeader_(codestream, mem_file);
+      decode_(codestream, frameInfo_, decompositionLevel);
+    }
+    catch (const std::exception &e)
+    {
+      OJPH_INFO(0x00010022, "decodeSubResolution failed: %s", e.what());
+    }
   }
 
   /// <summary>

packages/openjphjs/test/node/index.js

@@ -2,103 +2,119 @@
 // SPDX-License-Identifier: MIT
 
 let openjphjs = require("../../dist/openjphjs.js")
+const assert = require("assert")
 const fs = require("fs")
+const path = require("path")
 
-function decode(openjph, encodedImagePath, iterations = 100) {
-  const encodedBitStream = fs.readFileSync(encodedImagePath)
-  const decoder = new openjph.HTJ2KDecoder()
-  const encodedBuffer = decoder.getEncodedBuffer(encodedBitStream.length)
-  encodedBuffer.set(encodedBitStream)
+const rawPath = path.resolve(__dirname, "../fixtures/raw/CT1.RAW")
+const frameInfo = {
+  width: 512,
+  height: 512,
+  bitsPerSample: 16,
+  componentCount: 1,
+  isSigned: true,
+  isUsingColorTransform: false,
+}
+
+function encodeFrame(openjph, rawBytes, imageFrame, options = {}) {
+  const encoder = new openjph.HTJ2KEncoder()
+  const decodedBytes = encoder.getDecodedBuffer(imageFrame)
+  decodedBytes.set(rawBytes)
 
-  // do the actual benchmark
-  const beginDecode = process.hrtime()
-  for (var i = 0; i < iterations; i++) {
-    decoder.decode()
+  if (typeof options.lossless === "boolean") {
+    encoder.setQuality(options.lossless, options.quantizationStep || 0)
   }
-  const decodeDuration = process.hrtime(beginDecode) // hrtime returns seconds/nanoseconds tuple
-  const decodeDurationInSeconds =
-    decodeDuration[0] + decodeDuration[1] / 1000000000
 
-  // Print out information about the decode
-  console.log(
-    "Decode of " +
-      encodedImagePath +
-      " took " +
-      (decodeDurationInSeconds / iterations) * 1000 +
-      " ms"
-  )
-  const frameInfo = decoder.getFrameInfo()
-  console.log("  frameInfo = ", frameInfo)
-  console.log(" imageOffset = ", decoder.getImageOffset())
-  var decoded = decoder.getDecodedBuffer()
-  console.log("  decoded length = ", decoded.length)
+  encoder.encode()
+  const encoded = Uint8Array.from(encoder.getEncodedBuffer())
+  encoder.delete()
+  return encoded
+}
 
+function decodeFrame(openjph, encodedBytes) {
+  const decoder = new openjph.HTJ2KDecoder()
+  const encodedBuffer = decoder.getEncodedBuffer(encodedBytes.length)
+  encodedBuffer.set(encodedBytes)
+  decoder.decode()
+  const decoded = Uint8Array.from(decoder.getDecodedBuffer())
+  const decodedFrameInfo = decoder.getFrameInfo()
   decoder.delete()
+  return { decoded, decodedFrameInfo }
 }
 
-function encode(
-  openjph,
-  pathToUncompressedImageFrame,
-  imageFrame,
-  pathToJ2CFile,
-  iterations = 100
-) {
-  const uncompressedImageFrame = fs.readFileSync(pathToUncompressedImageFrame)
-  console.log("uncompressedImageFrame.length:", uncompressedImageFrame.length)
-  const encoder = new openjph.HTJ2KEncoder()
-  const decodedBytes = encoder.getDecodedBuffer(imageFrame)
-  decodedBytes.set(uncompressedImageFrame)
-  //encoder.setQuality(false, 0.001);
+function meanAbsoluteErrorI16(originalBytes, decodedBytes) {
+  assert.strictEqual(
+    decodedBytes.length,
+    originalBytes.length,
+    "Decoded byte length mismatch"
+  )
+
+  const original = new Int16Array(
+    originalBytes.buffer,
+    originalBytes.byteOffset,
+    originalBytes.byteLength / Int16Array.BYTES_PER_ELEMENT
+  )
+  const decoded = new Int16Array(
+    decodedBytes.buffer,
+    decodedBytes.byteOffset,
+    decodedBytes.byteLength / Int16Array.BYTES_PER_ELEMENT
+  )
 
-  const encodeBegin = process.hrtime()
-  for (var i = 0; i < iterations; i++) {
-    encoder.encode()
+  let absoluteErrorSum = 0
+  for (let i = 0; i < original.length; i++) {
+    absoluteErrorSum += Math.abs(original[i] - decoded[i])
   }
-  const encodeDuration = process.hrtime(encodeBegin)
-  const encodeDurationInSeconds =
-    encodeDuration[0] + encodeDuration[1] / 1000000000
 
-  // print out information about the encode
-  console.log(
-    "Encode of " +
-      pathToUncompressedImageFrame +
-      " took " +
-      (encodeDurationInSeconds / iterations) * 1000 +
-      " ms"
+  return absoluteErrorSum / original.length
+}
+
+function runLossyRoundTripTest(openjph, rawBytes) {
+  const encodedLossy = encodeFrame(openjph, rawBytes, frameInfo, {
+    lossless: false,
+    quantizationStep: 8,
+  })
+  const { decoded, decodedFrameInfo } = decodeFrame(openjph, encodedLossy)
+  const mae = meanAbsoluteErrorI16(rawBytes, decoded)
+
+  assert.strictEqual(decodedFrameInfo.width, frameInfo.width)
+  assert.strictEqual(decodedFrameInfo.height, frameInfo.height)
+  console.log(`Heavy lossy round-trip MAE: ${mae.toFixed(2)}`)
+  assert.ok(mae < 1500, `Heavy lossy MAE too large: ${mae}`)
+}
+
+function runTruncatedLosslessDecodeTest(openjph, rawBytes) {
+  const encodedLossless = encodeFrame(openjph, rawBytes, frameInfo, {
+    lossless: true,
+    quantizationStep: 0,
+  })
+  const truncatedSize = Math.min(10 * 1024, encodedLossless.length)
+  const truncatedBitstream = encodedLossless.slice(0, truncatedSize)
+  const { decoded, decodedFrameInfo } = decodeFrame(openjph, truncatedBitstream)
+  assert.ok(
+    decoded.length > 0,
+    `Expected a minimally decodable image from ${truncatedSize} bytes`
   )
-  const encodedBytes = encoder.getEncodedBuffer()
-  console.log("  encoded length=", encodedBytes.length)
+  const mae = meanAbsoluteErrorI16(rawBytes, decoded)
 
-  if (pathToJ2CFile) {
-    //fs.writeFileSync(pathToJ2CFile, encodedBytes);
-  }
-  // cleanup allocated memory
-  encoder.delete()
+  assert.strictEqual(decodedFrameInfo.width, frameInfo.width)
+  assert.strictEqual(decodedFrameInfo.height, frameInfo.height)
+  console.log(
+    `Truncated lossless decode MAE (${truncatedSize} bytes kept): ${mae.toFixed(2)}`
+  )
+  assert.ok(mae > 10, `Expected degradation with truncated stream, MAE: ${mae}`)
+  assert.ok(mae < 300, `Truncated lossless MAE too large: ${mae}`)
 }
 
 function main(openjph) {
-  decode(openjph, "../fixtures/j2c/CT2.j2c")
-  decode(openjph, "../../extern/OpenJPH/subprojects/js/html/test.j2c")
-
-  encode(
-    openjph,
-    "../fixtures/raw/CT1.RAW",
-    {
-      width: 512,
-      height: 512,
-      bitsPerSample: 16,
-      componentCount: 1,
-      isSigned: true,
-    },
-    "../fixtures/j2c/CT1.j2c"
-  )
+  const rawBytes = fs.readFileSync(rawPath)
+  runLossyRoundTripTest(openjph, rawBytes)
+  runTruncatedLosslessDecodeTest(openjph, rawBytes)
+  console.log("openjphjs node tests passed")
 }
 
 if (typeof openjphjs !== "undefined") {
-  console.log("testing openjphjs...")
-  openjphjs().then(function (openjphwasm) {
-    main(openjphwasm)
-  })
+  console.log("running openjphjs node tests...")
+  openjphjs().then(main)
 } else {
-  console.warn("openjphjs isn't defined");
+  console.warn("openjphjs isn't defined")
 }