@grame/faustwasm 0.15.6 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@grame/faustwasm",
-    "version": "0.15.6",
+    "version": "0.16.1",
     "description": "WebAssembly version of Faust Compiler",
     "main": "dist/cjs/index.js",
     "types": "dist/esm/index.d.ts",

package/src/FaustAudioWorkletNode.ts

@@ -314,7 +314,10 @@ export class FaustAudioWorkletNode<
 
     setParamValue(path: string, value: number) {
         const resolved = this.fParamAliases[path] || path;
-        this.port.postMessage({ type: 'param', data: { path: resolved, value } });
+        this.port.postMessage({
+            type: 'param',
+            data: { path: resolved, value }
+        });
         // Set value on AudioParam (but this is not used on Processor side for now)
         const param = this.parameters.get(resolved);
         if (param) param.setValueAtTime(value, this.context.currentTime);
@@ -342,6 +345,26 @@ export class FaustAudioWorkletNode<
         return this.fDescriptor;
     }
 
+    init() {
+        this.port.postMessage({ type: 'init' });
+    }
+
+    instanceInit() {
+        this.port.postMessage({ type: 'instanceInit' });
+    }
+
+    instanceClear() {
+        this.port.postMessage({ type: 'instanceClear' });
+    }
+
+    instanceConstants() {
+        this.port.postMessage({ type: 'instanceConstants' });
+    }
+
+    instanceResetUserInterface() {
+        this.port.postMessage({ type: 'instanceResetUserInterface' });
+    }
+
     start() {
         this.port.postMessage({ type: 'start' });
     }

package/src/FaustAudioWorkletProcessor.ts

@@ -44,18 +44,17 @@ export interface FaustAudioWorkletProcessorDependencies<
     FaustWasmInstantiator: typeof FaustWasmInstantiator;
     FaustAudioWorkletProcessorCommunicator: typeof FaustAudioWorkletProcessorCommunicator;
 }
