@grame/faustwasm 0.0.25

package/src/FaustOfflineProcessor.ts

@@ -0,0 +1,141 @@
+import { ComputeHandler, FaustBaseWebAudioDsp, FaustMonoWebAudioDsp, FaustPolyWebAudioDsp, IFaustBaseWebAudioDsp, IFaustMonoWebAudioDsp, IFaustPolyWebAudioDsp, MetadataHandler, OutputParamHandler, PlotHandler } from "./FaustWebAudioDsp";
+import { AudioParamDescriptor, FaustUIItem } from "./types";
+
+/**
+ *  For offline rendering.
+ */
+export interface IFaustOfflineProcessor extends IFaustBaseWebAudioDsp {
+    render(inputs?: Float32Array[], length?: number, onUpdate?: (sample: number) => any): Float32Array[];
+}
+
+export interface IFaustMonoOfflineProcessor extends IFaustOfflineProcessor, IFaustMonoWebAudioDsp {}
+export interface IFaustPolyOfflineProcessor extends IFaustOfflineProcessor, IFaustPolyWebAudioDsp {}
+
+export class FaustOfflineProcessor<Poly extends boolean = false> {
+    protected fDSPCode!: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp;
+
+    protected fBufferSize: number;
+    protected fInputs: Float32Array[];
+    protected fOutputs: Float32Array[];
+
+    constructor(instance: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp, bufferSize: number) {
+        this.fDSPCode = instance;
+        this.fBufferSize = bufferSize;
+        this.fInputs = new Array(this.fDSPCode.getNumInputs()).fill(null).map(() => new Float32Array(bufferSize));
+        this.fOutputs = new Array(this.fDSPCode.getNumOutputs()).fill(null).map(() => new Float32Array(bufferSize));
+    }
+
+    // Public API
+
+    getParameterDescriptors() {
+        const params = [] as AudioParamDescriptor[];
+        // Analyse voice JSON to generate AudioParam parameters
+        const callback = (item: FaustUIItem) => {
+            let param: AudioParamDescriptor | null = null;
+            const polyKeywords = ["/gate", "/freq", "/gain", "/key", "/vel", "/velocity"];
+            const isPolyReserved = "address" in item && !!polyKeywords.find(k => item.address.endsWith(k));
+            if (this.fDSPCode instanceof FaustMonoWebAudioDsp || !isPolyReserved) {
+                if (item.type === "vslider" || item.type === "hslider" || item.type === "nentry") {
+                    param = { name: item.address, defaultValue: item.init || 0, minValue: item.min || 0, maxValue: item.max || 0 };
+                } else if (item.type === "button" || item.type === "checkbox") {
+                    param = { name: item.address, defaultValue: item.init || 0, minValue: 0, maxValue: 1 };
+                }
+            }
+            if (param) params.push(param);
+        }
+        FaustBaseWebAudioDsp.parseUI(this.fDSPCode.getUI(), callback);
+        return params;
+    }
+    compute(input: Float32Array[], output: Float32Array[]) { return this.fDSPCode.compute(input, output); }
+
+    setOutputParamHandler(handler: OutputParamHandler) { this.fDSPCode.setOutputParamHandler(handler); }
+    getOutputParamHandler() { return this.fDSPCode.getOutputParamHandler(); }
+
+    setComputeHandler(handler: ComputeHandler) { this.fDSPCode.setComputeHandler(handler); }
+    getComputeHandler() { return this.fDSPCode.getComputeHandler(); }
+
+    setPlotHandler(handler: PlotHandler) { this.fDSPCode.setPlotHandler(handler); }
+    getPlotHandler() { return this.fDSPCode.getPlotHandler(); }
+
+    getNumInputs() { return this.fDSPCode.getNumInputs(); }
+    getNumOutputs() { return this.fDSPCode.getNumOutputs(); }
+
+    metadata(handler: MetadataHandler) { }
+
+    midiMessage(data: number[] | Uint8Array) { this.fDSPCode.midiMessage(data); }
+
+    ctrlChange(chan: number, ctrl: number, value: number) { this.fDSPCode.ctrlChange(chan, ctrl, value); }
+    pitchWheel(chan: number, value: number) { this.fDSPCode.pitchWheel(chan, value); }
+
+    setParamValue(path: string, value: number) { this.fDSPCode.setParamValue(path, value); }
+    getParamValue(path: string) { return this.fDSPCode.getParamValue(path); }
+    getParams() { return this.fDSPCode.getParams(); }
+
+    getMeta() { return this.fDSPCode.getMeta(); }
+    getJSON() { return this.fDSPCode.getJSON(); }
+    getDescriptors() { return this.fDSPCode.getDescriptors(); }
+    getUI() { return this.fDSPCode.getUI(); }
+
+    start() { this.fDSPCode.start(); }
+    stop() { this.fDSPCode.stop(); }
+
+    destroy() { this.fDSPCode.destroy(); }
+
+    /**
+     * Render frames in an array.
+     *
+     * @param inputs - input signal
+     * @param length - the number of frames to render (default: bufferSize)
+     * @param onUpdate - a callback after each buffer calculated, with an argument "current sample"
+     * @return an array of Float32Array with the rendered frames
+     */
+    render(inputs: Float32Array[] = [], length = this.fBufferSize, onUpdate?: (sample: number) => any): Float32Array[] {
+        let l = 0;
+        const outputs = new Array(this.fDSPCode.getNumOutputs()).fill(null).map(() => new Float32Array(length));
+        // The node has to be started before rendering
+        this.fDSPCode.start();
+        while (l < length) {
+            const sliceLength = Math.min(length - l, this.fBufferSize);
+            for (let i = 0; i < this.fDSPCode.getNumInputs(); i++) {
+                let input: Float32Array;
+                if (inputs[i]) {
+                    if (inputs[i].length <= l) {
+                        input = new Float32Array(sliceLength);
+                    } else if (inputs[i].length > l + sliceLength) {
+                        input = inputs[i].subarray(l, l + sliceLength);
+                    } else {
+                        input = inputs[i].subarray(l, inputs[i].length);
+                    }
+                } else {
+                    input = new Float32Array(sliceLength);
+                }
+                this.fInputs[i] = input;
+            }
+            this.fDSPCode.compute(this.fInputs, this.fOutputs);
+            for (let i = 0; i < this.fDSPCode.getNumOutputs(); i++) {
+                const output = this.fOutputs[i];
+                if (sliceLength < this.fBufferSize) {
+                    outputs[i].set(output.subarray(0, sliceLength), l);
+                } else {
+                    outputs[i].set(output, l);
+                }
+            }
+            l += this.fBufferSize;
+            onUpdate?.(l);
+        }
+        // The node can be stopped after rendering
+        this.fDSPCode.stop();
+        return outputs;
+    }
+}
+
+export class FaustMonoOfflineProcessor extends FaustOfflineProcessor<false> implements IFaustMonoWebAudioDsp {
+}
+
+export class FaustPolyOfflineProcessor extends FaustOfflineProcessor<true> implements IFaustPolyWebAudioDsp {
+    keyOn(channel: number, pitch: number, velocity: number) { this.fDSPCode.keyOn(channel, pitch, velocity); }
+    keyOff(channel: number, pitch: number, velocity: number) { this.fDSPCode.keyOff(channel, pitch, velocity); }
+    allNotesOff(hard: boolean) { this.fDSPCode.allNotesOff(hard); }
+}
+
+export default FaustOfflineProcessor;

