hdr-canvas 0.1.1 → 0.1.2

package/dist/hdr-canvas.umd.js

@@ -5908,6 +5908,283 @@
         }
     }
 
+    /* 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";
@@ -5964,17 +6241,17 @@
             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) {
@@ -6040,6 +6317,7 @@
         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) {
@@ -6052,7 +6330,10 @@
         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;
     }