-export interface FaustAudioWorkletNodeOptions<Poly extends boolean = false>
-    extends AudioWorkletNodeOptions {
+export interface FaustAudioWorkletNodeOptions<
+    Poly extends boolean = false
+> extends AudioWorkletNodeOptions {
     processorOptions: Poly extends true
         ? FaustPolyAudioWorkletProcessorOptions
         : FaustMonoAudioWorkletProcessorOptions;
 }
-export interface FaustMonoAudioWorkletNodeOptions
-    extends AudioWorkletNodeOptions {
+export interface FaustMonoAudioWorkletNodeOptions extends AudioWorkletNodeOptions {
     processorOptions: FaustMonoAudioWorkletProcessorOptions;
 }
-export interface FaustPolyAudioWorkletNodeOptions
-    extends AudioWorkletNodeOptions {
+export interface FaustPolyAudioWorkletNodeOptions extends AudioWorkletNodeOptions {
     processorOptions: FaustPolyAudioWorkletProcessorOptions;
 }
 export interface FaustAudioWorkletProcessorOptions {
@@ -65,12 +64,10 @@ export interface FaustAudioWorkletProcessorOptions {
     moduleId?: string;
     instanceId?: string;
 }
-export interface FaustMonoAudioWorkletProcessorOptions
-    extends FaustAudioWorkletProcessorOptions {
+export interface FaustMonoAudioWorkletProcessorOptions extends FaustAudioWorkletProcessorOptions {
     factory: LooseFaustDspFactory;
 }
-export interface FaustPolyAudioWorkletProcessorOptions
-    extends FaustAudioWorkletProcessorOptions {
+export interface FaustPolyAudioWorkletProcessorOptions extends FaustAudioWorkletProcessorOptions {
     voiceFactory: LooseFaustDspFactory;
     mixerModule: WebAssembly.Module;
     voices: number;
@@ -283,6 +280,26 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(
                     this.setupWamEventHandler();
                     break;
                 }
+                case 'init': {
+                    this.fDSPCode.init();
+                    break;
+                }
+                case 'instanceInit': {
+                    this.fDSPCode.instanceInit();
+                    break;
+                }
+                case 'instanceClear': {
+                    this.fDSPCode.instanceClear();
+                    break;
+                }
+                case 'instanceConstants': {
+                    this.fDSPCode.instanceConstants();
+                    break;
+                }
+                case 'instanceResetUserInterface': {
+                    this.fDSPCode.instanceResetUserInterface();
+                    break;
+                }
                 case 'start': {
                     this.fDSPCode.start();
                     break;

package/src/FaustDspGenerator.ts

@@ -367,7 +367,7 @@ export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
                 monoDsp.getNumOutputs()
             ) as FaustMonoScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustMonoScriptProcessorNode.prototype);
-            sp.init(monoDsp);
+            sp.setupNode(monoDsp);
             return sp as SP extends true
                 ? FaustMonoScriptProcessorNode
                 : FaustMonoAudioWorkletNode;
@@ -856,7 +856,7 @@ process = adaptorIns(dsp_code.process) : dsp_code.effect : adaptorOuts;
                 polyDsp.getNumOutputs()
             ) as FaustPolyScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustPolyScriptProcessorNode.prototype);
-            sp.init(polyDsp);
+            sp.setupNode(polyDsp);
             return sp as SP extends true
                 ? FaustPolyScriptProcessorNode
                 : FaustPolyAudioWorkletNode;

package/src/FaustOfflineProcessor.ts

@@ -25,11 +25,9 @@ export interface IFaustOfflineProcessor extends IFaustBaseWebAudioDsp {
 }
 
 export interface IFaustMonoOfflineProcessor
-    extends IFaustOfflineProcessor,
-        IFaustMonoWebAudioDsp {}
+    extends IFaustOfflineProcessor, IFaustMonoWebAudioDsp {}
 export interface IFaustPolyOfflineProcessor
-    extends IFaustOfflineProcessor,
-        IFaustPolyWebAudioDsp {}
+    extends IFaustOfflineProcessor, IFaustPolyWebAudioDsp {}
 
 export class FaustOfflineProcessor<Poly extends boolean = false> {
     protected fDSPCode!: Poly extends true
@@ -190,6 +188,26 @@ export class FaustOfflineProcessor<Poly extends boolean = false> {
         return this.fDSPCode.getUI();
     }
 
+    init() {
+        this.fDSPCode.init();
+    }
+
+    instanceInit() {
+        this.fDSPCode.instanceInit();
+    }
+
+    instanceClear() {
+        this.fDSPCode.instanceClear();
+    }
+
+    instanceConstants() {
+        this.fDSPCode.instanceConstants();
+    }
+
+    instanceResetUserInterface() {
+        this.fDSPCode.instanceResetUserInterface();
+    }
+
     start() {
         this.fDSPCode.start();
     }
@@ -273,7 +291,7 @@ export class FaustOfflineProcessor<Poly extends boolean = false> {
                     outputs[i].set(output, l);
                 }
             }
-            l += this.fBufferSize;
+            l += sliceLength;
             onUpdate?.(l);
         }
         // The node can be stopped after rendering

package/src/FaustScriptProcessorNode.ts

@@ -26,7 +26,7 @@ export class FaustScriptProcessorNode<
     protected handleDeviceMotion = undefined as any;
     protected handleDeviceOrientation = undefined as any;
 
-    init(
+    setupNode(
         instance: Poly extends true
             ? FaustPolyWebAudioDsp
             : FaustMonoWebAudioDsp
@@ -71,6 +71,26 @@ export class FaustScriptProcessorNode<
         this.start();
     }
 
+    init() {
+        this.fDSPCode.init();
+    }
+
+    instanceInit() {
+        this.fDSPCode.instanceInit();
+    }
+
+    instanceClear() {
+        this.fDSPCode.instanceClear();
+    }
+
+    instanceConstants() {
+        this.fDSPCode.instanceConstants();
+    }
+
+    instanceResetUserInterface() {
+        this.fDSPCode.instanceResetUserInterface();
+    }
+
     // Public API
 
     /** Start accelerometer and gyroscope handlers */

package/src/FaustWebAudioDsp.ts

@@ -678,6 +678,31 @@ export interface IFaustBaseWebAudioDsp {
         event: Pick<DeviceOrientationEvent, 'alpha' | 'beta' | 'gamma'>
     ): void;
 
+    /**
+     * Reinitialize the DSP using its configured sample rate.
+     */
+    init(): void;
+
+    /**
+     * Reinitialize the DSP instance state using its configured sample rate.
+     */
+    instanceInit(): void;
+
+    /**
+     * Clear the DSP instance state.
+     */
+    instanceClear(): void;
+
+    /**
+     * Reinitialize the DSP instance constants using its configured sample rate.
+     */
+    instanceConstants(): void;
+
+    /**
+     * Reset DSP user interface parameters to their default values.
+     */
+    instanceResetUserInterface(): void;
+
     /**
      * Start the DSP audio processing.
      */
@@ -696,8 +721,7 @@ export interface IFaustBaseWebAudioDsp {
 
 export type IFaustMonoWebAudioDsp = IFaustBaseWebAudioDsp;
 export interface IFaustMonoWebAudioNode
-    extends IFaustMonoWebAudioDsp,
-        AudioNode {}
+    extends IFaustMonoWebAudioDsp, AudioNode {}
 
 export interface IFaustPolyWebAudioDsp extends IFaustBaseWebAudioDsp {
     /**
@@ -726,8 +750,7 @@ export interface IFaustPolyWebAudioDsp extends IFaustBaseWebAudioDsp {
     allNotesOff(hard: boolean): void;
 }
 export interface IFaustPolyWebAudioNode
-    extends IFaustPolyWebAudioDsp,
-        AudioNode {}
+    extends IFaustPolyWebAudioDsp, AudioNode {}
 
 export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
     protected fOutputHandler: OutputParamHandler | null = null;
@@ -1040,7 +1063,9 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
             .split(';')
             .map((str) =>
                 str.length <= 2 ? '' : str.substring(1, str.length - 1)
-            );
+            )
+            .map((str) => str.trim())
+            .filter((str) => str.length > 0);
     }
 
     get hasAccInput() {
@@ -1574,6 +1599,16 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
         this.stopSensors();
     }
 
+    init() {}
+
+    instanceInit() {}
+
+    instanceClear() {}
+
+    instanceConstants() {}
+
+    instanceResetUserInterface() {}
+
     start() {
         this.fProcessing = true;
     }
@@ -1597,6 +1632,7 @@ export class FaustMonoWebAudioDsp
 {
     private fInstance: FaustMonoDspInstance;
     private fDSP!: number;
+    private fSampleRate: number;
 
     constructor(
         instance: FaustMonoDspInstance,
@@ -1607,6 +1643,7 @@ export class FaustMonoWebAudioDsp
     ) {
         super(sampleSize, bufferSize, soundfiles);
         this.fInstance = instance;
+        this.fSampleRate = sampleRate;
 
         console.log(`sampleSize: ${sampleSize} bufferSize: ${bufferSize}`);
 
@@ -1635,6 +1672,26 @@ export class FaustMonoWebAudioDsp
         }
     }
 
+    init() {
+        this.fInstance.api.init(this.fDSP, this.fSampleRate);
+    }
+
+    instanceInit() {
+        this.fInstance.api.instanceInit(this.fDSP, this.fSampleRate);
+    }
+
+    instanceClear() {
+        this.fInstance.api.instanceClear(this.fDSP);
+    }
+
+    instanceConstants() {
+        this.fInstance.api.instanceConstants(this.fDSP, this.fSampleRate);
+    }
+
+    instanceResetUserInterface() {
+        this.fInstance.api.instanceResetUserInterface(this.fDSP);
+    }
+
     private initMemory(): number {
         // Start of DSP memory: Mono DSP is placed first with index 0
         this.fDSP = 0;
@@ -1886,6 +1943,7 @@ export class FaustWebAudioDspVoice {
     private fVelLabel: number[] = [];
     private fDSP: number; // Voice DSP location in wasm memory
     private fAPI: IFaustDspInstance; // Voice DSP code
+    private fSampleRate: number;
     // Accessed by PolyDSPImp class
     fCurNote = FaustWebAudioDspVoice.kFreeVoice;
     fNextNote = -1;
@@ -1902,7 +1960,8 @@ export class FaustWebAudioDspVoice {
     ) {
         this.fDSP = $dsp;
         this.fAPI = api;
-        this.fAPI.init(this.fDSP, sampleRate);
+        this.fSampleRate = sampleRate;
+        this.init(sampleRate);
         this.extractPaths(inputItems, pathTable);
     }
 
@@ -1914,6 +1973,26 @@ export class FaustWebAudioDspVoice {
         return velocity / 127.0;
     }
 
+    init(sampleRate: number) {
+        this.fAPI.init(this.fDSP, sampleRate);
+    }
+
+    instanceInit() {
+        this.fAPI.instanceInit(this.fDSP, this.fSampleRate);
+    }
+
+    instanceClear() {
+        this.fAPI.instanceClear(this.fDSP);
+    }
+
+    instanceConstants() {
+        this.fAPI.instanceConstants(this.fDSP, this.fSampleRate);
+    }
+
+    instanceResetUserInterface() {
+        this.fAPI.instanceResetUserInterface(this.fDSP);
+    }
+
     private extractPaths(
         inputItems: string[],
         pathTable: { [address: string]: number }
@@ -2023,6 +2102,7 @@ export class FaustPolyWebAudioDsp
     private fAudioMixing!: number;
     private fAudioMixingHalf!: number;
     private fVoiceTable: FaustWebAudioDspVoice[];
+    private fSampleRate: number;
 
     constructor(
         instance: FaustPolyDspInstance,
@@ -2033,6 +2113,7 @@ export class FaustPolyWebAudioDsp
     ) {
         super(sampleSize, bufferSize, soundfiles);
         this.fInstance = instance;
+        this.fSampleRate = sampleRate;
 
         console.log(`sampleSize: ${sampleSize} bufferSize: ${bufferSize}`);
 
@@ -2085,6 +2166,42 @@ export class FaustPolyWebAudioDsp
         }
     }
 
+    init() {
+        this.fVoiceTable.forEach((voice) => voice.init(this.fSampleRate));
+        if (this.fInstance.effectAPI)
+            this.fInstance.effectAPI.init(this.fEffect, this.fSampleRate);
+    }
+
+    instanceInit() {
+        this.fVoiceTable.forEach((voice) => voice.instanceInit());
+        if (this.fInstance.effectAPI)
+            this.fInstance.effectAPI.instanceInit(
+                this.fEffect,
+                this.fSampleRate
+            );
+    }
+
+    instanceClear() {
+        this.fVoiceTable.forEach((voice) => voice.instanceClear());
+        if (this.fInstance.effectAPI)
+            this.fInstance.effectAPI.instanceClear(this.fEffect);
+    }
+
+    instanceConstants() {
+        this.fVoiceTable.forEach((voice) => voice.instanceConstants());
+        if (this.fInstance.effectAPI)
+            this.fInstance.effectAPI.instanceConstants(
+                this.fEffect,
+                this.fSampleRate
+            );
+    }
+
+    instanceResetUserInterface() {
+        this.fVoiceTable.forEach((voice) => voice.instanceResetUserInterface());
+        if (this.fInstance.effectAPI)
+            this.fInstance.effectAPI.instanceResetUserInterface(this.fEffect);
+    }
+
     private initMemory() {
         // Effet start at the end of all DSP voices
         this.fEffect = this.fJSONDsp.size * this.fInstance.voices;

package/src/SoundfileReader.ts

@@ -64,32 +64,13 @@ class SoundfileReader {
             if (item.type === 'soundfile') {
                 const urls = FaustBaseWebAudioDsp.splitSoundfileNames(item.url);
                 // soundfiles.map[item.label] = urls;
-                urls.forEach((url) => (soundfiles[url] = null));
+                urls.filter((url) => url.trim().length > 0)
+                    .forEach((url) => (soundfiles[url] = null));
             }
         };
         FaustBaseWebAudioDsp.parseUI(dspMeta.ui, callback);
         return soundfiles;
     }
-    /**
-     * Check if the file exists.
-     *
-     * @param url : the url of the file to check
-     * @returns : true if the file exists, otherwise false
-     */
-    private static async checkFileExists(url: string): Promise<boolean> {
-        try {
-            console.log(`"checkFileExists" url: ${url}`);
-            // Fetch in "HEAD" mode does not properly work with the service-worker.js cache, so use "GET" mode for now
-            //const response = await fetch(url, { method: "HEAD" });
-            const response = await fetch(url);
-            console.log(`"checkFileExists" response.ok: ${response.ok}`);
-            return response.ok; // Will be true if the status code is 200-299
-        } catch (error) {
-            console.error('Fetch error:', error);
-            return false;
-        }
-    }
-
     /**
      * Fetch the soundfile.
      *
@@ -136,17 +117,21 @@ class SoundfileReader {
                         .href
             )
         ];
-        const checkResults = await Promise.all(
-            urlsToCheck.map((url) => this.checkFileExists(url))
-        );
-        const successIndex = checkResults.findIndex((r) => !!r);
-        if (successIndex === -1)
-            throw new Error(
-                `Failed to load sound file ${filename}, all check failed.`
-            );
-        soundfiles![filename] = await this.fetchSoundfile(
-            urlsToCheck[successIndex],
-            audioCtx
+        // Try each candidate once to avoid double downloads (no preflight GET).
+        let lastError: unknown = null;
+        for (const url of urlsToCheck) {
+            try {
+                soundfiles![filename] = await this.fetchSoundfile(
+                    url,
+                    audioCtx
+                );
+                return;
+            } catch (error) {
+                lastError = error;
+            }
+        }
+        throw new Error(
+            `Failed to load sound file ${filename}, all check failed. Last error: ${String(lastError)}`
         );
     }
 

package/src/faust2wavFiles.js

@@ -52,7 +52,12 @@ const faust2wavFiles = async (
     let input = undefined;
     if (inputWav) {
         console.log(`Reading input wav file ${inputWav}.`);
-        const inputBuffer = fs.readFileSync(inputWav).buffer;
+        const inputBufferView = fs.readFileSync(inputWav);
+        // Slice to the exact Buffer view to avoid extra bytes from the backing ArrayBuffer.
+        const inputBuffer = inputBufferView.buffer.slice(
+            inputBufferView.byteOffset,
+            inputBufferView.byteOffset + inputBufferView.byteLength
+        );
         console.log(`Decoding...`);
         input = WavDecoder.decode(inputBuffer).channelData;
     }

package/test/faustlive-wasm/faustwasm/index.d.ts

@@ -729,6 +729,26 @@ export interface IFaustBaseWebAudioDsp {
 	 * event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">
 	 */
 	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
+	/**
+	 * Reinitialize the DSP using its configured sample rate.
+	 */
+	init(): void;
+	/**
+	 * Reinitialize the DSP instance state using its configured sample rate.
+	 */
+	instanceInit(): void;
+	/**
+	 * Clear the DSP instance state.
+	 */
+	instanceClear(): void;
+	/**
+	 * Reinitialize the DSP instance constants using its configured sample rate.
+	 */
+	instanceConstants(): void;
+	/**
+	 * Reset DSP user interface parameters to their default values.
+	 */
+	instanceResetUserInterface(): void;
 	/**
 	 * Start the DSP audio processing.
 	 */
@@ -903,6 +923,11 @@ export declare class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
 	hasSoundfiles(): boolean;
 	startSensors(): void;
 	stopSensors(): void;
+	init(): void;
+	instanceInit(): void;
+	instanceClear(): void;
+	instanceConstants(): void;
+	instanceResetUserInterface(): void;
 	start(): void;
 	stop(): void;
 	destroy(): void;
@@ -910,7 +935,13 @@ export declare class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
 export declare class FaustMonoWebAudioDsp extends FaustBaseWebAudioDsp implements IFaustMonoWebAudioDsp {
 	private fInstance;
 	private fDSP;
+	private fSampleRate;
 	constructor(instance: FaustMonoDspInstance, sampleRate: number, sampleSize: number, bufferSize: number, soundfiles: LooseFaustDspFactory["soundfiles"]);
+	init(): void;
+	instanceInit(): void;
+	instanceClear(): void;
+	instanceConstants(): void;
+	instanceResetUserInterface(): void;
 	private initMemory;
 	toString(): string;
 	compute(input: Float32Array[] | ((input: Float32Array[] | Float64Array[]) => any), output: Float32Array[] | ((output: Float32Array[] | Float64Array[]) => any)): boolean;
@@ -938,6 +969,7 @@ export declare class FaustWebAudioDspVoice {
 	private fVelLabel;
 	private fDSP;
 	private fAPI;
+	private fSampleRate;
 	fCurNote: number;
 	fNextNote: number;
 	fNextVel: number;
@@ -948,6 +980,11 @@ export declare class FaustWebAudioDspVoice {
 	}, sampleRate: number);
 	static midiToFreq(note: number): number;
 	static normalizeVelocity(velocity: number): number;
+	init(sampleRate: number): void;
+	instanceInit(): void;
+	instanceClear(): void;
+	instanceConstants(): void;
+	instanceResetUserInterface(): void;
 	private extractPaths;
 	keyOn(pitch: number, velocity: number, legato?: boolean): void;
 	keyOff(hard?: boolean): void;
@@ -963,7 +1000,13 @@ export declare class FaustPolyWebAudioDsp extends FaustBaseWebAudioDsp implement
 	private fAudioMixing;
 	private fAudioMixingHalf;
 	private fVoiceTable;
+	private fSampleRate;
 	constructor(instance: FaustPolyDspInstance, sampleRate: number, sampleSize: number, bufferSize: number, soundfiles: LooseFaustDspFactory["soundfiles"]);
+	init(): void;
+	instanceInit(): void;
+	instanceClear(): void;
+	instanceConstants(): void;
+	instanceResetUserInterface(): void;
 	private initMemory;
 	toString(): string;
 	private allocVoice;
@@ -1258,6 +1301,11 @@ export declare class FaustOfflineProcessor<Poly extends boolean = false> {
 	getJSON(): string;
 	getDescriptors(): FaustUIInputItem[];
 	getUI(): FaustUIDescriptor;
+	init(): void;
+	instanceInit(): void;
+	instanceClear(): void;
+	instanceConstants(): void;
+	instanceResetUserInterface(): void;
 	start(): void;
 	stop(): void;
 	destroy(): void;
@@ -1378,13 +1426,6 @@ export declare class SoundfileReader {
 	 * @returns : the URLs
 	 */
 	static findSoundfilesFromMeta(dspMeta: FaustDspMeta): LooseFaustDspFactory["soundfiles"];
-	/**
-	 * Check if the file exists.
-	 *
-	 * @param url : the url of the file to check
-	 * @returns : true if the file exists, otherwise false
-	 */
-	private static checkFileExists;
 	/**
 	 * Fetch the soundfile.
 	 *
@@ -1470,6 +1511,11 @@ export declare class FaustAudioWorkletNode<Poly extends boolean = false> extends
 	getJSON(): string;
 	getUI(): FaustUIDescriptor;
 	getDescriptors(): FaustUIInputItem[];
+	init(): void;
+	instanceInit(): void;
+	instanceClear(): void;
+	instanceConstants(): void;
+	instanceResetUserInterface(): void;
 	start(): void;
 	stop(): void;
 	destroy(): void;
@@ -1508,7 +1554,12 @@ export declare class FaustScriptProcessorNode<Poly extends boolean = false> exte
 	protected fOutputs: Float32Array[];
 	protected handleDeviceMotion: any;
 	protected handleDeviceOrientation: any;
-	init(instance: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp): void;
+	setupNode(instance: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp): void;
+	init(): void;
+	instanceInit(): void;
+	instanceClear(): void;
+	instanceConstants(): void;
+	instanceResetUserInterface(): void;
 	/** Start accelerometer and gyroscope handlers */
 	startSensors(): Promise<void>;
 	/** Stop accelerometer and gyroscope handlers */