package/src/FaustScriptProcessorNode.ts

@@ -0,0 +1,80 @@
+import type { ComputeHandler, FaustMonoWebAudioDsp, FaustPolyWebAudioDsp, IFaustMonoWebAudioDsp, IFaustPolyWebAudioDsp, MetadataHandler, OutputParamHandler, PlotHandler } from "./FaustWebAudioDsp";
+
+/**
+ * Base class for Monophonic and Polyphonic ScriptProcessorNode
+ */
+export class FaustScriptProcessorNode<Poly extends boolean = false> extends (globalThis.ScriptProcessorNode || null) {
+    protected fDSPCode!: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp;
+
+    // Needed for ScriptProcessorNode
+    protected fInputs!: Float32Array[];
+    protected fOutputs!: Float32Array[];
+
+    init(instance: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp) {
+        this.fDSPCode = instance;
+
+        this.fInputs = new Array(this.fDSPCode.getNumInputs());
+        this.fOutputs = new Array(this.fDSPCode.getNumOutputs());
+
+        this.onaudioprocess = (e) => {
+
+            // Read inputs
+            for (let chan = 0; chan < this.fDSPCode.getNumInputs(); chan++) {
+                this.fInputs[chan] = e.inputBuffer.getChannelData(chan);
+            }
+
+            // Read outputs
+            for (let chan = 0; chan < this.fDSPCode.getNumOutputs(); chan++) {
+                this.fOutputs[chan] = e.outputBuffer.getChannelData(chan);
+            }
+
+            return this.fDSPCode.compute(this.fInputs, this.fOutputs);
+        }
+
+        this.start();
+    }
+    // Public API
+    compute(input: Float32Array[], output: Float32Array[]) { return this.fDSPCode.compute(input, output); }
+
+    setOutputParamHandler(handler: OutputParamHandler) { this.fDSPCode.setOutputParamHandler(handler); }
+    getOutputParamHandler() { return this.fDSPCode.getOutputParamHandler(); }
+
+    setComputeHandler(handler: ComputeHandler) { this.fDSPCode.setComputeHandler(handler); }
+    getComputeHandler() { return this.fDSPCode.getComputeHandler(); }
+
+    setPlotHandler(handler: PlotHandler) { this.fDSPCode.setPlotHandler(handler); }
+    getPlotHandler() { return this.fDSPCode.getPlotHandler(); }
+
+    getNumInputs() { return this.fDSPCode.getNumInputs(); }
+    getNumOutputs() { return this.fDSPCode.getNumOutputs(); }
+
+    metadata(handler: MetadataHandler) { }
+
+    midiMessage(data: number[] | Uint8Array) { this.fDSPCode.midiMessage(data); }
+
+    ctrlChange(chan: number, ctrl: number, value: number) { this.fDSPCode.ctrlChange(chan, ctrl, value); }
+    pitchWheel(chan: number, value: number) { this.fDSPCode.pitchWheel(chan, value); }
+
+    setParamValue(path: string, value: number) { this.fDSPCode.setParamValue(path, value); }
+    getParamValue(path: string) { return this.fDSPCode.getParamValue(path); }
+    getParams() { return this.fDSPCode.getParams(); }
+
+    getMeta() { return this.fDSPCode.getMeta(); }
+    getJSON() { return this.fDSPCode.getJSON(); }
+    getDescriptors() { return this.fDSPCode.getDescriptors(); }
+    getUI() { return this.fDSPCode.getUI(); }
+
+    start() { this.fDSPCode.start(); }
+    stop() { this.fDSPCode.stop(); }
+
+    destroy() { this.fDSPCode.destroy(); }
+}
+
+export class FaustMonoScriptProcessorNode extends FaustScriptProcessorNode<false> implements IFaustMonoWebAudioDsp {
+}
+
+export class FaustPolyScriptProcessorNode extends FaustScriptProcessorNode<true> implements IFaustPolyWebAudioDsp {
+    keyOn(channel: number, pitch: number, velocity: number) { this.fDSPCode.keyOn(channel, pitch, velocity); }
+    keyOff(channel: number, pitch: number, velocity: number) { this.fDSPCode.keyOff(channel, pitch, velocity); }
+    allNotesOff(hard: boolean) { this.fDSPCode.allNotesOff(hard); }
+}

