spatialdata-js-util 0.1.0__py3-none-any.whl

spatialdata_js_util/codecs/htj2k_wasm.py

@@ -0,0 +1,266 @@
+"""The openjph-wasm HTJ2K backend: vendored WASM driven by Node.js workers.
+
+This is the same WASM build the JS reader uses, which makes it the reference for
+encode/decode agreement with the browser. Prefer the `backends` module over
+calling this directly — it selects between this and the Node-free `imagecodecs`
+backend.
+"""
+
+from __future__ import annotations
+
+import atexit
+import base64
+import json
+import os
+import shutil
+import struct
+import subprocess
+import threading
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+_VENDOR_DIR = Path(__file__).resolve().parent / "vendor"
+_ENCODE_SCRIPT = _VENDOR_DIR / "encode-plane.mjs"
+
+
+def encode_script_path() -> Path:
+    return _ENCODE_SCRIPT
+
+
+def openjph_vendor_dir() -> Path:
+    return _VENDOR_DIR / "openjph"
+
+
+def openjph_encode_options(encode_options: dict[str, Any]) -> tuple[bool, float]:
+    """Map encode options to OpenJPH WASM setQuality(reversible, quality)."""
+    reversible = bool(encode_options.get("reversible", True))
+    if reversible:
+        return True, 0.0
+    quality = encode_options.get("quality", encode_options.get("level", 0.0002))
+    return False, float(quality)
+
+
+def _encode_request_payload(
+    volume: np.ndarray, *, reversible: bool, quality: float
+) -> dict[str, Any]:
+    """Build an encode request for a 2D plane or a 3D (components, y, x) volume.
+
+    The samples are sent planar / component-major (C-order of the array), which
+    is exactly the layout openjph-wasm expects for multi-component codestreams.
+    """
+    array = np.ascontiguousarray(np.asarray(volume))
+    if array.ndim == 2:
+        components, (height, width) = 1, (int(array.shape[0]), int(array.shape[1]))
+    elif array.ndim == 3:
+        components, height, width = (int(value) for value in array.shape)
+    else:
+        raise ValueError(
+            f"HTJ2K encode expects a 2D plane or 3D (components, y, x) volume, got shape {array.shape}."
+        )
+    return {
+        "width": width,
+        "height": height,
+        "components": components,
+        "dtype": array.dtype.name,
+        "reversible": reversible,
+        "quality": quality,
+        "plane": base64.b64encode(array.tobytes(order="C")).decode("ascii"),
+    }
+
+
+# Decode response header (see vendor/encode-plane.mjs): little-endian
+# u32 components, u32 height, u32 width, u8 bytesPerSample, u8 isSigned.
+_DECODE_HEADER = struct.Struct("<IIIBB")
+
+
+def _decode_response_to_array(resp: bytes) -> np.ndarray:
+    components, height, width, bytes_per_sample, is_signed = _DECODE_HEADER.unpack_from(resp, 0)
+    body = resp[_DECODE_HEADER.size :]
+    dtype = np.dtype(f"{'i' if is_signed else 'u'}{bytes_per_sample}")
+    return np.frombuffer(body, dtype=dtype).reshape(components, height, width)
+
+
+class OpenJphEncoderWorker:
+    """Long-lived Node subprocess that loads OpenJPH WASM once."""
+
+    def __init__(self) -> None:
+        node = shutil.which("node")
+        if node is None:
+            raise RuntimeError("Node.js is required for HTJ2K encode but was not found on PATH.")
+        if not _ENCODE_SCRIPT.is_file():
+            raise RuntimeError(f"HTJ2K encode script not found: {_ENCODE_SCRIPT}")
+        vendor_dir = openjph_vendor_dir()
+        missing = [
+            str(path.relative_to(vendor_dir))
+            for path in (vendor_dir / "index.mjs", vendor_dir / "wasm" / "libopenjph.wasm")
+            if not path.is_file()
+        ]
+        if missing:
+            raise RuntimeError(
+                f"Vendored openjph-wasm assets missing under {vendor_dir}: {', '.join(missing)}. "
+                "Both index.mjs and wasm/libopenjph.wasm are required; "
+                "run scripts/vendor-openjph-for-python.mjs before building the package."
+            )
+
+        self._lock = threading.Lock()
+        self._proc = subprocess.Popen(
+            [node, str(_ENCODE_SCRIPT), "--worker"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            bufsize=0,
+        )
+        if self._proc.stdin is None or self._proc.stdout is None:
+            raise RuntimeError("Failed to open pipes for HTJ2K encoder worker.")
+
+    def close(self) -> None:
+        with self._lock:
+            assert(self._proc)
+            if self._proc.stdin is not None:
+                self._proc.stdin.close()
+            if self._proc.poll() is None:
+                self._proc.wait(timeout=5)
+                if self._proc.poll() is None:
+                    self._proc.terminate()
+                    self._proc.wait(timeout=5)
+                    if self._proc.poll() is None:
+                        self._proc.kill()
+            self._proc = None  # type: ignore[assignment]
+
+    def _request(self, payload: dict[str, Any]) -> bytes:
+        with self._lock:
+            if self._proc is None or self._proc.poll() is not None:
+                raise RuntimeError("HTJ2K worker is not running.")
+            body = json.dumps(payload).encode("utf-8")
+            assert self._proc.stdin is not None
+            assert self._proc.stdout is not None
+            self._proc.stdin.write(struct.pack(">I", len(body)))
+            self._proc.stdin.write(body)
+            self._proc.stdin.flush()
+
+            header = self._read_exact(self._proc.stdout, 5)
+            status = header[0]
+            length = struct.unpack(">I", header[1:5])[0]
+            resp = self._read_exact(self._proc.stdout, length)
+            if status != 0:
+                message = resp.decode("utf-8", errors="replace")
+                raise RuntimeError(message or "HTJ2K worker failed.")
+            return bytes(resp)
+
+    def encode(self, volume: np.ndarray, *, reversible: bool = True, quality: float = 0.0) -> bytes:
+        return self._request(
+            _encode_request_payload(volume, reversible=reversible, quality=quality)
+        )
+
+    def decode(self, codestream: bytes | bytearray) -> np.ndarray:
+        payload = {
+            "op": "decode",
+            "codestream": base64.b64encode(bytes(codestream)).decode("ascii"),
+        }
+        return _decode_response_to_array(self._request(payload))
+
+    @staticmethod
+    def _read_exact(stream: Any, length: int) -> bytes:
+        chunks: list[bytes] = []
+        received = 0
+        while received < length:
+            chunk = stream.read(length - received)
+            if not chunk:
+                raise RuntimeError("HTJ2K encoder worker closed stdout unexpectedly.")
+            chunks.append(chunk)
+            received += len(chunk)
+        return b"".join(chunks)
+
+
+class EncoderPool:
+    """Pool of persistent OpenJPH encoder workers."""
+
+    def __init__(self, workers: int | None = None) -> None:
+        count = workers if workers is not None else (os.cpu_count() or 1)
+        self._workers = [OpenJphEncoderWorker() for _ in range(max(1, count))]
+        self._next = 0
+        self._lock = threading.Lock()
+
+    def _next_worker(self) -> OpenJphEncoderWorker:
+        with self._lock:
+            worker = self._workers[self._next]
+            self._next = (self._next + 1) % len(self._workers)
+        return worker
+
+    def encode(self, volume: np.ndarray, *, reversible: bool = True, quality: float = 0.0) -> bytes:
+        return self._next_worker().encode(volume, reversible=reversible, quality=quality)
+
+    def decode(self, codestream: bytes | bytearray) -> np.ndarray:
+        return self._next_worker().decode(codestream)
+
+    def close(self) -> None:
+        for worker in self._workers:
+            worker.close()
+
+
+_pool: EncoderPool | None = None
+_pool_lock = threading.Lock()
+_pool_workers: int | None = None
+
+
+def configure_encoder_pool(workers: int | None = None) -> None:
+    """Configure or replace the global HTJ2K encoder worker pool."""
+    global _pool, _pool_workers
+    with _pool_lock:
+        if _pool is not None:
+            _pool.close()
+            _pool = None
+        _pool_workers = workers
+
+
+def get_encoder_pool(workers: int | None = None) -> EncoderPool:
+    global _pool, _pool_workers
+    with _pool_lock:
+        effective_workers = workers if workers is not None else _pool_workers
+        if _pool is None or (workers is not None and workers != _pool_workers):
+            if _pool is not None:
+                _pool.close()
+            _pool_workers = effective_workers
+            _pool = EncoderPool(workers=effective_workers)
+        return _pool
+
+
+def shutdown_encoder_pool() -> None:
+    global _pool, _pool_workers
+    with _pool_lock:
+        if _pool is not None:
+            _pool.close()
+            _pool = None
+        _pool_workers = None
+
+
+atexit.register(shutdown_encoder_pool)
+
+
+@lru_cache(maxsize=1)
+def wasm_encode_available() -> bool:
+    """Return whether the vendored OpenJPH WASM helper (and Node.js) is usable."""
+    try:
+        plane = np.zeros((4, 4), dtype=np.uint16)
+        encode_htj2k_wasm(plane, reversible=True, quality=0.0)
+    except Exception:
+        return False
+    return True
+
+
+def encode_htj2k_wasm(
+    volume: np.ndarray,
+    *,
+    reversible: bool = True,
+    quality: float = 0.0,
+) -> bytes:
+    """Encode a 2D plane or 3D (components, y, x) volume to an HTJ2K codestream."""
+    return get_encoder_pool().encode(volume, reversible=reversible, quality=quality)
+
+
+def decode_htj2k_wasm(codestream: bytes | bytearray) -> np.ndarray:
+    """Decode an HTJ2K codestream to a (components, y, x) array via openjph-wasm."""
+    return get_encoder_pool().decode(codestream)

spatialdata_js_util/codecs/names.py

@@ -0,0 +1,26 @@
+"""Codec identifiers shared by the writer, the reader shim, and the JS runtime.
+
+These strings are the `name` field of the zarr v3 array metadata `codecs` entry,
+so they are part of the on-disk contract. They must stay in sync with
+`packages/zarrextra/src/codecs.ts`.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+CODEC_JPEG2K = "imagecodecs_jpeg2k"
+CODEC_HTJ2K_OPENJPH = "experimental.openjph_htj2k"
+# Legacy label for stores written before OpenJPH became the supported encoder.
+CODEC_HTJ2K_LEGACY = "experimental.imagecodecs_htj2k"
+
+HTJ2K_CODECS = frozenset({CODEC_HTJ2K_OPENJPH, CODEC_HTJ2K_LEGACY})
+SUPPORTED_IMAGE_CODECS = frozenset({CODEC_JPEG2K, CODEC_HTJ2K_OPENJPH})
+
+HTJ2K_ENCODER = "openjph"
+
+CodecName = Literal["imagecodecs_jpeg2k", "experimental.openjph_htj2k"]
+
+
+def is_htj2k_codec(codec: str) -> bool:
+    return codec in HTJ2K_CODECS

spatialdata_js_util/codecs/probe/multicomponent.json

@@ -0,0 +1,3 @@
+{
+  "encoder": "openjph-wasm"
+}

spatialdata_js_util/codecs/vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendored OpenJPH WASM assets and Node encode driver."""

spatialdata_js_util/codecs/vendor/encode-plane.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import { dirname, join } from 'node:path';
+/**
+ * Encode/decode HTJ2K chunks via vendored openjph-wasm.
+ *
+ * A chunk is one or more planar, component-major planes (e.g. z-planes of a
+ * volumetric chunk) encoded as a single multi-component codestream.
+ *
+ * One-shot mode (default): encode only.
+ *   stdin: JSON { width, height, components?, dtype, reversible?, quality?, plane: base64 }
+ *   stdout: raw HTJ2K bytes
+ *
+ * Worker mode (--worker):
+ *   Repeated length-prefixed requests on stdin; length-prefixed responses on stdout.
+ *   Request:  [u32 BE length][JSON utf8]
+ *     encode (default): { width, height, components?, dtype, reversible?, quality?, plane: base64 }
+ *     decode:           { op: "decode", codestream: base64 }
+ *   Response: [u8 status][u32 BE length][payload]
+ *     status 0 = payload (encode: HTJ2K bytes; decode: 14-byte header + planar samples)
+ *     status 1 = UTF-8 error message
+ *
+ *   Decode header (little-endian): u32 components, u32 height, u32 width,
+ *     u8 bytesPerSample, u8 isSigned — followed by the raw component-major samples.
+ */
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const vendorDir = dirname(fileURLToPath(import.meta.url));
+const openjphIndex = join(vendorDir, 'openjph', 'index.mjs');
+const workerMode = process.argv.includes('--worker');
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+
+function planeArrayForDtype(dtype, bytes) {
+  switch (dtype) {
+    case 'uint8':
+      return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    case 'int8':
+      return new Int8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    case 'uint16':
+      return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+    case 'int16':
+      return new Int16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+    default:
+      throw new Error(`Unsupported plane dtype '${dtype}'.`);
+  }
+}
+
+async function loadRuntime() {
+  const mod = await import(pathToFileURL(openjphIndex).href);
+  if (typeof mod.encode !== 'function' || typeof mod.decode !== 'function') {
+    throw new Error('Vendored openjph-wasm does not expose encode()/decode().');
+  }
+  return mod;
+}
+
+async function encodeChunk(runtime, request) {
+  const { width, height, dtype } = request;
+  const components = request.components ?? 1;
+  const reversible = request.reversible ?? true;
+  const quality = request.quality ?? 0;
+  const planeBytes = Buffer.from(request.plane, 'base64');
+  const data = planeArrayForDtype(dtype, planeBytes);
+  const expectedValues = width * height * components;
+  if (data.length !== expectedValues) {
+    throw new Error(`Chunk has ${data.length} samples, expected ${expectedValues}.`);
+  }
+
+  // bitDepth / isSigned are inferred from the typed array by openjph-wasm.
+  const input = { data, width, height, components, reversible };
+  if (!reversible) {
+    input.quality = quality;
+  }
+  return await runtime.encode(input);
+}
+
+async function decodeChunk(runtime, request) {
+  const codestream = Buffer.from(request.codestream, 'base64');
+  const result = await runtime.decode(new Uint8Array(codestream));
+  const samples = result.data;
+  const bytesPerSample = samples.BYTES_PER_ELEMENT;
+  const header = Buffer.alloc(14);
+  header.writeUInt32LE(result.components, 0);
+  header.writeUInt32LE(result.height, 4);
+  header.writeUInt32LE(result.width, 8);
+  header.writeUInt8(bytesPerSample, 12);
+  header.writeUInt8(result.isSigned ? 1 : 0, 13);
+  const body = Buffer.from(samples.buffer, samples.byteOffset, samples.byteLength);
+  return Buffer.concat([header, body]);
+}
+
+async function handleRequest(runtime, request) {
+  return request.op === 'decode'
+    ? await decodeChunk(runtime, request)
+    : await encodeChunk(runtime, request);
+}
+
+function writeResponse(status, payload) {
+  const header = Buffer.alloc(5);
+  header.writeUInt8(status, 0);
+  header.writeUInt32BE(payload.length, 1);
+  process.stdout.write(header);
+  if (payload.length > 0) {
+    process.stdout.write(payload);
+  }
+}
+
+async function* readLengthPrefixedJson(stream) {
+  let buffer = Buffer.alloc(0);
+  for await (const chunk of stream) {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (buffer.length >= 4) {
+      const length = buffer.readUInt32BE(0);
+      if (buffer.length < 4 + length) {
+        break;
+      }
+      const body = buffer.subarray(4, 4 + length);
+      buffer = buffer.subarray(4 + length);
+      yield JSON.parse(body.toString('utf8'));
+    }
+  }
+}
+
+async function runWorker(runtime) {
+  for await (const request of readLengthPrefixedJson(process.stdin)) {
+    try {
+      const payload = await handleRequest(runtime, request);
+      writeResponse(0, Buffer.from(payload));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      writeResponse(1, Buffer.from(message, 'utf8'));
+    }
+  }
+}
+
+async function runOnce(runtime) {
+  const request = JSON.parse((await readStdin()).toString('utf8'));
+  const encoded = await encodeChunk(runtime, request);
+  process.stdout.write(Buffer.from(encoded));
+}
+
+async function main() {
+  const runtime = await loadRuntime();
+  if (workerMode) {
+    await runWorker(runtime);
+    return;
+  }
+  await runOnce(runtime);
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  if (workerMode) {
+    writeResponse(1, Buffer.from(message, 'utf8'));
+    process.exit(1);
+  }
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+});

