@grame/faustwasm 0.0.25

package/src/FaustAudioWorkletProcessor.ts

@@ -0,0 +1,273 @@
+import type FaustWasmInstantiator from "./FaustWasmInstantiator";
+import type { FaustBaseWebAudioDsp, FaustWebAudioDspVoice, FaustMonoWebAudioDsp, FaustPolyWebAudioDsp } from "./FaustWebAudioDsp";
+import type { AudioParamDescriptor, AudioWorkletGlobalScope, LooseFaustDspFactory, FaustDspMeta, FaustUIItem, AudioWorkletProcessor } from "./types";
+
+/**
+ * Injected in the string to be compiled on AudioWorkletProcessor side
+ */
+export interface FaustData {
+    processorName: string;
+    dspName: string;
+    dspMeta: FaustDspMeta;
+    poly: boolean;
+    effectMeta?: FaustDspMeta;
+};
+export interface FaustAudioWorkletProcessorDependencies<Poly extends boolean = false> {
+    FaustBaseWebAudioDsp: typeof FaustBaseWebAudioDsp;
+    FaustMonoWebAudioDsp: Poly extends true ? undefined : typeof FaustMonoWebAudioDsp;
+    FaustPolyWebAudioDsp: Poly extends true ? typeof FaustPolyWebAudioDsp : undefined;
+    FaustWebAudioDspVoice: Poly extends true ? typeof FaustWebAudioDspVoice : undefined;
+    FaustWasmInstantiator: typeof FaustWasmInstantiator;
+}
+export interface FaustAudioWorkletNodeOptions<Poly extends boolean = false> extends AudioWorkletNodeOptions {
+    processorOptions: Poly extends true ? FaustPolyAudioWorkletProcessorOptions : FaustMonoAudioWorkletProcessorOptions;
+}
+export interface FaustMonoAudioWorkletNodeOptions extends AudioWorkletNodeOptions {
+    processorOptions: FaustMonoAudioWorkletProcessorOptions;
+}
+export interface FaustPolyAudioWorkletNodeOptions extends AudioWorkletNodeOptions {
+    processorOptions: FaustPolyAudioWorkletProcessorOptions;
+}
+export interface FaustAudioWorkletProcessorOptions {
+    name: string;
+    sampleSize: number;
+}
+export interface FaustMonoAudioWorkletProcessorOptions extends FaustAudioWorkletProcessorOptions {
+    factory: LooseFaustDspFactory;
+}
+export interface FaustPolyAudioWorkletProcessorOptions extends FaustAudioWorkletProcessorOptions {
+    voiceFactory: LooseFaustDspFactory;
+    mixerModule: WebAssembly.Module;
+    voices: number;
+    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;
+
+    const {
+        FaustBaseWebAudioDsp,
+        FaustWasmInstantiator
+    } = dependencies;
+    
+    const {
+        processorName,
+        dspName,
+        dspMeta,
+        effectMeta,
+        poly
+    } = faustData;
+
+    // Analyse voice JSON to generate AudioParam parameters
+    const analysePolyParameters = (item: FaustUIItem): AudioParamDescriptor | null => {
+        const polyKeywords = ["/gate", "/freq", "/gain", "/key", "/vel", "/velocity"];
+        const isPolyReserved = "address" in item && !!polyKeywords.find(k => item.address.endsWith(k));
+        if (poly && isPolyReserved) return null;
+        if (item.type === "vslider" || item.type === "hslider" || item.type === "nentry") {
+            return { name: item.address, defaultValue: item.init || 0, minValue: item.min || 0, maxValue: item.max || 0 };
+        } else if (item.type === "button" || item.type === "checkbox") {
+            return { name: item.address, defaultValue: item.init || 0, minValue: 0, maxValue: 1 };
+        }
+        return null;
+    }
+
+    /**
+     * Base class for Monophonic and Polyphonic AudioWorkletProcessor
+     */
+    class FaustAudioWorkletProcessor<Poly extends boolean = false> extends AudioWorkletProcessor {
+
+        // Use ! syntax when the field is not defined in the constructor
+        protected fDSPCode!: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp;
+
+        protected paramValuesCache: Record<string, number> = {};
+
+        constructor(options: FaustAudioWorkletNodeOptions<Poly>) {
+            super(options);
+
+            // 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;
+            })
+        }
+
+        static get parameterDescriptors() {
+            const params = [] as AudioParamDescriptor[];
+            // Analyse voice JSON to generate AudioParam parameters
+            const callback = (item: FaustUIItem) => {
+                const param = analysePolyParameters(item);
+                if (param) params.push(param);
+            }
+            FaustBaseWebAudioDsp.parseUI(dspMeta.ui, callback);
+            // Analyse effect JSON to generate AudioParam parameters
+            if (effectMeta) FaustBaseWebAudioDsp.parseUI(effectMeta.ui, callback);
+            return params;
+        }
+
+        process(inputs: Float32Array[][], outputs: Float32Array[][], parameters: { [key: string]: Float32Array }) {
+
+            // Update controls (possibly needed for sample accurate control)
+            for (const path in parameters) {
+                const [paramValue] = parameters[path];
+                if (paramValue !== this.paramValuesCache[path]) {
+                    this.fDSPCode.setParamValue(path, paramValue);
+                    this.paramValuesCache[path] = paramValue;
+                }
+            }
+
+            return this.fDSPCode.compute(inputs[0], outputs[0]);
+        }
+
+        protected handleMessageAux(e: MessageEvent) { // use arrow function for binding
+            const msg = e.data;
+
+            switch (msg.type) {
+                // Generic MIDI message
+                case "midi": this.midiMessage(msg.data); break;
+                // Typed MIDI message
+                case "ctrlChange": this.ctrlChange(msg.data[0], msg.data[1], msg.data[2]); break;
+                case "pitchWheel": this.pitchWheel(msg.data[0], msg.data[1]); break;
+                // Generic data message
+                case "param": this.setParamValue(msg.data.path, msg.data.value); break;
+                // Plot handler set on demand
+                case "setPlotHandler": {
+                    if (msg.data) {
+                        this.fDSPCode.setPlotHandler((output, index, events) => this.port.postMessage({ type: "plot", value: output, index, events }));
+                    } else {
+                        this.fDSPCode.setPlotHandler(null);
+                    }
+                    break;
+                }
+                case "start": {
+                    this.fDSPCode.start();
+                    break;
+                }
+                case "stop": {
+                    this.fDSPCode.stop();
+                    break;
+                }
+                case "destroy": {
+                    this.port.close();
+                    this.fDSPCode.destroy();
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+
+        protected setParamValue(path: string, value: number) {
+            this.fDSPCode.setParamValue(path, value);
+            this.paramValuesCache[path] = value;
+        }
+
+        protected midiMessage(data: number[] | Uint8Array) {
+            this.fDSPCode.midiMessage(data);
+        }
+
+        protected ctrlChange(channel: number, ctrl: number, value: number) {
+            this.fDSPCode.ctrlChange(channel, ctrl, value);
+        }
+
+        protected pitchWheel(channel: number, wheel: number) {
+            this.fDSPCode.pitchWheel(channel, wheel);
+        }
+    }
+
+    /**
+     * Monophonic AudioWorkletProcessor
+     */
+    class FaustMonoAudioWorkletProcessor extends FaustAudioWorkletProcessor<false> {
+
+        constructor(options: FaustAudioWorkletNodeOptions) {
+            super(options);
+            const { FaustMonoWebAudioDsp } = dependencies as FaustAudioWorkletProcessorDependencies<false>;
+            const { factory, sampleSize } = options.processorOptions;
+
+            const instance = FaustWasmInstantiator.createSyncMonoDSPInstance(factory);
+            // Create Monophonic DSP
+            this.fDSPCode = new FaustMonoWebAudioDsp(instance, sampleRate, sampleSize, 128);
+
+            // Setup output handler
+            this.fDSPCode.setOutputParamHandler((path, value) => this.port.postMessage({ path, value, type: "param" }));
+
+            this.fDSPCode.start();
+        }
+    }
+
+    /**
+     * Polyphonic AudioWorkletProcessor
+     */
+    class FaustPolyAudioWorkletProcessor extends FaustAudioWorkletProcessor<true> {
+
+        constructor(options: FaustPolyAudioWorkletNodeOptions) {
+            super(options);
+            const { FaustPolyWebAudioDsp } = dependencies as FaustAudioWorkletProcessorDependencies<true>;
+
+            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);
+
+            // Setup port message handling
+            this.port.onmessage = (e: MessageEvent) => this.handleMessageAux(e);
+
+            // Setup output handler
+            this.fDSPCode.setOutputParamHandler((path, value) => this.port.postMessage({ path, value, type: "param" }));
+
+            this.fDSPCode.start();
+        }
+
+        protected midiMessage(data: number[] | Uint8Array) {
+            const cmd = data[0] >> 4;
+            const channel = data[0] & 0xf;
+            const data1 = data[1];
+            const data2 = data[2];
+            if (cmd === 8 || (cmd === 9 && data2 === 0)) this.keyOff(channel, data1, data2);
+            else if (cmd === 9) this.keyOn(channel, data1, data2);
+            else super.midiMessage(data);
+        }
+
+        protected handleMessageAux = (e: MessageEvent) => { // use arrow function for binding
+            const msg = e.data;
+            switch (msg.type) {
+                case "keyOn": this.keyOn(msg.data[0], msg.data[1], msg.data[2]); break;
+                case "keyOff": this.keyOff(msg.data[0], msg.data[1], msg.data[2]); break;
+                default:
+                    super.handleMessageAux(e);
+                    break;
+            }
+        }
+
+        // Public API
+        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);
+        }
+    }
+
+    const Processor = poly ? FaustPolyAudioWorkletProcessor : FaustMonoAudioWorkletProcessor;
+    if (register) {
+        try {
+            registerProcessor(processorName || dspName || (poly ? "mydsp_poly" : "mydsp"), Processor);
+        } catch (error) {
+            console.warn(error);
+        }
+    }
+
+    return poly ? FaustPolyAudioWorkletProcessor : FaustMonoAudioWorkletProcessor;
+}
+
+export default getFaustAudioWorkletProcessor;

