@grame/faustwasm 0.0.67 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grame/faustwasm",
-  "version": "0.0.67",
+  "version": "0.1.0",
   "description": "WebAssembly version of Faust Compiler",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
@@ -39,7 +39,7 @@
   "homepage": "https://github.com/grame-cncm/faustwasm#readme",
   "devDependencies": {
     "@aws-crypto/sha256-js": "^2.0.1",
-    "@shren/faust-ui": "^1.1.8",
+    "@shren/faust-ui": "^1.1.9",
     "@types/emscripten": "^1.39.5",
     "@types/node": "^16.11.7",
     "@types/webmidi": "^2.0.6",

package/src/FaustAudioWorkletProcessor.ts

@@ -42,7 +42,6 @@ export interface FaustPolyAudioWorkletProcessorOptions extends FaustAudioWorklet
     effectFactory?: LooseFaustDspFactory;
 }
 
-
 // Dynamic AudioWorkletProcessor code generator
 const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencies: FaustAudioWorkletProcessorDependencies<Poly>, faustData: FaustData, register = true): typeof AudioWorkletProcessor => {
     const { registerProcessor, AudioWorkletProcessor, sampleRate } = globalThis as unknown as AudioWorkletGlobalScope;
@@ -51,7 +50,7 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
         FaustBaseWebAudioDsp,
         FaustWasmInstantiator
     } = dependencies;