package/src/FaustSvgDiagrams.ts

@@ -0,0 +1,37 @@
+import type FaustCompiler from "./FaustCompiler";
+
+interface IFaustSvgDiagrams {
+    /**
+     * Generates auxiliary files from Faust code. The output depends on the compiler options.
+     *
+     * @param name - the DSP's name
+     * @param code - Faust code
+     * @param args - compilation args
+     * @returns the svg diagrams as a filename - svg string map
+     */
+    from(name: string, code: string, args: string): Record<string, string>;
+}
+
+class FaustSvgDiagrams implements IFaustSvgDiagrams {
+    private compiler: FaustCompiler;
+
+    constructor(compiler: FaustCompiler) {
+        this.compiler = compiler;
+    }
+    
+    from(name: string, code: string, args: string) {
+        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 -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);
+        return svgs;
+    }
+}
+
+export default FaustSvgDiagrams;

package/src/FaustWasmInstantiator.ts

@@ -0,0 +1,202 @@
+import FaustDspInstance, { FaustMonoDspInstance, FaustPolyDspInstance, IFaustDspInstance, IFaustMixerInstance } from "./FaustDspInstance";
+import type { FaustDspFactory, FaustDspMeta, LooseFaustDspFactory } from "./types";
+
+class FaustWasmInstantiator {
+    private static createWasmImport(memory?: WebAssembly.Memory) {
+        return {
+            env: {
+                memory: memory || new WebAssembly.Memory({ initial: 100 }),
+                memoryBase: 0,
+                tableBase: 0,
+                // 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,
+                _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.fround, _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,
+                _fmod: (x: number, y: number) => x % y,
+                _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.fround, _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" })
+            }
+        };
+    }
+    private static createWasmMemory(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; }
+            return n;
+        };
+        const effectSize = effectMeta ? effectMeta.size : 0;
+        let memorySize = pow2limit(
+            effectSize
+            + dspMeta.size * voices
+            + (dspMeta.inputs + dspMeta.outputs * 2)
+            * (ptrSize + bufferSize * sampleSize)
+        ) / 65536;
+        memorySize = Math.max(2, memorySize); // At least 2
+        return new WebAssembly.Memory({ initial: memorySize, maximum: memorySize });
+    };
+    private static createMonoDSPInstanceAux(instance: WebAssembly.Instance, json: string) {
+        const functions = instance.exports as IFaustDspInstance & WebAssembly.Exports;
+        const api = new FaustDspInstance(functions);
+        const memory: any = instance.exports.memory;
+        return { memory, api, json } as FaustMonoDspInstance;
+    }
+    private static createMemoryAux(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);
+    }
+    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;
+        return mixerFunctions;
+    }
+    // Public API
+    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}`);
+        }
+        try {
+            const wasmBuffer = await wasmFile.arrayBuffer();
+            const module = await WebAssembly.compile(wasmBuffer);
+            const jsonFile = await fetch(jsonPath);
+            const json = await jsonFile.text();
+            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;
+        } catch (e) {
+            // console.error(`=> exception raised while running loadDSPFactory: ${e}`);
+            throw e;
+        }
+    }
+    
+    static async loadDSPMixer(mixerPath: string, fs?: typeof FS) {
+        try {
+            let mixerBuffer = null;
+            if (fs) {
+                mixerBuffer = fs.readFile(mixerPath, { encoding: "binary" });
+            } else {
+                const mixerFile = await fetch(mixerPath);
+                mixerBuffer = await mixerFile.arrayBuffer();
+            }
+            // Compile mixer
+            return WebAssembly.compile(mixerBuffer);
+        } catch (e) {
+            // console.error(`=> exception raised while running loadMixer: ${e}`);
+            throw e;
+        }
+    }
+    
+    static async createAsyncMonoDSPInstance(factory: LooseFaustDspFactory) {
+        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);
+    }
+    
+    static async createAsyncPolyDSPInstance(voiceFactory: LooseFaustDspFactory, mixerModule: WebAssembly.Module, voices: number, effectFactory?: LooseFaustDspFactory): Promise<FaustPolyDspInstance> {
+        const memory = this.createMemoryAux(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));
+            const effectFunctions = effectInstance.exports as IFaustDspInstance & WebAssembly.Exports;
+            const effectAPI = new FaustDspInstance(effectFunctions);
+            return {
+                memory,
+                voices,
+                voiceAPI,
+                effectAPI,
+                mixerAPI,
+                voiceJSON: voiceFactory.json,
+                effectJSON: effectFactory.json
+            };
+        } else {
+            return {
+                memory,
+                voices,
+                voiceAPI,
+                mixerAPI,
+                voiceJSON: voiceFactory.json
+            };
+        }
+    }
+    
+    static createSyncPolyDSPInstance(voiceFactory: LooseFaustDspFactory, mixerModule: WebAssembly.Module, voices: number, effectFactory?: LooseFaustDspFactory): FaustPolyDspInstance {
+        const memory = this.createMemoryAux(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));
+            const effectFunctions = effectInstance.exports as IFaustDspInstance & WebAssembly.Exports;
+            const effectAPI = new FaustDspInstance(effectFunctions);
+            return {
+                memory,
+                voices,
+                voiceAPI,
+                effectAPI,
+                mixerAPI,
+                voiceJSON: voiceFactory.json,
+                effectJSON: effectFactory.json
+            };
+        } else {
+            return {
+                memory,
+                voices,
+                voiceAPI,
+                mixerAPI,
+                voiceJSON: voiceFactory.json
+            };
+        }
+    }
+}
+
+export default FaustWasmInstantiator;