@grame/faustwasm 0.12.2 → 0.13.0

package/src/FaustSvgDiagrams.ts

@@ -1,4 +1,4 @@
-import type FaustCompiler from "./FaustCompiler";
+import type FaustCompiler from './FaustCompiler';
 
 interface IFaustSvgDiagrams {
     /**
@@ -23,13 +23,26 @@ class FaustSvgDiagrams implements IFaustSvgDiagrams {
         const fs = this.compiler.fs();
         try {
             const files: string[] = fs.readdir(`/${name}-svg/`);
-            files.filter(file => file !== "." && file !== "..").forEach(file => fs.unlink(`/${name}-svg/${file}`));
-        } catch { }
-        const success = this.compiler.generateAuxFiles(name, code, `-lang wasm -o binary -svg ${args}`);
+            files
+                .filter((file) => file !== '.' && file !== '..')
+                .forEach((file) => fs.unlink(`/${name}-svg/${file}`));
+        } catch {}
+        const success = this.compiler.generateAuxFiles(
+            name,
+            code,
+            `-lang wasm -o binary -svg ${args}`
+        );
         if (!success) throw new Error(this.compiler.getErrorMessage());
         const svgs: Record<string, string> = {};
         const files: string[] = fs.readdir(`/${name}-svg/`);
-        files.filter(file => file !== "." && file !== "..").forEach(file => svgs[file] = fs.readFile(`/${name}-svg/${file}`, { encoding: "utf8" }) as string);
+        files
+            .filter((file) => file !== '.' && file !== '..')
+            .forEach(
+                (file) =>
+                    (svgs[file] = fs.readFile(`/${name}-svg/${file}`, {
+                        encoding: 'utf8'
+                    }) as string)
+            );
         return svgs;
     }
 }

package/src/FaustWasmInstantiator.ts

@@ -1,5 +1,15 @@
-import { FaustDspInstance, FaustMonoDspInstance, FaustPolyDspInstance, IFaustDspInstance, IFaustMixerInstance } from "./FaustDspInstance";
-import type { FaustDspFactory, FaustDspMeta, LooseFaustDspFactory } from "./types";
+import {
+    FaustDspInstance,
+    FaustMonoDspInstance,
+    FaustPolyDspInstance,
+    IFaustDspInstance,
+    IFaustMixerInstance
+} from './FaustDspInstance';
+import type {
+    FaustDspFactory,
+    FaustDspMeta,
+    LooseFaustDspFactory
+} from './types';
 
 class FaustWasmInstantiator {
     private static createWasmImport(memory?: WebAssembly.Memory) {
@@ -11,92 +21,172 @@ class FaustWasmInstantiator {
                 // Integer version
                 _abs: Math.abs,
                 // Float version
-                _acosf: Math.acos, _asinf: Math.asin, _atanf: Math.atan, _atan2f: Math.atan2,
-                _ceilf: Math.ceil, _cosf: Math.cos, _expf: Math.exp, _floorf: Math.floor,
+                _acosf: Math.acos,
+                _asinf: Math.asin,
+                _atanf: Math.atan,
+                _atan2f: Math.atan2,
+                _ceilf: Math.ceil,
+                _cosf: Math.cos,
+                _expf: Math.exp,
+                _floorf: Math.floor,
                 _fmodf: (x: number, y: number) => x % y,
-                _logf: Math.log, _log10f: Math.log10, _max_f: Math.max, _min_f: Math.min,
-                _remainderf: (x: number, y: number) => x - Math.round(x / y) * y,
-                _powf: Math.pow, _roundf: Math.round, _sinf: Math.sin, _sqrtf: Math.sqrt, _tanf: Math.tan,
-                _acoshf: Math.acosh, _asinhf: Math.asinh, _atanhf: Math.atanh,
-                _coshf: Math.cosh, _sinhf: Math.sinh, _tanhf: Math.tanh,
-                _isnanf: Number.isNaN, _isinff: (x: number) => !isFinite(x),
-                _copysignf: (x: number, y: number) => (Math.sign(x) === Math.sign(y) ? x : -x),
+                _logf: Math.log,
+                _log10f: Math.log10,
+                _max_f: Math.max,
+                _min_f: Math.min,
+                _remainderf: (x: number, y: number) =>
+                    x - Math.round(x / y) * y,
+                _powf: Math.pow,
+                _roundf: Math.round,
+                _sinf: Math.sin,
+                _sqrtf: Math.sqrt,
+                _tanf: Math.tan,
+                _acoshf: Math.acosh,
+                _asinhf: Math.asinh,
+                _atanhf: Math.atanh,
+                _coshf: Math.cosh,
+                _sinhf: Math.sinh,
+                _tanhf: Math.tanh,
+                _isnanf: Number.isNaN,
+                _isinff: (x: number) => !isFinite(x),
+                _copysignf: (x: number, y: number) =>
+                    Math.sign(x) === Math.sign(y) ? x : -x,
 
                 // Double version
-                _acos: Math.acos, _asin: Math.asin, _atan: Math.atan, _atan2: Math.atan2,
-                _ceil: Math.ceil, _cos: Math.cos, _exp: Math.exp, _floor: Math.floor,
+                _acos: Math.acos,
+                _asin: Math.asin,
+                _atan: Math.atan,
+                _atan2: Math.atan2,
+                _ceil: Math.ceil,
+                _cos: Math.cos,
+                _exp: Math.exp,
+                _floor: Math.floor,
                 _fmod: (x: number, y: number) => x % y,
-                _log: Math.log, _log10: Math.log10, _max_: Math.max, _min_: Math.min,
+                _log: Math.log,
+                _log10: Math.log10,
+                _max_: Math.max,
+                _min_: Math.min,
                 _remainder: (x: number, y: number) => x - Math.round(x / y) * y,
-                _pow: Math.pow, _round: Math.round, _sin: Math.sin, _sqrt: Math.sqrt, _tan: Math.tan,
-                _acosh: Math.acosh, _asinh: Math.asinh, _atanh: Math.atanh,
-                _cosh: Math.cosh, _sinh: Math.sinh, _tanh: Math.tanh,
-                _isnan: Number.isNaN, _isinf: (x: number) => !isFinite(x),
-                _copysign: (x: number, y: number) => (Math.sign(x) === Math.sign(y) ? x : -x),
+                _pow: Math.pow,
+                _round: Math.round,
+                _sin: Math.sin,
+                _sqrt: Math.sqrt,
+                _tan: Math.tan,
+                _acosh: Math.acosh,
+                _asinh: Math.asinh,
+                _atanh: Math.atanh,
+                _cosh: Math.cosh,
+                _sinh: Math.sinh,
+                _tanh: Math.tanh,
+                _isnan: Number.isNaN,
+                _isinf: (x: number) => !isFinite(x),
+                _copysign: (x: number, y: number) =>
+                    Math.sign(x) === Math.sign(y) ? x : -x,
 
-                table: new WebAssembly.Table({ initial: 0, element: "anyfunc" })
+                table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' })
             }
         };
     }
-    private static createWasmMemoryPoly(voicesIn: number, sampleSize: number, dspMeta: FaustDspMeta, effectMeta: FaustDspMeta, bufferSize: number) {
+    private static createWasmMemoryPoly(
+        voicesIn: number,
+        sampleSize: number,
+        dspMeta: FaustDspMeta,
+        effectMeta: FaustDspMeta,
+        bufferSize: number
+    ) {
         // Hack : at least 4 voices (to avoid weird wasm memory bug?)
         const voices = Math.max(4, voicesIn);
         // Memory allocator
         const ptrSize = sampleSize; // Done on wast/wasm backend side
         const pow2limit = (x: number) => {
             let n = 65536; // Minimum = 64 kB
-            while (n < x) { n *= 2; }
+            while (n < x) {
+                n *= 2;
+            }
             return n;
         };
         const effectSize = effectMeta ? effectMeta.size : 0;
-        let memorySize = pow2limit(
-            effectSize
-            + dspMeta.size * voices
-            + (dspMeta.inputs + dspMeta.outputs * 2)  // + 2 for effect
-            * (ptrSize + bufferSize * sampleSize)
-        ) / 65536;
+        let memorySize =
+            pow2limit(
+                effectSize +
+                    dspMeta.size * voices +
+                    (dspMeta.inputs + dspMeta.outputs * 2) * // + 2 for effect
+                        (ptrSize + bufferSize * sampleSize)
+            ) / 65536;
         memorySize = Math.max(2, memorySize); // At least 2
         return new WebAssembly.Memory({ initial: memorySize });
-    };
+    }
 
-    private static createWasmMemoryMono(sampleSize: number, dspMeta: FaustDspMeta, bufferSize: number) {
+    private static createWasmMemoryMono(
+        sampleSize: number,
+        dspMeta: FaustDspMeta,
+        bufferSize: number
+    ) {
         // Memory allocator
         const ptrSize = sampleSize; // Done on wast/wasm backend side
-        const memorySize = (dspMeta.size + (dspMeta.inputs + dspMeta.outputs) * (ptrSize + bufferSize * sampleSize)) / 65536;
+        const memorySize =
+            (dspMeta.size +
+                (dspMeta.inputs + dspMeta.outputs) *
+                    (ptrSize + bufferSize * sampleSize)) /
+            65536;
         return new WebAssembly.Memory({ initial: memorySize * 2 }); // Safer to have a bit more memory
     }
 
-    private static createMonoDSPInstanceAux(instance: WebAssembly.Instance, json: string, mem: WebAssembly.Memory | null = null) {
-        const functions = instance.exports as IFaustDspInstance & WebAssembly.Exports;
+    private static createMonoDSPInstanceAux(
+        instance: WebAssembly.Instance,
+        json: string,
+        mem: WebAssembly.Memory | null = null
+    ) {
+        const functions = instance.exports as IFaustDspInstance &
+            WebAssembly.Exports;
         const api = new FaustDspInstance(functions);
-        const memory: any = (mem) ? mem : instance.exports.memory;
+        const memory: any = mem ? mem : instance.exports.memory;
         return { memory, api, json } as FaustMonoDspInstance;
     }
 
     private static createMemoryMono(monoFactory: LooseFaustDspFactory) {
         // Parse JSON to get 'size' and 'inputs/outputs' infos
         const monoMeta: FaustDspMeta = JSON.parse(monoFactory.json);
-        const sampleSize = monoMeta.compile_options.match("-double") ? 8 : 4;
+        const sampleSize = monoMeta.compile_options.match('-double') ? 8 : 4;
         return this.createWasmMemoryMono(sampleSize, monoMeta, 8192);
-
     }
-    private static createMemoryPoly(voices: number, voiceFactory: LooseFaustDspFactory, effectFactory?: LooseFaustDspFactory) {
+    private static createMemoryPoly(
+        voices: number,
+        voiceFactory: LooseFaustDspFactory,
+        effectFactory?: LooseFaustDspFactory
+    ) {
         // Parse JSON to get 'size' and 'inputs/outputs' infos
         const voiceMeta: FaustDspMeta = JSON.parse(voiceFactory.json);
-        const effectMeta: FaustDspMeta = (effectFactory && effectFactory.json) ? JSON.parse(effectFactory.json) : null;
-        const sampleSize = voiceMeta.compile_options.match("-double") ? 8 : 4;
+        const effectMeta: FaustDspMeta =
+            effectFactory && effectFactory.json
+                ? JSON.parse(effectFactory.json)
+                : null;
+        const sampleSize = voiceMeta.compile_options.match('-double') ? 8 : 4;
         // Memory will be shared by voice, mixer and (possibly) effect instances
-        return this.createWasmMemoryPoly(voices, sampleSize, voiceMeta, effectMeta, 8192);
+        return this.createWasmMemoryPoly(
+            voices,
+            sampleSize,
+            voiceMeta,
+            effectMeta,
+            8192
+        );
     }
 
-    private static createMixerAux(mixerModule: WebAssembly.Module, memory: WebAssembly.Memory) {
+    private static createMixerAux(
+        mixerModule: WebAssembly.Module,
+        memory: WebAssembly.Memory
+    ) {
         // Create mixer instance
         const mixerImport = {
             imports: { print: console.log },
             memory: { memory }
         };
-        const mixerInstance = new WebAssembly.Instance(mixerModule, mixerImport);
-        const mixerFunctions = mixerInstance.exports as IFaustMixerInstance & WebAssembly.Exports;
+        const mixerInstance = new WebAssembly.Instance(
+            mixerModule,
+            mixerImport
+        );
+        const mixerFunctions = mixerInstance.exports as IFaustMixerInstance &
+            WebAssembly.Exports;
         return mixerFunctions;
     }
 
@@ -104,7 +194,9 @@ class FaustWasmInstantiator {
     static async loadDSPFactory(wasmPath: string, jsonPath: string) {
         const wasmFile = await fetch(wasmPath);
         if (!wasmFile.ok) {
-            throw new Error(`=> exception raised while running loadDSPFactory, file not found: ${wasmPath}`);
+            throw new Error(
+                `=> exception raised while running loadDSPFactory, file not found: ${wasmPath}`
+            );
         }
         try {
             const wasmBuffer = await wasmFile.arrayBuffer();
@@ -114,7 +206,13 @@ class FaustWasmInstantiator {
             const meta: FaustDspMeta = JSON.parse(json);
             const cOptions = meta.compile_options;
             const poly = cOptions.indexOf('wasm-e') !== -1;
-            return { cfactory: 0, code: new Uint8Array(wasmBuffer), module, json, poly } as FaustDspFactory;
+            return {
+                cfactory: 0,
+                code: new Uint8Array(wasmBuffer),
+                module,
+                json,
+                poly
+            } as FaustDspFactory;
         } catch (e) {
             // console.error(`=> exception raised while running loadDSPFactory: ${e}`);
             throw e;
@@ -125,7 +223,9 @@ class FaustWasmInstantiator {
         try {
             let mixerBuffer: BufferSource | null = null;
             if (fs) {
-                mixerBuffer = new Uint8Array(fs.readFile(mixerPath, { encoding: "binary" }));
+                mixerBuffer = new Uint8Array(
+                    fs.readFile(mixerPath, { encoding: 'binary' })
+                );
             } else {
                 const mixerFile = await fetch(mixerPath);
                 mixerBuffer = await mixerFile.arrayBuffer();
@@ -139,7 +239,6 @@ class FaustWasmInstantiator {
     }
 
     static async createAsyncMonoDSPInstance(factory: LooseFaustDspFactory) {
-
         // Regular expression to match the 'type: soundfile' pattern
         const pattern = /"type":\s*"soundfile"/;
         // Check if the pattern exists in the JSON string
@@ -147,17 +246,26 @@ class FaustWasmInstantiator {
 
         if (isDetected) {
             const memory = this.createMemoryMono(factory);
-            const instance = await WebAssembly.instantiate(factory.module, this.createWasmImport(memory));
-            return this.createMonoDSPInstanceAux(instance, factory.json, memory);
+            const instance = await WebAssembly.instantiate(
+                factory.module,
+                this.createWasmImport(memory)
+            );
+            return this.createMonoDSPInstanceAux(
+                instance,
+                factory.json,
+                memory
+            );
         } else {
             // Otherwise, we can create the instance using the wasm internal memory allocated by the wasm module
-            const instance = await WebAssembly.instantiate(factory.module, this.createWasmImport());
+            const instance = await WebAssembly.instantiate(
+                factory.module,
+                this.createWasmImport()
+            );
             return this.createMonoDSPInstanceAux(instance, factory.json);
         }
     }
 
     static createSyncMonoDSPInstance(factory: LooseFaustDspFactory) {
-
         // Regular expression to match the 'type: soundfile' pattern
         const pattern = /"type":\s*"soundfile"/;
         // Check if the pattern exists in the JSON string
@@ -166,28 +274,56 @@ class FaustWasmInstantiator {
         // If the JSON contains a soundfile UI element, we need to create a memory object
         if (isDetected) {
             const memory = this.createMemoryMono(factory);
-            const instance = new WebAssembly.Instance(factory.module, this.createWasmImport(memory));
-            return this.createMonoDSPInstanceAux(instance, factory.json, memory);
+            const instance = new WebAssembly.Instance(
+                factory.module,
+                this.createWasmImport(memory)
+            );
+            return this.createMonoDSPInstanceAux(
+                instance,
+                factory.json,
+                memory
+            );
         } else {
             // Otherwise, we can create the instance using the wasm internal memory allocated by the wasm module
-            const instance = new WebAssembly.Instance(factory.module, this.createWasmImport());
+            const instance = new WebAssembly.Instance(
+                factory.module,
+                this.createWasmImport()
+            );
             return this.createMonoDSPInstanceAux(instance, factory.json);
         }
     }
 
-    static async createAsyncPolyDSPInstance(voiceFactory: LooseFaustDspFactory, mixerModule: WebAssembly.Module, voices: number, effectFactory?: LooseFaustDspFactory): Promise<FaustPolyDspInstance> {
-        const memory = this.createMemoryPoly(voices, voiceFactory, effectFactory);
-        // Create voice 
-        const voiceInstance = await WebAssembly.instantiate(voiceFactory.module, this.createWasmImport(memory));
-        const voiceFunctions = voiceInstance.exports as IFaustDspInstance & WebAssembly.Exports;
+    static async createAsyncPolyDSPInstance(
+        voiceFactory: LooseFaustDspFactory,
+        mixerModule: WebAssembly.Module,
+        voices: number,
+        effectFactory?: LooseFaustDspFactory
+    ): Promise<FaustPolyDspInstance> {
+        const memory = this.createMemoryPoly(
+            voices,
+            voiceFactory,
+            effectFactory
+        );
+        // Create voice
+        const voiceInstance = await WebAssembly.instantiate(
+            voiceFactory.module,
+            this.createWasmImport(memory)
+        );
+        const voiceFunctions = voiceInstance.exports as IFaustDspInstance &
+            WebAssembly.Exports;
         const voiceAPI = new FaustDspInstance(voiceFunctions);
         // Create mixer
         const mixerAPI = this.createMixerAux(mixerModule, memory);
 
-        // Possibly create effect instance 
+        // Possibly create effect instance
         if (effectFactory) {
-            const effectInstance = await WebAssembly.instantiate(effectFactory.module, this.createWasmImport(memory));
-            const effectFunctions = effectInstance.exports as IFaustDspInstance & WebAssembly.Exports;
+            const effectInstance = await WebAssembly.instantiate(
+                effectFactory.module,
+                this.createWasmImport(memory)
+            );
+            const effectFunctions =
+                effectInstance.exports as IFaustDspInstance &
+                    WebAssembly.Exports;
             const effectAPI = new FaustDspInstance(effectFunctions);
             return {
                 memory,
@@ -209,19 +345,37 @@ class FaustWasmInstantiator {
         }
     }
 
-    static createSyncPolyDSPInstance(voiceFactory: LooseFaustDspFactory, mixerModule: WebAssembly.Module, voices: number, effectFactory?: LooseFaustDspFactory): FaustPolyDspInstance {
-        const memory = this.createMemoryPoly(voices, voiceFactory, effectFactory);
-        // Create voice 
-        const voiceInstance = new WebAssembly.Instance(voiceFactory.module, this.createWasmImport(memory));
-        const voiceFunctions = voiceInstance.exports as IFaustDspInstance & WebAssembly.Exports;
+    static createSyncPolyDSPInstance(
+        voiceFactory: LooseFaustDspFactory,
+        mixerModule: WebAssembly.Module,
+        voices: number,
+        effectFactory?: LooseFaustDspFactory
+    ): FaustPolyDspInstance {
+        const memory = this.createMemoryPoly(
+            voices,
+            voiceFactory,
+            effectFactory
+        );
+        // Create voice
+        const voiceInstance = new WebAssembly.Instance(
+            voiceFactory.module,
+            this.createWasmImport(memory)
+        );
+        const voiceFunctions = voiceInstance.exports as IFaustDspInstance &
+            WebAssembly.Exports;
         const voiceAPI = new FaustDspInstance(voiceFunctions);
         // Create mixer
         const mixerAPI = this.createMixerAux(mixerModule, memory);
 
-        // Possibly create effect instance 
+        // Possibly create effect instance
         if (effectFactory) {
-            const effectInstance = new WebAssembly.Instance(effectFactory.module, this.createWasmImport(memory));
-            const effectFunctions = effectInstance.exports as IFaustDspInstance & WebAssembly.Exports;
+            const effectInstance = new WebAssembly.Instance(
+                effectFactory.module,
+                this.createWasmImport(memory)
+            );
+            const effectFunctions =
+                effectInstance.exports as IFaustDspInstance &
+                    WebAssembly.Exports;
             const effectAPI = new FaustDspInstance(effectFunctions);
             return {
                 memory,