-    
+
     const {
         processorName,
         dspName,
@@ -88,7 +87,7 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
 
             // Setup port message handling
             this.port.onmessage = (e: MessageEvent) => this.handleMessageAux(e);
-            
+
             const { parameterDescriptors } = (this.constructor as typeof AudioWorkletProcessor);
             parameterDescriptors.forEach((pd) => {
                 this.paramValuesCache[pd.name] = pd.defaultValue || 0;
@@ -189,9 +188,16 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
             const { factory, sampleSize } = options.processorOptions;
 
             const instance = FaustWasmInstantiator.createSyncMonoDSPInstance(factory);
+
             // Create Monophonic DSP
             this.fDSPCode = new FaustMonoWebAudioDsp(instance, sampleRate, sampleSize, 128);
 
+            // Check for soundfile support
+            if (this.fDSPCode.hasSoundfiles()) {
+                console.error("FaustAudioWorkletProcessor: Soundfile support is not implemented yet, switch to ScriptProcessorNode for now");
+                return;
+            }
+
             // Setup output handler
             this.fDSPCode.setOutputParamHandler((path, value) => this.port.postMessage({ path, value, type: "param" }));
 
@@ -211,9 +217,16 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
             const { voiceFactory, mixerModule, voices, effectFactory, sampleSize } = options.processorOptions;
 
             const instance = FaustWasmInstantiator.createSyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory);
+
             // Create Polyphonic DSP
             this.fDSPCode = new FaustPolyWebAudioDsp(instance, sampleRate, sampleSize, 128);
 
+            // Check for soundfile support
+            if (this.fDSPCode.hasSoundfiles()) {
+                console.error("FaustAudioWorkletProcessor: Soundfile support is not implemented yet, switch to ScriptProcessorNode for now");
+                return;
+            }
+
             // Setup port message handling
             this.port.onmessage = (e: MessageEvent) => this.handleMessageAux(e);
 

package/src/FaustDspGenerator.ts

@@ -112,6 +112,7 @@ export interface IFaustPolyDspGenerator {
         voiceFactory: FaustDspFactory | null;
         effectFactory?: FaustDspFactory | null;
     } | null>;
+
     /**
      * Create a polyphonic WebAudio node (either ScriptProcessorNode or AudioWorkletNode).
      *
@@ -189,9 +190,12 @@ export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
     }
     async compile(compiler: IFaustCompiler, name: string, code: string, args: string) {
         this.factory = await compiler.createMonoDSPFactory(name, code, args);
-        if (!this.factory) return null;
-        this.name = name;
-        return this;
+        if (this.factory) {
+            this.name = name;
+            return this;
+        } else {
+            return null;
+        }
     }
 
     async createNode<SP extends boolean = false>(
@@ -209,6 +213,8 @@ export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
         if (sp) {
             const instance = await FaustWasmInstantiator.createAsyncMonoDSPInstance(factory);
             const monoDsp = new FaustMonoWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize);
+            // Initialize the DSP instance, possibly loading soundfiles
+            await monoDsp.init(context);
             const sp = context.createScriptProcessor(bufferSize, monoDsp.getNumInputs(), monoDsp.getNumOutputs()) as FaustMonoScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustMonoScriptProcessorNode.prototype);
             sp.init(monoDsp);
@@ -255,6 +261,7 @@ const dependencies = {
             return node as SP extends true ? FaustMonoScriptProcessorNode : FaustMonoAudioWorkletNode;
         }
     }
+
     async createFFTNode(
         context: BaseAudioContext,
         fftUtils: typeof FFTUtils,
@@ -325,6 +332,7 @@ const dependencies = {
         }
         return node;
     }
+
     async createAudioWorkletProcessor(
         name = this.name,
         factory = this.factory as LooseFaustDspFactory,
@@ -359,6 +367,7 @@ const dependencies = {
             throw e;
         }
     }
+
     async createOfflineProcessor(
         sampleRate: number,
         bufferSize: number,
@@ -370,6 +379,8 @@ const dependencies = {
         const instance = await FaustWasmInstantiator.createAsyncMonoDSPInstance(factory);
         const sampleSize = meta.compile_options.match("-double") ? 8 : 4;
         const monoDsp = new FaustMonoWebAudioDsp(instance, sampleRate, sampleSize, bufferSize);
+        // Initialize the DSP instance, no soundfiles loading for now (TODO ?)
+        await monoDsp.init(null);
         return new FaustMonoOfflineProcessor(monoDsp, bufferSize);
     }
 
@@ -492,6 +503,8 @@ export class FaustPolyDspGenerator implements IFaustPolyDspGenerator {
         if (sp) {
             const instance = await FaustWasmInstantiator.createAsyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory || undefined);
             const polyDsp = new FaustPolyWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize);
+            // Initialize the DSP instance, possibly loading soundfiles
+            await polyDsp.init(context);
             const sp = context.createScriptProcessor(bufferSize, polyDsp.getNumInputs(), polyDsp.getNumOutputs()) as FaustPolyScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustPolyScriptProcessorNode.prototype);
             sp.init(polyDsp);
@@ -540,6 +553,7 @@ const dependencies = {
             return node as SP extends true ? FaustPolyScriptProcessorNode : FaustPolyAudioWorkletNode;
         }
     }
+
     async createAudioWorkletProcessor(
         name = this.name,
         voiceFactory = this.voiceFactory as LooseFaustDspFactory,
@@ -577,6 +591,7 @@ const dependencies = {
             throw e;
         }
     }
+
     async createOfflineProcessor(
         sampleRate: number,
         bufferSize: number,

package/src/FaustWasmInstantiator.ts

@@ -21,7 +21,7 @@ class FaustWasmInstantiator {
                 _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,
@@ -33,12 +33,12 @@ class FaustWasmInstantiator {
                 _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" })
             }
         };
     }
-    private static createWasmMemory(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
@@ -52,26 +52,43 @@ class FaustWasmInstantiator {
         let memorySize = pow2limit(
             effectSize
             + dspMeta.size * voices
-            + (dspMeta.inputs + dspMeta.outputs * 2)
+            + (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, maximum: memorySize });
+        return new WebAssembly.Memory({ initial: memorySize });
     };
-    private static createMonoDSPInstanceAux(instance: WebAssembly.Instance, json: string) {
+
+    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;
+        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;
         const api = new FaustDspInstance(functions);
-        const memory: any = instance.exports.memory;
+        const memory: any = (mem) ? mem : instance.exports.memory;
         return { memory, api, json } as FaustMonoDspInstance;
     }
-    private static createMemoryAux(voices: number, voiceFactory: LooseFaustDspFactory, effectFactory?: LooseFaustDspFactory) {
+
+    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;
+        return this.createWasmMemoryMono(sampleSize, monoMeta, 8192);
+
+    }
+    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;
         // Memory will be shared by voice, mixer and (possibly) effect instances
-        return this.createWasmMemory(voices, sampleSize, voiceMeta, effectMeta, 8192);
+        return this.createWasmMemoryPoly(voices, sampleSize, voiceMeta, effectMeta, 8192);
     }
+
     private static createMixerAux(mixerModule: WebAssembly.Module, memory: WebAssembly.Memory) {
         // Create mixer instance
         const mixerImport = {
@@ -82,6 +99,7 @@ class FaustWasmInstantiator {
         const mixerFunctions = mixerInstance.exports as IFaustMixerInstance & WebAssembly.Exports;
         return mixerFunctions;
     }
+
     // Public API
     static async loadDSPFactory(wasmPath: string, jsonPath: string) {
         const wasmFile = await fetch(wasmPath);
@@ -102,7 +120,7 @@ class FaustWasmInstantiator {
             throw e;
         }
     }
-    
+
     static async loadDSPMixer(mixerPath: string, fs?: typeof FS) {
         try {
             let mixerBuffer = null;
@@ -119,26 +137,44 @@ class FaustWasmInstantiator {
             throw e;
         }
     }
-    
+
     static async createAsyncMonoDSPInstance(factory: LooseFaustDspFactory) {
-        const instance = await WebAssembly.instantiate(factory.module, this.createWasmImport());
-        return this.createMonoDSPInstanceAux(instance, factory.json);
+        const parsedJson = JSON.parse(factory.json);
+        // If the JSON contains a soundfile UI element, we need to create a memory object
+        if (Array.isArray(parsedJson.ui) && parsedJson.ui.some((group: { items: any[]; }) => group.items?.some(item => item.type === "soundfile"))) {
+            const memory = this.createMemoryMono(factory);
+            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());
+            return this.createMonoDSPInstanceAux(instance, factory.json);
+        }
     }
-    
+
     static createSyncMonoDSPInstance(factory: LooseFaustDspFactory) {
-        const instance = new WebAssembly.Instance(factory.module, this.createWasmImport());
-        return this.createMonoDSPInstanceAux(instance, factory.json);
+        const parsedJson = JSON.parse(factory.json);
+        // If the JSON contains a soundfile UI element, we need to create a memory object
+        if (Array.isArray(parsedJson.ui) && parsedJson.ui.some((group: { items: any[]; }) => group.items?.some(item => item.type === "soundfile"))) {
+            const memory = this.createMemoryMono(factory);
+            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());
+            return this.createMonoDSPInstanceAux(instance, factory.json);
+        }
     }
-    
+
     static async createAsyncPolyDSPInstance(voiceFactory: LooseFaustDspFactory, mixerModule: WebAssembly.Module, voices: number, effectFactory?: LooseFaustDspFactory): Promise<FaustPolyDspInstance> {
-        const memory = this.createMemoryAux(voices, voiceFactory, effectFactory);
+        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 
         if (effectFactory) {
             const effectInstance = await WebAssembly.instantiate(effectFactory.module, this.createWasmImport(memory));
@@ -152,7 +188,7 @@ class FaustWasmInstantiator {
                 mixerAPI,
                 voiceJSON: voiceFactory.json,
                 effectJSON: effectFactory.json
-            };
+            } as FaustPolyDspInstance;
         } else {
             return {
                 memory,
@@ -160,19 +196,19 @@ class FaustWasmInstantiator {
                 voiceAPI,
                 mixerAPI,
                 voiceJSON: voiceFactory.json
-            };
+            } as FaustPolyDspInstance;
         }
     }
-    
+
     static createSyncPolyDSPInstance(voiceFactory: LooseFaustDspFactory, mixerModule: WebAssembly.Module, voices: number, effectFactory?: LooseFaustDspFactory): FaustPolyDspInstance {
-        const memory = this.createMemoryAux(voices, voiceFactory, effectFactory);
+        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 
         if (effectFactory) {
             const effectInstance = new WebAssembly.Instance(effectFactory.module, this.createWasmImport(memory));
@@ -186,7 +222,7 @@ class FaustWasmInstantiator {
                 mixerAPI,
                 voiceJSON: voiceFactory.json,
                 effectJSON: effectFactory.json
-            };
+            } as FaustPolyDspInstance;
         } else {
             return {
                 memory,
@@ -194,7 +230,7 @@ class FaustWasmInstantiator {
                 voiceAPI,
                 mixerAPI,
                 voiceJSON: voiceFactory.json
-            };
+            } as FaustPolyDspInstance;
         }
     }
 }