hdr-canvas 0.1.0 → 0.1.2

package/dist/hdr-canvas.js

@@ -5902,6 +5902,283 @@ class Uint16Image extends HDRImage {
     }
 }
 
+/* eslint-disable no-restricted-globals, no-restricted-syntax */
+/* global SharedArrayBuffer */
+
+
+/** @type {<T extends (...args: any) => any>(target: T) => (thisArg: ThisType<T>, ...args: any[]) => any} */
+function uncurryThis(target) {
+  return (thisArg, ...args) => {
+    return ReflectApply(target, thisArg, args);
+  };
+}
+
+/** @type {(target: any, key: string | symbol) => (thisArg: any, ...args: any[]) => any} */
+function uncurryThisGetter(target, key) {
+  return uncurryThis(
+    ReflectGetOwnPropertyDescriptor(
+      target,
+      key
+    ).get
+  );
+}
+
+// Reflect
+const {
+  apply: ReflectApply,
+  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
+  getPrototypeOf: ReflectGetPrototypeOf} = Reflect;
+
+// Number
+const {
+  EPSILON,
+  isFinite: NumberIsFinite,
+  isNaN: NumberIsNaN,
+} = Number;
+
+// Symbol
+const {
+  iterator: SymbolIterator,
+  toStringTag: SymbolToStringTag} = Symbol;
+
+// Math
+const {
+  abs: MathAbs} = Math;
+
+// ArrayBuffer
+const NativeArrayBuffer = ArrayBuffer;
+const ArrayBufferPrototype = NativeArrayBuffer.prototype;
+/** @type {(buffer: ArrayBuffer) => ArrayBuffer} */
+uncurryThisGetter(ArrayBufferPrototype, "byteLength");
+
+// SharedArrayBuffer
+const NativeSharedArrayBuffer = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : null;
+/** @type {(buffer: SharedArrayBuffer) => SharedArrayBuffer} */
+NativeSharedArrayBuffer
+  && uncurryThisGetter(NativeSharedArrayBuffer.prototype, "byteLength");
+
+// TypedArray
+/** @typedef {Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array|BigUint64Array|BigInt64Array} TypedArray */
+/** @type {any} */
+const TypedArray = ReflectGetPrototypeOf(Uint8Array);
+TypedArray.from;
+const TypedArrayPrototype = TypedArray.prototype;
+TypedArrayPrototype[SymbolIterator];
+/** @type {(typedArray: TypedArray) => IterableIterator<number>} */
+uncurryThis(TypedArrayPrototype.keys);
+/** @type {(typedArray: TypedArray) => IterableIterator<number>} */
+uncurryThis(
+  TypedArrayPrototype.values
+);
+/** @type {(typedArray: TypedArray) => IterableIterator<[number, number]>} */
+uncurryThis(
+  TypedArrayPrototype.entries
+);
+/** @type {(typedArray: TypedArray, array: ArrayLike<number>, offset?: number) => void} */
+uncurryThis(TypedArrayPrototype.set);
+/** @type {<T extends TypedArray>(typedArray: T) => T} */
+uncurryThis(
+  TypedArrayPrototype.reverse
+);
+/** @type {<T extends TypedArray>(typedArray: T, value: number, start?: number, end?: number) => T} */
+uncurryThis(TypedArrayPrototype.fill);
+/** @type {<T extends TypedArray>(typedArray: T, target: number, start: number, end?: number) => T} */
+uncurryThis(
+  TypedArrayPrototype.copyWithin
+);
+/** @type {<T extends TypedArray>(typedArray: T, compareFn?: (a: number, b: number) => number) => T} */
+uncurryThis(TypedArrayPrototype.sort);
+/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */
+uncurryThis(TypedArrayPrototype.slice);
+/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */
+uncurryThis(
+  TypedArrayPrototype.subarray
+);
+/** @type {((typedArray: TypedArray) => ArrayBuffer)} */
+uncurryThisGetter(
+  TypedArrayPrototype,
+  "buffer"
+);
+/** @type {((typedArray: TypedArray) => number)} */
+uncurryThisGetter(
+  TypedArrayPrototype,
+  "byteOffset"
+);
+/** @type {((typedArray: TypedArray) => number)} */
+uncurryThisGetter(
+  TypedArrayPrototype,
+  "length"
+);
+/** @type {(target: unknown) => string} */
+uncurryThisGetter(
+  TypedArrayPrototype,
+  SymbolToStringTag
+);
+
+// Uint8Array
+const NativeUint8Array = Uint8Array;
+
+// Uint16Array
+const NativeUint16Array = Uint16Array;
+
+// Uint32Array
+const NativeUint32Array = Uint32Array;
+
+// ArrayIterator
+/** @type {any} */
+const ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());
+/** @type {<T>(arrayIterator: IterableIterator<T>) => IteratorResult<T>} */
+uncurryThis(ArrayIteratorPrototype.next);
+
+// Generator
+/** @type {<T = unknown, TReturn = any, TNext = unknown>(generator: Generator<T, TReturn, TNext>, value?: TNext) => T} */
+uncurryThis((function* () {})().next);
+
+// Iterator
+ReflectGetPrototypeOf(ArrayIteratorPrototype);
+
+const INVERSE_OF_EPSILON = 1 / EPSILON;
+
+/**
+ * rounds to the nearest value;
+ * if the number falls midway, it is rounded to the nearest value with an even least significant digit
+ * @param {number} num
+ * @returns {number}
+ */
+function roundTiesToEven(num) {
+  return (num + INVERSE_OF_EPSILON) - INVERSE_OF_EPSILON;
+}
+
+const FLOAT16_MIN_VALUE = 6.103515625e-05;
+const FLOAT16_MAX_VALUE = 65504;
+const FLOAT16_EPSILON = 0.0009765625;
+
+const FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE = FLOAT16_EPSILON * FLOAT16_MIN_VALUE;
+const FLOAT16_EPSILON_DEVIDED_BY_EPSILON = FLOAT16_EPSILON * INVERSE_OF_EPSILON;
+
+/**
+ * round a number to a half float number
+ * @param {unknown} num - double float
+ * @returns {number} half float number
+ */
+function roundToFloat16(num) {
+  const number = +num;
+
+  // NaN, Infinity, -Infinity, 0, -0
+  if (!NumberIsFinite(number) || number === 0) {
+    return number;
+  }
+
+  // finite except 0, -0
+  const sign = number > 0 ? 1 : -1;
+  const absolute = MathAbs(number);
+
+  // small number
+  if (absolute < FLOAT16_MIN_VALUE) {
+    return sign * roundTiesToEven(absolute / FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE) * FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE;
+  }
+
+  const temp = (1 + FLOAT16_EPSILON_DEVIDED_BY_EPSILON) * absolute;
+  const result = temp - (temp - absolute);
+
+  // large number
+  if (result > FLOAT16_MAX_VALUE || NumberIsNaN(result)) {
+    return sign * Infinity;
+  }
+
+  return sign * result;
+}
+
+const baseTable = new NativeUint16Array(512);
+const shiftTable = new NativeUint8Array(512);
+
+for (let i = 0; i < 256; ++i) {
+  const e = i - 127;
+
+  // very small number (0, -0)
+  if (e < -24) {
+    baseTable[i]         = 0x0000;
+    baseTable[i | 0x100] = 0x8000;
+    shiftTable[i]         = 24;
+    shiftTable[i | 0x100] = 24;
+
+  // small number (denorm)
+  } else if (e < -14) {
+    baseTable[i]         =  0x0400 >> (-e - 14);
+    baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
+    shiftTable[i]         = -e - 1;
+    shiftTable[i | 0x100] = -e - 1;
+
+  // normal number
+  } else if (e <= 15) {
+    baseTable[i]         =  (e + 15) << 10;
+    baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;
+    shiftTable[i]         = 13;
+    shiftTable[i | 0x100] = 13;
+
+  // large number (Infinity, -Infinity)
+  } else if (e < 128) {
+    baseTable[i]         = 0x7c00;
+    baseTable[i | 0x100] = 0xfc00;
+    shiftTable[i]         = 24;
+    shiftTable[i | 0x100] = 24;
+
+  // stay (NaN, Infinity, -Infinity)
+  } else {
+    baseTable[i]         = 0x7c00;
+    baseTable[i | 0x100] = 0xfc00;
+    shiftTable[i]         = 13;
+    shiftTable[i | 0x100] = 13;
+  }
+}
+
+const mantissaTable = new NativeUint32Array(2048);
+for (let i = 1; i < 1024; ++i) {
+  let m = i << 13; // zero pad mantissa bits
+  let e = 0; // zero exponent
+
+  // normalized
+  while ((m & 0x00800000) === 0) {
+    m <<= 1;
+    e -= 0x00800000; // decrement exponent
+  }
+
+  m &= -8388609; // clear leading 1 bit
+  e += 0x38800000; // adjust bias
+
+  mantissaTable[i] = m | e;
+}
+for (let i = 1024; i < 2048; ++i) {
+  mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);
+}
+
+const exponentTable = new NativeUint32Array(64);
+for (let i = 1; i < 31; ++i) {
+  exponentTable[i] = i << 23;
+}
+exponentTable[31] = 0x47800000;
+exponentTable[32] = 0x80000000;
+for (let i = 33; i < 63; ++i) {
+  exponentTable[i] = 0x80000000 + ((i - 32) << 23);
+}
+exponentTable[63] = 0xc7800000;
+
+const offsetTable = new NativeUint16Array(64);
+for (let i = 1; i < 64; ++i) {
+  if (i !== 32) {
+    offsetTable[i] = 1024;
+  }
+}
+
+/**
+ * returns the nearest half-precision float representation of a number
+ * @param {number} x
+ * @returns {number}
+ */
+function f16round(x) {
+  return roundToFloat16(x);
+}
+
 class Float16Image extends HDRImage {
     data;
     static DEFAULT_PIXELFORMAT = "rgba-float16";
@@ -5958,17 +6235,17 @@ class Float16Image extends HDRImage {
         return Float16Array.from(hlg);
     }
     static convertArrayToRec2100_hlg(data) {
-        const uint16Data = new Float16Array(data.length);
-        for (let i = 0; i < data.length; i += 4) {
-            const rgbPixel = data.slice(i, i + 4);
-            const pixel = Float16Image.convertPixelToRec2100_hlg(rgbPixel);
-            uint16Data.set(pixel, i);
+        const float16Array = new Float16Array(data.length);
+        for (let i = 0; i < data.length; i++) {
+            const normalizedFloat = data[i] / 255.0;
+            float16Array[i] = f16round(normalizedFloat);
         }
-        return uint16Data;
+        return float16Array;
     }
     pixelCallback(fn) {
         for (let i = 0; i < this.data.length; i += 4) {
-            this.data.set(fn(this.data[i], this.data[i + 1], this.data[i + 2], this.data[i + 3]), i);
+            const pixel = fn(this.data[i], this.data[i + 1], this.data[i + 2], this.data[i + 3]);
+            this.data.set(pixel, i);
         }
     }
     static fromImageData(imageData) {
@@ -6034,6 +6311,7 @@ function getHdrOptions() {
     if (browserMajorVersion == null) {
         console.warn(`Unsupported / untested browser (${navigator.userAgent}) detected - using more modern defaults`);
         hdrOptions["colorType"] = "float16";
+        hdrOptions["toneMapping"] = { mode: "extended" };
     }
     else {
         if (browserMajorVersion < 134) {
@@ -6046,7 +6324,10 @@ function getHdrOptions() {
     return hdrOptions;
 }
 function initHDRCanvas(canvas) {
-    canvas.configureHighDynamicRange({ mode: "extended" });
+    const browserMajorVersion = getBrowserVersion();
+    if (browserMajorVersion !== null && browserMajorVersion < 134) {
+        canvas.configureHighDynamicRange({ mode: "extended" });
+    }
     const ctx = canvas.getContext("2d", getHdrOptions());
     return ctx;
 }