open-ultrahdr 0.1.2 → 0.2.0

package/dist/index.mjs

@@ -38,65 +38,61 @@ var smallSizeEncodeOptions = {
 };
 
 // src/index.ts
+var WASM_FILENAME = "open_ultrahdr.wasm";
 var location = "";
-var wasmUrl = "";
+var explicitWasmUrl = null;
 var wasmInstance = null;
 var initPromise = null;
+var initGeneration = 0;
 function setLocation(newLocation) {
   location = newLocation;
+  explicitWasmUrl = null;
+  resetCache();
 }
 function setWasmUrl(url) {
-  wasmUrl = url;
+  explicitWasmUrl = url;
+  resetCache();
 }
-function isWasmMetadataInstance(metadata) {
-  return typeof metadata === "object" && metadata !== null && "__wbg_ptr" in metadata;
+function resetCache() {
+  initGeneration += 1;
+  wasmInstance = null;
+  initPromise = null;
 }
-async function toWasmMetadata(metadata) {
-  if (isWasmMetadataInstance(metadata)) {
-    return metadata;
-  }
-  const wasm = await getWasm();
-  const wasmMetadata = wasm.createDefaultMetadata();
-  wasmMetadata.version = metadata.version;
-  wasmMetadata.baseRenditionIsHdr = metadata.baseRenditionIsHdr;
-  wasmMetadata.gainMapMin = metadata.gainMapMin;
-  wasmMetadata.gainMapMax = metadata.gainMapMax;
-  wasmMetadata.gamma = metadata.gamma;
-  wasmMetadata.offsetSdr = metadata.offsetSdr;
-  wasmMetadata.offsetHdr = metadata.offsetHdr;
-  wasmMetadata.hdrCapacityMin = metadata.hdrCapacityMin;
-  wasmMetadata.hdrCapacityMax = metadata.hdrCapacityMax;
-  return wasmMetadata;
+function joinPath(base, name) {
+  if (!base) return name;
+  return base.endsWith("/") ? `${base}${name}` : `${base}/${name}`;
 }
 async function getWasm() {
-  if (wasmInstance) {
-    return wasmInstance;
-  }
-  if (initPromise) {
-    return initPromise;
-  }
+  if (wasmInstance) return wasmInstance;
+  if (initPromise) return initPromise;
+  const generation = initGeneration;
   initPromise = (async () => {
     try {
-      const UltraHdrWasm = await import("open-ultrahdr-wasm");
-      if (wasmUrl) {
-        await UltraHdrWasm.default(wasmUrl);
+      const wasmModule = await import("open-ultrahdr-wasm");
+      const factory = wasmModule.default;
+      const isNode = typeof process !== "undefined" && !!process.versions && !!process.versions.node;
+      const moduleOptions = {};
+      if (explicitWasmUrl) {
+        moduleOptions.locateFile = (path) => path.endsWith(".wasm") ? explicitWasmUrl : path;
       } else if (location) {
-        const base = location.endsWith("/") ? location : `${location}/`;
-        const wasmPath = base + "open_ultrahdr_bg.wasm";
-        if (typeof process !== "undefined" && process.versions && process.versions.node) {
+        if (isNode) {
           const fs = await import("fs");
-          const wasmBytes = await fs.promises.readFile(wasmPath);
-          await UltraHdrWasm.default(wasmBytes);
+          const wasmBytes = await fs.promises.readFile(joinPath(location, WASM_FILENAME));
+          moduleOptions.wasmBinary = new Uint8Array(wasmBytes);
         } else {
-          await UltraHdrWasm.default(wasmPath);
+          moduleOptions.locateFile = (path) => path.endsWith(".wasm") ? joinPath(location, WASM_FILENAME) : path;
         }
-      } else {
-        await UltraHdrWasm.default();
       }
-      wasmInstance = UltraHdrWasm;
-      return wasmInstance;
+      const instance = await factory(moduleOptions);
+      if (generation !== initGeneration) {
+        return getWasm();
+      }
+      wasmInstance = instance;
+      return instance;
     } catch (err) {
-      initPromise = null;
+      if (generation === initGeneration) {
+        initPromise = null;
+      }
       throw err;
     }
   })();
@@ -107,27 +103,35 @@ async function isUltraHdr(buffer) {
   return wasm.isUltraHdr(new Uint8Array(buffer));
 }
 async function probeUltraHdr(buffer) {
-  const wasm = await getWasm();
-  return wasm.probeUltraHdr(new Uint8Array(buffer));
+  try {
+    const wasm = await getWasm();
+    return wasm.probeUltraHdr(new Uint8Array(buffer));
+  } catch {
+    return {
+      isValid: false,
+      hasPrimaryImage: false,
+      hasGainMap: false,
+      hasMetadata: false,
+      width: 0,
+      height: 0,
+      gainMapWidth: 0,
+      gainMapHeight: 0,
+      hdrCapacity: 0,
+      metadataVersion: ""
+    };
+  }
 }
-async function decodeUltraHdr(id, buffer) {
+async function decodeUltraHdr(_id, buffer) {
   const wasm = await getWasm();
   return wasm.decodeUltraHdr(new Uint8Array(buffer));
 }
-async function encodeUltraHdr(id, sdrBuffer, hdrBuffer, options) {
+async function encodeUltraHdr(_id, sdrBuffer, hdrBuffer, options) {
   const wasm = await getWasm();
-  const wasmOpts = wasm.createDefaultOptions();
-  const mergedOpts = { ...defaultEncodeOptions, ...options };
-  wasmOpts.baseQuality = mergedOpts.baseQuality;
-  wasmOpts.gainMapQuality = mergedOpts.gainMapQuality;
-  wasmOpts.targetHdrCapacity = mergedOpts.targetHdrCapacity;
-  wasmOpts.includeIsoMetadata = mergedOpts.includeIsoMetadata;
-  wasmOpts.includeUltrahdrV1 = mergedOpts.includeUltrahdrV1;
-  wasmOpts.gainMapScale = mergedOpts.gainMapScale;
+  const merged = { ...defaultEncodeOptions, ...options };
   const result = wasm.encodeUltraHdr(
     new Uint8Array(sdrBuffer),
     new Float32Array(hdrBuffer),
-    wasmOpts
+    merged
   );
   return result.buffer.slice(
     result.byteOffset,
@@ -148,18 +152,15 @@ async function getMetadata(buffer) {
 }
 async function validateMetadata(metadata) {
   const wasm = await getWasm();
-  const wasmMetadata = await toWasmMetadata(metadata);
-  return wasm.validateMetadata(wasmMetadata);
+  return wasm.validateMetadata(metadata);
 }
 async function estimateHdrHeadroom(metadata) {
   const wasm = await getWasm();
-  const wasmMetadata = await toWasmMetadata(metadata);
-  return wasm.estimateHdrHeadroom(wasmMetadata);
+  return wasm.estimateHdrHeadroom(metadata);
 }
 async function isMeaningfulHdr(metadata) {
   const wasm = await getWasm();
-  const wasmMetadata = await toWasmMetadata(metadata);
-  return wasm.isMeaningfulHdr(wasmMetadata);
+  return wasm.isMeaningfulHdr(metadata);
 }
 export {
   ColorGamut,

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "open-ultrahdr",
-	"version": "0.1.2",
-	"description": "UltraHDR (ISO 21496-1) gain map support for JavaScript/TypeScript",
+	"version": "0.2.0",
+	"description": "UltraHDR (ISO 21496-1) gain map support for JavaScript/TypeScript, backed by upstream libultrahdr",
 	"author": "Adam Silverstein",
-	"license": "GPL-2.0-or-later",
+	"license": "Apache-2.0 OR MIT",
 	"keywords": [
 		"ultrahdr",
 		"hdr",
@@ -52,7 +52,7 @@
 		"lint:fix": "eslint src __tests__ --fix"
 	},
 	"dependencies": {
-		"open-ultrahdr-wasm": "^0.1.2"
+		"open-ultrahdr-wasm": "^0.2.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.0.0",