spatialdata_js_util/codecs/vendor/openjph/index.mjs

@@ -0,0 +1,131 @@
+// openjph-wasm: typed wrapper around the OpenJPH Emscripten module.
+// Provides multi-component HTJ2K (JPEG 2000 Part 15) encode + decode.
+let modPromise;
+async function loadModule(options = {}) {
+    if (options.moduleFactory)
+        return options.moduleFactory();
+    const url = new URL("./wasm/libopenjph.mjs", import.meta.url).href;
+    const imported = await import(/* @vite-ignore */ url);
+    const factory = imported.default ?? imported;
+    return factory(options.locateFile ? { locateFile: options.locateFile } : {});
+}
+/** Initialise (and cache) the underlying WASM module. */
+export function init(options) {
+    modPromise ??= loadModule(options);
+    return modPromise;
+}
+function dtypeOf(view) {
+    if (view instanceof Uint8Array || view instanceof Uint8ClampedArray)
+        return { bitDepth: 8, isSigned: false };
+    if (view instanceof Int8Array)
+        return { bitDepth: 8, isSigned: true };
+    if (view instanceof Uint16Array)
+        return { bitDepth: 16, isSigned: false };
+    if (view instanceof Int16Array)
+        return { bitDepth: 16, isSigned: true };
+    if (view instanceof Int32Array)
+        return { bitDepth: 32, isSigned: true };
+    throw new Error("openjph-wasm: unsupported typed array for encode input");
+}
+function outputArray(bitDepth, isSigned, n) {
+    if (bitDepth <= 8)
+        return isSigned ? new Int8Array(n) : new Uint8Array(n);
+    if (bitDepth <= 16)
+        return isSigned ? new Int16Array(n) : new Uint16Array(n);
+    return new Int32Array(n);
+}
+/** Decode a J2K/HTJ2K codestream into planar, component-major samples. */
+export async function decode(codestream, options) {
+    const mod = await init(options);
+    const create = mod.cwrap("create_j2c_data", "number", []);
+    const initData = mod.cwrap("init_j2c_data", null, ["number", "number", "number"]);
+    const numComps = mod.cwrap("get_j2c_num_components", "number", ["number"]);
+    const getW = mod.cwrap("get_j2c_width", "number", ["number", "number"]);
+    const getH = mod.cwrap("get_j2c_height", "number", ["number", "number"]);
+    const getBD = mod.cwrap("get_j2c_bit_depth", "number", ["number", "number"]);
+    const getSigned = mod.cwrap("get_j2c_is_signed", "number", ["number", "number"]);
+    const parse = mod.cwrap("parse_j2c_data", null, ["number"]);
+    const pull = mod.cwrap("pull_j2c_line", "number", ["number"]);
+    const currComp = mod.cwrap("get_curr_comp", "number", ["number"]);
+    const release = mod.cwrap("release_j2c_data", null, ["number"]);
+    const inPtr = mod._malloc(codestream.length);
+    mod.HEAPU8.set(codestream, inPtr);
+    const j2c = create();
+    try {
+        initData(j2c, inPtr, codestream.length);
+        const components = numComps(j2c);
+        if (components <= 0)
+            throw new Error("openjph-wasm: failed to parse codestream headers");
+        const width = getW(j2c, 0);
+        const height = getH(j2c, 0);
+        const bitDepth = getBD(j2c, 0);
+        const isSigned = getSigned(j2c, 0) === 1;
+        parse(j2c);
+        const out = outputArray(bitDepth, isSigned, components * width * height);
+        const rowPerComp = new Int32Array(components);
+        const totalLines = components * height;
+        for (let i = 0; i < totalLines; i++) {
+            const linePtr = pull(j2c);
+            const c = currComp(j2c);
+            const row = rowPerComp[c]++;
+            const base = (linePtr >> 2); // i32 index into HEAP32
+            const dst = (c * height + row) * width;
+            for (let x = 0; x < width; x++)
+                out[dst + x] = mod.HEAP32[base + x];
+        }
+        return { width, height, components, bitDepth, isSigned, data: out };
+    }
+    finally {
+        release(j2c);
+        mod._free(inPtr);
+    }
+}
+/** Encode planar, component-major samples into a J2K/HTJ2K codestream. */
+export async function encode(input, options) {
+    const mod = await init(options);
+    const { width, height } = input;
+    const components = input.components ?? input.data.length / (width * height);
+    if (!Number.isInteger(components) || components < 1)
+        throw new Error("openjph-wasm: data length is not a multiple of width*height");
+    const inferred = dtypeOf(input.data);
+    const bitDepth = input.bitDepth ?? inferred.bitDepth;
+    const isSigned = input.isSigned ?? inferred.isSigned;
+    const reversible = input.reversible ?? true;
+    const quality = input.quality ?? 0;
+    const decompositions = input.decompositions ?? 5;
+    const [bw, bh] = input.blockSize ?? [64, 64];
+    const encCreate = mod.cwrap("enc_create", "number", []);
+    const encEncode = mod.cwrap("enc_encode", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
+    const encGetData = mod.cwrap("enc_get_data", "number", ["number"]);
+    const encGetSize = mod.cwrap("enc_get_size", "number", ["number"]);
+    const encDestroy = mod.cwrap("enc_destroy", null, ["number"]);
+    const n = components * width * height;
+    // Convert samples to int32 (planar comp-major) for the line buffers.
+    const i32 = new Int32Array(n);
+    const src = input.data;
+    for (let i = 0; i < n; i++)
+        i32[i] = src[i] | 0;
+    const dataPtr = mod._malloc(n * 4);
+    mod.HEAP32.set(i32, dataPtr >> 2);
+    const bdPtr = mod._malloc(components * 4);
+    const sgPtr = mod._malloc(components * 4);
+    for (let c = 0; c < components; c++) {
+        mod.HEAP32[(bdPtr >> 2) + c] = bitDepth;
+        mod.HEAP32[(sgPtr >> 2) + c] = isSigned ? 1 : 0;
+    }
+    const enc = encCreate();
+    try {
+        const size = encEncode(enc, dataPtr, width, height, components, bdPtr, sgPtr, reversible ? 1 : 0, quality, decompositions, bw, bh);
+        if (size < 0)
+            throw new Error("openjph-wasm: encode failed");
+        const dataAddr = encGetData(enc);
+        const sz = encGetSize(enc);
+        return mod.HEAPU8.slice(dataAddr, dataAddr + sz);
+    }
+    finally {
+        encDestroy(enc);
+        mod._free(dataPtr);
+        mod._free(bdPtr);
+        mod._free(sgPtr);
+    }
+}

spatialdata_js_util/codecs/vendor/openjph/wasm/libopenjph.mjs

@@ -0,0 +1,2 @@
+async function Module(moduleArg={}){var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("node:module");var require=createRequire(import.meta.url)}var programArgs=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("node:fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("node:path").dirname(require("node:url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}programArgs=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");class EmscriptenEH{}class EmscriptenSjLj extends EmscriptenEH{}class CppException extends EmscriptenEH{constructor(excPtr){super();this.excPtr=excPtr}}var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["w"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what=`Aborted(${what})`;err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("libopenjph.wasm")}return new URL("libopenjph.wasm",import.meta.url).href}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP16;var HEAP32;var HEAP64;var HEAP8;var HEAPF32;var HEAPF64;var HEAPU16;var HEAPU32;var HEAPU64;var HEAPU8;var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);function getValue(ptr,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":return HEAP8[ptr];case"i8":return HEAP8[ptr];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":return HEAP64[ptr>>3];case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];case"*":return HEAPU32[ptr>>2];default:abort(`invalid type for getValue: ${type}`)}}var noExitRuntime=true;function setValue(ptr,value,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":HEAP8[ptr]=value;break;case"i8":HEAP8[ptr]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":HEAP64[ptr>>3]=BigInt(value);break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;case"*":HEAPU32[ptr>>2]=value;break;default:abort(`invalid type for setValue: ${type}`)}}var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var exceptionCaught=[];var uncaughtExceptionCount=0;var ___cxa_begin_catch=ptr=>{var info=new ExceptionInfo(ptr);if(!info.get_caught()){info.set_caught(true);uncaughtExceptionCount--}info.set_rethrown(false);exceptionCaught.push(info);return ___cxa_get_exception_ptr(ptr)};var exceptionLast=null;var ___cxa_end_catch=()=>{_setThrew(0,0);var info=exceptionCaught.pop();___cxa_decrement_exception_refcount(info.excPtr);exceptionLast=null};class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}}var setTempRet0=val=>__emscripten_tempret_set(val);var findMatchingCatch=args=>{var thrown=exceptionLast?.excPtr;if(!thrown){setTempRet0(0);return 0}var info=new ExceptionInfo(thrown);info.set_adjusted_ptr(thrown);var thrownType=info.get_type();if(!thrownType){setTempRet0(0);return thrown}for(var caughtType of args){if(caughtType===0||caughtType===thrownType){break}var adjusted_ptr_addr=info.ptr+16;if(___cxa_can_catch(caughtType,thrownType,adjusted_ptr_addr)){setTempRet0(caughtType);return thrown}}setTempRet0(thrownType);return thrown};var ___cxa_find_matching_catch_2=()=>findMatchingCatch([]);var ___cxa_find_matching_catch_3=arg0=>findMatchingCatch([arg0]);var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);___cxa_increment_exception_refcount(ptr);exceptionLast=new CppException(ptr);uncaughtExceptionCount++;throw exceptionLast};var ___resumeException=ptr=>{if(!exceptionLast){exceptionLast=new CppException(ptr)}throw exceptionLast};var __abort_js=()=>abort("");var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var _fd_close=fd=>52;var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);function _fd_seek(fd,offset,whence,newOffset){offset=bigintToI53Checked(offset);return 70}var printCharBuffers=[null,[],[]];var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer));buffer.length=0}else{buffer.push(curr)}};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var _fd_write=(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0};var _llvm_eh_typeid_for=type=>type;var wasmTableMirror=[];var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])programArgs=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["setValue"]=setValue;Module["getValue"]=getValue;Module["writeArrayToMemory"]=writeArrayToMemory;var _create_j2c_data,_init_j2c_data,_get_j2c_num_components,_get_j2c_width,_get_j2c_height,_get_j2c_bit_depth,_get_j2c_is_signed,_get_j2c_downsampling_x,_get_j2c_downsampling_y,_parse_j2c_data,_pull_j2c_line,_get_curr_comp,_restrict_input_resolution,_enable_resilience,_release_j2c_data,_enc_create,_enc_destroy,_enc_encode,_enc_get_data,_enc_get_size,_free,_malloc,_setThrew,__emscripten_tempret_set,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,___cxa_increment_exception_refcount,___cxa_decrement_exception_refcount,___cxa_can_catch,___cxa_get_exception_ptr,memory,__indirect_function_table,wasmMemory,wasmTable;function assignWasmExports(wasmExports){_create_j2c_data=Module["_create_j2c_data"]=wasmExports["x"];_init_j2c_data=Module["_init_j2c_data"]=wasmExports["z"];_get_j2c_num_components=Module["_get_j2c_num_components"]=wasmExports["A"];_get_j2c_width=Module["_get_j2c_width"]=wasmExports["B"];_get_j2c_height=Module["_get_j2c_height"]=wasmExports["C"];_get_j2c_bit_depth=Module["_get_j2c_bit_depth"]=wasmExports["D"];_get_j2c_is_signed=Module["_get_j2c_is_signed"]=wasmExports["E"];_get_j2c_downsampling_x=Module["_get_j2c_downsampling_x"]=wasmExports["F"];_get_j2c_downsampling_y=Module["_get_j2c_downsampling_y"]=wasmExports["G"];_parse_j2c_data=Module["_parse_j2c_data"]=wasmExports["H"];_pull_j2c_line=Module["_pull_j2c_line"]=wasmExports["I"];_get_curr_comp=Module["_get_curr_comp"]=wasmExports["J"];_restrict_input_resolution=Module["_restrict_input_resolution"]=wasmExports["K"];_enable_resilience=Module["_enable_resilience"]=wasmExports["L"];_release_j2c_data=Module["_release_j2c_data"]=wasmExports["M"];_enc_create=Module["_enc_create"]=wasmExports["N"];_enc_destroy=Module["_enc_destroy"]=wasmExports["O"];_enc_encode=Module["_enc_encode"]=wasmExports["P"];_enc_get_data=Module["_enc_get_data"]=wasmExports["Q"];_enc_get_size=Module["_enc_get_size"]=wasmExports["R"];_free=Module["_free"]=wasmExports["S"];_malloc=Module["_malloc"]=wasmExports["T"];_setThrew=wasmExports["U"];__emscripten_tempret_set=wasmExports["V"];__emscripten_stack_restore=wasmExports["W"];__emscripten_stack_alloc=wasmExports["X"];_emscripten_stack_get_current=wasmExports["Y"];___cxa_increment_exception_refcount=wasmExports["Z"];___cxa_decrement_exception_refcount=wasmExports["_"];___cxa_can_catch=wasmExports["$"];___cxa_get_exception_ptr=wasmExports["aa"];memory=wasmMemory=wasmExports["v"];__indirect_function_table=wasmTable=wasmExports["y"]}var wasmImports={g:___cxa_begin_catch,n:___cxa_end_catch,c:___cxa_find_matching_catch_2,a:___cxa_find_matching_catch_3,d:___cxa_throw,b:___resumeException,r:__abort_js,q:_emscripten_resize_heap,t:_fd_close,s:_fd_seek,l:_fd_write,o:invoke_i,e:invoke_ii,m:invoke_iii,h:invoke_iiii,j:invoke_v,i:invoke_vi,k:invoke_vii,f:invoke_viiii,u:invoke_viiiiii,p:_llvm_eh_typeid_for};function invoke_ii(index,a1){var sp=stackSave();try{return getWasmTableEntry(index)(a1)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_v(index){var sp=stackSave();try{getWasmTableEntry(index)()}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_vi(index,a1){var sp=stackSave();try{getWasmTableEntry(index)(a1)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiii(index,a1,a2,a3){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiii(index,a1,a2,a3,a4){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_i(index){var sp=stackSave();try{return getWasmTableEntry(index)()}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiiiii(index,a1,a2,a3,a4,a5,a6){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iii(index,a1,a2){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_vii(index,a1,a2){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}async function run(){preRun();var setStatus=Module["setStatus"];if(setStatus){setStatus("Running...");await new Promise(resolve=>setTimeout(resolve,1));setTimeout(setStatus,1,"")}if(ABORT)return;initRuntime();Module["onRuntimeInitialized"]?.();postRun()}var wasmExports;wasmExports=await createWasm();await run();
+;return Module}export default Module;