package/src/FaustCompiler.ts

@@ -0,0 +1,252 @@
+import { Sha256 } from "@aws-crypto/sha256-js";
+import type { ILibFaust } from "./LibFaust";
+import type { FaustDspFactory, IntVector } from "./types";
+
+export const ab2str = (buf: Uint8Array) => String.fromCharCode.apply(null, buf);
+
+export const str2ab = (str: string) => {
+    const buf = new ArrayBuffer(str.length);
+    const bufView = new Uint8Array(buf);
+    for (let i = 0, strLen = str.length; i < strLen; i++) {
+        bufView[i] = str.charCodeAt(i);
+    }
+    return bufView;
+};
+const sha256 = async (str: string) => {
+    const sha256 = new Sha256();
+    sha256.update(str);
+    const hashArray = Array.from(await sha256.digest());
+    const hashHex = hashArray.map(b => b.toString(16).padStart(2, "0")).join("");
+    return hashHex;
+};
+
+export interface IFaustCompiler {
+    /**
+     * Gives the Faust compiler version.
+     * @return a version string
+     */
+    version(): string;
+
+    /**
+     * Gives the last compilation error.
+     * @return an error string
+     */
+    getErrorMessage(): string;
+
+    /**
+     * Create a wasm factory from Faust code i.e. wasm compiled code, to be used to create monophonic instances. 
+     * This function is running asynchronously.
+     *
+     * @param name - an arbitrary name for the Faust factory
+     * @param code - Faust dsp code
+     * @param args - the compiler options
+     * @returns returns the wasm factory
+     */
+    createMonoDSPFactory(name: string, code: string, args: string): Promise<FaustDspFactory | null>;
+
+    /**
+     * Create a wasm factory from Faust code i.e. wasm compiled code, to be used to create polyphonic instances. 
+     * This function is running asynchronously.
+     *
+     * @param name - an arbitrary name for the Faust factory
+     * @param code - Faust dsp code
+     * @param args - the compiler options
+     * @returns returns the wasm factory
+     */
+    createPolyDSPFactory(name: string, code: string, args: string): Promise<FaustDspFactory | null>;
+
+    /**
+     * Delete a dsp factory.
+     *
+     * @param factory - the factory to be deleted
+     */
+    deleteDSPFactory(factory: FaustDspFactory): void;
+
+    /**
+     * Expand Faust code i.e. linearize included libraries.
+     *
+     * @param code - Faust dsp code
+     * @param args - the compiler options
+     * @returns returns the expanded dsp code
+     */
+    expandDSP(code: string, args: string): string | null;
+
+    /**
+     * Generates auxiliary files from Faust code. The output depends on the compiler options.
+     *
+     * @param name - an arbitrary name for the Faust module
+     * @param code - Faust dsp code
+     * @param args - the compiler options
+     * @returns whether the generation actually succeded
+     */
+    generateAuxFiles(name: string, code: string, args: string): boolean;
+
+    /**
+     * Delete all factories.
+     */
+    deleteAllDSPFactories(): void;
+
+    fs(): typeof FS;
+
+    getAsyncInternalMixerModule(isDouble?: boolean): Promise<{ mixerBuffer: Uint8Array; mixerModule: WebAssembly.Module }>;
+    getSyncInternalMixerModule(isDouble?: boolean): { mixerBuffer: Uint8Array; mixerModule: WebAssembly.Module };
+}
+
+class FaustCompiler implements IFaustCompiler {
+    private fLibFaust: ILibFaust;
+    private fErrorMessage: string;
+    private static gFactories: Map<string, FaustDspFactory> = new Map<string, FaustDspFactory>();
+    private mixer32Buffer!: Uint8Array;
+    private mixer64Buffer!: Uint8Array;
+    private mixer32Module!: WebAssembly.Module;
+    private mixer64Module!: WebAssembly.Module;
+
+    /**
+     * Get a stringified DSP factories table
+     */
+    static serializeDSPFactories() {
+        const table: Record<string, { code: string, json: any; poly: boolean }> = {};
+        this.gFactories.forEach((factory, shaKey) => {
+            const { code, json, poly } = factory;
+            table[shaKey] = { code: btoa(ab2str(code)), json: JSON.parse(json), poly };
+        });
+        return table;
+    }
+    /**
+     * Get a stringified DSP factories table as string
+     */
+    static stringifyDSPFactories() {
+        return JSON.stringify(this.serializeDSPFactories());
+    }
+    /**
+     * Import a DSP factories table
+     */
+    static deserializeDSPFactories(table: Record<string, { code: string, json: any; poly: boolean }>) {
+        const awaited: Promise<Map<string, FaustDspFactory>>[] = [];
+        for (const shaKey in table) {
+            const factory = table[shaKey];
+            const { code, json, poly } = factory;
+            const ab = str2ab(atob(code))
+            awaited.push(WebAssembly.compile(ab).then(module => this.gFactories.set(shaKey, { shaKey, cfactory: 0, code: ab, module, json: JSON.stringify(json), poly })));
+        }
+        return Promise.all(awaited);
+    }
+    /**
+     * Import a stringified DSP factories table
+     */
+    static importDSPFactories(tableStr: string) {
+        const table: Record<string, { code: string, json: any; poly: boolean }> = JSON.parse(tableStr);
+        return this.deserializeDSPFactories(table);
+    }
+    constructor(libFaust: ILibFaust) {
+        this.fLibFaust = libFaust;
+        this.fErrorMessage = "";
+    }
+    private intVec2intArray(vec: IntVector) {
+        const size = vec.size();
+        const ui8Code = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            ui8Code[i] = vec.get(i);
+        }
+        return ui8Code;
+    }
+    private async createDSPFactory(name: string, code: string, args: string, poly: boolean) {
+        // Cleanup the cache
+        if (FaustCompiler.gFactories.size > 10) {
+            FaustCompiler.gFactories.clear();
+        }
+
+        // If code is already compiled, return the cached factory
+        let shaKey = await sha256(name + code + args + (poly ? "poly" : "mono"));
+        if (FaustCompiler.gFactories.has(shaKey)) {
+            return FaustCompiler.gFactories.get(shaKey) || null;
+        } else {
+            try {
+                // Can possibly raise a C++ exception catched by the second catch()
+                const faustDspWasm = this.fLibFaust.createDSPFactory(name, code, args, !poly);
+                const ui8Code = this.intVec2intArray(faustDspWasm.data);
+                faustDspWasm.data.delete();
+                const module = await WebAssembly.compile(ui8Code);
+                const factory: FaustDspFactory = { shaKey, cfactory: faustDspWasm.cfactory, code: ui8Code, module, json: faustDspWasm.json, poly };
+                // Factory C++ side can be deallocated immediately
+                this.deleteDSPFactory(factory);
+                // Keep the compiled factory in the cache
+                FaustCompiler.gFactories.set(shaKey, factory);
+                return factory;
+            } catch (e) {
+                this.fErrorMessage = this.fLibFaust.getErrorAfterException();
+                // console.error(`=> exception raised while running createDSPFactory: ${this.fErrorMessage}`, e);
+                this.fLibFaust.cleanupAfterException();
+                throw this.fErrorMessage ? new Error(this.fErrorMessage) : e;
+            }
+        }
+    }
+    version() {
+        return this.fLibFaust.version();
+    }
+    getErrorMessage() {
+        return this.fErrorMessage;
+    }
+    async createMonoDSPFactory(name: string, code: string, args: string) {
+        return this.createDSPFactory(name, code, args, false);
+    }
+    async createPolyDSPFactory(name: string, code: string, args: string) {
+        return this.createDSPFactory(name, code, args, true);
+    }
+    deleteDSPFactory(factory: FaustDspFactory) {
+        this.fLibFaust.deleteDSPFactory(factory.cfactory);
+        factory.cfactory = 0;
+    }
+    expandDSP(code: string, args: string) {
+        try {
+            return this.fLibFaust.expandDSP("FaustDSP", code, args);
+        } catch (e) {
+            this.fErrorMessage = this.fLibFaust.getErrorAfterException();
+            // console.error(`=> exception raised while running expandDSP: ${this.fErrorMessage}`);
+            this.fLibFaust.cleanupAfterException();
+            throw this.fErrorMessage ? new Error(this.fErrorMessage) : e;
+        }
+    }
+    generateAuxFiles(name: string, code: string, args: string) {
+        try {
+            return this.fLibFaust.generateAuxFiles(name, code, args);
+        } catch (e) {
+            this.fErrorMessage = this.fLibFaust.getErrorAfterException();
+            // console.error(`=> exception raised while running generateAuxFiles: ${this.fErrorMessage}`);
+            this.fLibFaust.cleanupAfterException();
+            throw this.fErrorMessage ? new Error(this.fErrorMessage) : e;
+        }
+    }
+    deleteAllDSPFactories(): void {
+        this.fLibFaust.deleteAllDSPFactories();
+    }
+    fs() {
+        return this.fLibFaust.fs();
+    }
+    async getAsyncInternalMixerModule(isDouble = false) {
+        const bufferKey = isDouble ? "mixer64Buffer" : "mixer32Buffer";
+        const moduleKey = isDouble ? "mixer64Module" : "mixer32Module";
+        if (this[moduleKey]) return { mixerBuffer: this[bufferKey], mixerModule: this[moduleKey] };
+        const path = isDouble ? "/usr/rsrc/mixer64.wasm" : "/usr/rsrc/mixer32.wasm";
+        const mixerBuffer = this.fs().readFile(path, { encoding: "binary" });
+        this[bufferKey] = mixerBuffer;
+        // Compile mixer
+        const mixerModule = await WebAssembly.compile(mixerBuffer);
+        this[moduleKey] = mixerModule;
+        return { mixerBuffer, mixerModule };
+    }
+    getSyncInternalMixerModule(isDouble = false) {
+        const bufferKey = isDouble ? "mixer64Buffer" : "mixer32Buffer";
+        const moduleKey = isDouble ? "mixer64Module" : "mixer32Module";
+        if (this[moduleKey]) return { mixerBuffer: this[bufferKey], mixerModule: this[moduleKey] };
+        const path = isDouble ? "/usr/rsrc/mixer64.wasm" : "/usr/rsrc/mixer32.wasm";
+        const mixerBuffer = this.fs().readFile(path, { encoding: "binary" });
+        this[bufferKey] = mixerBuffer;
+        // Compile mixer
+        const mixerModule = new WebAssembly.Module(mixerBuffer);
+        this[moduleKey] = mixerModule;
+        return { mixerBuffer, mixerModule };
+    }
+}
+
+export default FaustCompiler;