geedback

geedback_dsp.js (7260B)

---

 /* @ts-self-types="./geedback_dsp.d.ts" */
 
 export class GeedbackProcessor {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         GeedbackProcessorFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_geedbackprocessor_free(ptr, 0);
     }
     /**
      * @returns {number}
      */
     get_latest_output() {
         const ret = wasm.geedbackprocessor_get_latest_output(this.__wbg_ptr);
         return ret;
     }
     constructor() {
         const ret = wasm.geedbackprocessor_new();
         this.__wbg_ptr = ret;
         GeedbackProcessorFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
      * @returns {number}
      */
     process() {
         const ret = wasm.geedbackprocessor_process(this.__wbg_ptr);
         return ret;
     }
     /**
      * @param {number} x
      * @param {number} y
      * @param {number} z
      */
     set_linear_accel(x, y, z) {
         wasm.geedbackprocessor_set_linear_accel(this.__wbg_ptr, x, y, z);
     }
     /**
      * @param {number} a
      * @param {number} b
      * @param {number} g
      */
     set_orient(a, b, g) {
         wasm.geedbackprocessor_set_orient(this.__wbg_ptr, a, b, g);
     }
     /**
      * @param {number} sample_rate
      */
     set_sample_rate(sample_rate) {
         wasm.geedbackprocessor_set_sample_rate(this.__wbg_ptr, sample_rate);
     }
     /**
      * @param {number} x
      * @param {number} y
      */
     set_touch(x, y) {
         wasm.geedbackprocessor_set_touch(this.__wbg_ptr, x, y);
     }
     /**
      * @param {number} index
      * @param {Waveform} wave
      */
     set_waveform(index, wave) {
         wasm.geedbackprocessor_set_waveform(this.__wbg_ptr, index, wave);
     }
 }
 if (Symbol.dispose) GeedbackProcessor.prototype[Symbol.dispose] = GeedbackProcessor.prototype.free;
 
 /**
  * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
  */
 export const Waveform = Object.freeze({
     Sine: 0, "0": "Sine",
     Triangle: 1, "1": "Triangle",
     TriangleSawtooth: 2, "2": "TriangleSawtooth",
     Sawtooth: 3, "3": "Sawtooth",
     ReverseSawtooth: 4, "4": "ReverseSawtooth",
     Square: 5, "5": "Square",
     WidePulse: 6, "6": "WidePulse",
     NarrowPulse: 7, "7": "NarrowPulse",
 });
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
         __wbg___wbindgen_throw_9c75d47bf9e7731e: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
             table.set(0, undefined);
             table.set(offset + 0, undefined);
             table.set(offset + 1, null);
             table.set(offset + 2, true);
             table.set(offset + 3, false);
         },
     };
     return {
         __proto__: null,
         "./geedback_dsp_bg.js": import0,
     };
 }
 
 const GeedbackProcessorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_geedbackprocessor_free(ptr, 1));
 
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
         cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
     return cachedUint8ArrayMemory0;
 }
 
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
 let numBytesDecoded = 0;
 function decodeText(ptr, len) {
     numBytesDecoded += len;
     if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
         cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
         cachedTextDecoder.decode();
         numBytesDecoded = len;
     }
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
 let wasmModule, wasmInstance, wasm;
 function __wbg_finalize_init(instance, module) {
     wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();
     return wasm;
 }
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
             } catch (e) {
                 const validResponse = module.ok && expectedResponseType(module.type);
 
                 if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
 
                 } else { throw e; }
             }
         }
 
         const bytes = await module.arrayBuffer();
         return await WebAssembly.instantiate(bytes, imports);
     } else {
         const instance = await WebAssembly.instantiate(module, imports);
 
         if (instance instanceof WebAssembly.Instance) {
             return { instance, module };
         } else {
             return instance;
         }
     }
 
     function expectedResponseType(type) {
         switch (type) {
             case 'basic': case 'cors': case 'default': return true;
         }
         return false;
     }
 }
 
 function initSync(module) {
     if (wasm !== undefined) return wasm;
 
 
     if (module !== undefined) {
         if (Object.getPrototypeOf(module) === Object.prototype) {
             ({module} = module)
         } else {
             console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
         }
     }
 
     const imports = __wbg_get_imports();
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
     const instance = new WebAssembly.Instance(module, imports);
     return __wbg_finalize_init(instance, module);
 }
 
 async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
 
 
     if (module_or_path !== undefined) {
         if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
             ({module_or_path} = module_or_path)
         } else {
             console.warn('using deprecated parameters for the initialization function; pass a single object instead')
         }
     }
 
     if (module_or_path === undefined) {
         module_or_path = new URL('geedback_dsp_bg.wasm', import.meta.url);
     }
     const imports = __wbg_get_imports();
 
     if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
         module_or_path = fetch(module_or_path);
     }
 
     const { instance, module } = await __wbg_load(await module_or_path, imports);
 
     return __wbg_finalize_init(instance, module);
 }
 
 export { initSync, __wbg_init as default };