@grame/faustwasm 0.0.56 → 0.0.58

package/package.json

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

package/src/FaustDspGenerator.ts

@@ -395,35 +395,82 @@ export class FaustPolyDspGenerator implements IFaustPolyDspGenerator {
     async compile(
         compiler: IFaustCompiler,
         name: string,
-        dspCode: string,
+        dspCodeAux: string,
         args: string,
-        // The ${dspCode} has to be added with wrapping new lines to make it properly formatted and ready to compile
-        effectCode = `
-            adapt(1,1) = _;
-            adapt(2,2) = _,_;
-            adapt(1,2) = _ <: _,_;
-            adapt(2,1) = _,_ :> _;
-            adaptor(F,G) = adapt(outputs(F),inputs(G));
-            dsp_code = environment{
-                ${dspCode}
+        // The ${dspCode} has to be added with wrapping new lines to make it properly formatted and ready to compile  
+        effectCodeAux = `dsp_code = environment{
+                ${dspCodeAux}
             };
-            process = adaptor(dsp_code.process, dsp_code.effect) : dsp_code.effect;`
+            process = dsp_code.effect;`
     ) {
-        this.voiceFactory = await compiler.createPolyDSPFactory(name, dspCode, args);
-        if (!this.voiceFactory) return null;
-        // Compile effect, possibly failing
+        // Try to compile effect, possibly failing
         try {
-            this.effectFactory = await compiler.createPolyDSPFactory(name, effectCode, args);
+            this.effectFactory = await compiler.createPolyDSPFactory(name, effectCodeAux, args);
+            // Since the effect is processing the same buffers for inputs and outputs (in place processing), 
+            // the voice and effect are adapted, possibly clearing buffers
+            if (this.effectFactory) {
+                const effectJSON = JSON.parse(this.effectFactory.json);
+                const dspCode = `
+                    // Voice output is forced to 2, when DSP is stereo or effect has 2 ins or 2 outs,
+                    // so that the effect can process the 2 channels of the voice
+                    adaptOut(1,1,1) = _;
+                    adaptOut(1,1,2) = _ <: _,_;
+                    adaptOut(1,2,1) = _ <: _,_;
+                    adaptOut(1,2,2) = _ <: _,_;
+                    adaptOut(2,1,1) = _,_;
+                    adaptOut(2,1,2) = _,_;
+                    adaptOut(2,2,1) = _,_;
+                    adaptOut(2,2,2) = _,_;
+                    adaptor(F) = adaptOut(outputs(F),${effectJSON.inputs},${effectJSON.outputs});
+                    dsp_code = environment{
+                        ${dspCodeAux}
+                    };
+                    process = dsp_code.process : adaptor(dsp_code.process);`
+                const effectCode = `
+                    // Inputs
+                    adaptIn(1,1,1) = _;
+                    adaptIn(1,1,2) = _,*(0) :> _;  // The voice output was duplicated, so only one channel has to be kept
+                    adaptIn(1,2,1) = _,_;
+                    adaptIn(1,2,2) = _,_;
+                    adaptIn(2,1,1) = _,_ :> _;
+                    adaptIn(2,1,2) = _,_ :> _;
+                    adaptIn(2,2,1) = _,_;
+                    adaptIn(2,2,2) = _,_;
+                    // Outputs
+                    adaptOut(1,1) = _ <: _,*(0);   // The left channel is kept, but the right one has to be cleared
+                    adaptOut(1,2) = _,_;
+                    adaptOut(2,1) = _ <: _,*(0);   // The left channel is kept, but the right one has to be cleared
+                    adaptOut(2,2) = _,_;
+                    adaptorIns(F) = adaptIn(outputs(F),${effectJSON.inputs},${effectJSON.outputs});
+                    adaptorOuts = adaptOut(${effectJSON.inputs},${effectJSON.outputs});
+                    dsp_code = environment{
+                        ${dspCodeAux}
+                    };
+                    process = adaptorIns(dsp_code.process) : dsp_code.effect : adaptorOuts;`
+                this.voiceFactory = await compiler.createPolyDSPFactory(name, dspCode, args);
+                try {
+                    // Effect is processing same buffers for inputs and outputs, so has to use -inpl option
+                    this.effectFactory = await compiler.createPolyDSPFactory(name, effectCode, args + " -inpl");
+                } catch (e) {
+                    console.log(e);
+                }
+            }
         } catch (e) {
-            console.warn(e);
+            console.log(e);
+            this.voiceFactory = await compiler.createPolyDSPFactory(name, dspCodeAux, args);
+        }
+
+        if (this.voiceFactory) {
+            this.name = name;
+            const voiceMeta = JSON.parse(this.voiceFactory.json);
+            const isDouble = voiceMeta.compile_options.match("-double");
+            const { mixerBuffer, mixerModule } = await compiler.getAsyncInternalMixerModule(!!isDouble);
+            this.mixerBuffer = mixerBuffer;
+            this.mixerModule = mixerModule;
+            return this;
+        } else {
+            return null;
         }
-        this.name = name;
-        const voiceMeta = JSON.parse(this.voiceFactory.json);
-        const isDouble = voiceMeta.compile_options.match("-double");
-        const { mixerBuffer, mixerModule } = await compiler.getAsyncInternalMixerModule(!!isDouble);
-        this.mixerBuffer = mixerBuffer;
-        this.mixerModule = mixerModule;
-        return this;
     }
 
     async createNode<SP extends boolean = false>(

package/test/bug/bug.html

@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Faust DSP</title>
+    <style>
+        body {
+            color: #b0b0b0;
+            background-color: #1f1f1f;
+            display: flex;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            margin: 0;
+            position: absolute;
+        }
+
+        main {
+            margin: 20px;
+            display: flex;
+            flex-direction: column;
+            flex: 1 1 100%;
+        }
+
+        main span {
+            position: relative;
+            display: flex;
+        }
+
+        main span[hidden] {
+            display: none;
+        }
+
+        main span span {
+            margin: 0px 10px;
+            flex: 1;
+        }
+
+        main span select {
+            flex: 2;
+        }
+
+        #dsp-switch {
+            margin: 20px auto;
+        }
+
+        #button-dsp {
+            padding: 10px;
+        }
+
+        #div-faust-ui {
+            flex: 1 1 auto;
+            display: flex;
+            position: relative;
+            flex-direction: column;
+        }
+    </style>
+    <link rel="stylesheet" href="./faust-ui/index.css">
+</head>
+
+<body>
+    <main>
+        <span id="audio-input">
+            <span>Select Audio Input Device</span>
+            <select id="select-audio-input"></select>
+        </span>
+        <span id="midi-input">
+            <span>Select MIDI Input Device</span>
+            <select id="select-midi-input"></select>
+        </span>
+        <span id="dsp-switch">
+            <button id="button-dsp">Activate DSP</button>
+        </span>
+        <div id="div-faust-ui">
+        </div>
+    </main>
+    <script src="./bug.js"></script>
+</body>
+
+</html>

package/test/bug/bug.js

@@ -0,0 +1,216 @@
+/**
+ * @typedef {import("./types").FaustDspDistribution} FaustDspDistribution
+ * @typedef {import("./faustwasm").FaustAudioWorkletNode} FaustAudioWorkletNode
+ * @typedef {import("./faustwasm").FaustDspMeta} FaustDspMeta
+ * @typedef {import("./faustwasm").FaustUIDescriptor} FaustUIDescriptor
+ * @typedef {import("./faustwasm").FaustUIGroup} FaustUIGroup
+ * @typedef {import("./faustwasm").FaustUIItem} FaustUIItem
+ */
+
+/** @type {HTMLSpanElement} */
+const $spanAudioInput = document.getElementById("audio-input");
+/** @type {HTMLSpanElement} */
+const $spanMidiInput = document.getElementById("midi-input");
+/** @type {HTMLSelectElement} */
+const $selectAudioInput = document.getElementById("select-audio-input");
+/** @type {HTMLSelectElement} */
+const $selectMidiInput = document.getElementById("select-midi-input");
+/** @type {HTMLSelectElement} */
+const $buttonDsp = document.getElementById("button-dsp");
+/** @type {HTMLDivElement} */
+const $divFaustUI = document.getElementById("div-faust-ui");
+
+/** @type {typeof AudioContext} */
+const AudioCtx = window.AudioContext || window.webkitAudioContext;
+const audioContext = new AudioCtx({ latencyHint: 0.00001 });
+audioContext.destination.channelInterpretation = "discrete";
+audioContext.suspend();
+
+/**
+ * @param {FaustAudioWorkletNode} faustNode 
+ */
+const buildAudioDeviceMenu = async (faustNode) => {
+    /** @type {MediaStreamAudioSourceNode} */
+    let inputStreamNode;
+    const handleDeviceChange = async () => {
+        const devicesInfo = await navigator.mediaDevices.enumerateDevices();
+        $selectAudioInput.innerHTML = '';
+        devicesInfo.forEach((deviceInfo, i) => {
+            const { kind, deviceId, label } = deviceInfo;
+            if (kind === "audioinput") {
+                const option = new Option(label || `microphone ${i + 1}`, deviceId);
+                $selectAudioInput.add(option);
+            }
+        });
+    }
+    await handleDeviceChange();
+    navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange)
+    $selectAudioInput.onchange = async () => {
+        const id = $selectAudioInput.value;
+        const constraints = {
+            audio: {
+                echoCancellation: false,
+                mozNoiseSuppression: false,
+                mozAutoGainControl: false,
+                deviceId: id ? { exact: id } : undefined,
+            },
+        };
+        const stream = await navigator.mediaDevices.getUserMedia(constraints);
+        if (inputStreamNode) inputStreamNode.disconnect();
+        inputStreamNode = audioContext.createMediaStreamSource(stream);
+        inputStreamNode.connect(faustNode);
+    };
+
+    const defaultConstraints = {
+        audio: {
+            echoCancellation: false,
+            mozNoiseSuppression: false,
+            mozAutoGainControl: false
+        }
+    };
+    const defaultStream = await navigator.mediaDevices.getUserMedia(defaultConstraints);
+    if (defaultStream) {
+        inputStreamNode = audioContext.createMediaStreamSource(defaultStream);
+        inputStreamNode.connect(faustNode);
+    }
+};
+
+/**
+ * @param {FaustAudioWorkletNode} faustNode 
+ */
+const buildMidiDeviceMenu = async (faustNode) => {
+    const midiAccess = await navigator.requestMIDIAccess();
+    /** @type {WebMidi.MIDIInput} */
+    let currentInput;
+    /**
+     * @param {WebMidi.MIDIMessageEvent} e
+     */
+    const handleMidiMessage = e => faustNode.midiMessage(e.data);
+    const handleStateChange = () => {
+        const { inputs } = midiAccess;
+        if ($selectMidiInput.options.length === inputs.size + 1) return;
+        if (currentInput) currentInput.removeEventListener("midimessage", handleMidiMessage);
+        $selectMidiInput.innerHTML = '<option value="-1" disabled selected>Select...</option>';
+        inputs.forEach((midiInput) => {
+            const { name, id } = midiInput;
+            const option = new Option(name, id);
+            $selectMidiInput.add(option);
+        });
+    };
+    handleStateChange();
+    midiAccess.addEventListener("statechange", handleStateChange);
+    $selectMidiInput.onchange = () => {
+        if (currentInput) currentInput.removeEventListener("midimessage", handleMidiMessage);
+        const id = $selectMidiInput.value;
+        currentInput = midiAccess.inputs.get(id);
+        currentInput.addEventListener("midimessage", handleMidiMessage);
+    };
+};
+
+$buttonDsp.disabled = true;
+$buttonDsp.onclick = () => {
+    if (audioContext.state === "running") {
+        $buttonDsp.textContent = "Suspended";
+        audioContext.suspend();
+    } else if (audioContext.state === "suspended") {
+        $buttonDsp.textContent = "Running";
+        audioContext.resume();
+    }
+}
+
+/**
+ * Creates a Faust audio node for use in the Web Audio API.
+ *
+ * @param {AudioContext} audioContext - The Web Audio API AudioContext to which the Faust audio node will be connected.
+ * @param {string} dspName - The name of the DSP to be loaded.
+ * @param {number} voices - The number of voices to be used for polyphonic DSPs.
+ * @returns {Object} - An object containing the Faust audio node and the DSP metadata.
+ */
+const createFaustNode = async (audioContext, dspName = "template", voices = 0) => {
+    // Import necessary Faust modules and data
+    const { FaustMonoDspGenerator, FaustPolyDspGenerator } = await import("./faustwasm/index.js");
+
+    // Load DSP metadata from JSON
+    /** @type {FaustDspMeta} */
+    const dspMeta = await (await fetch(`./${dspName}.json`)).json();
+
+    // Compile the DSP module from WebAssembly binary data
+    const dspModule = await WebAssembly.compileStreaming(await fetch(`./${dspName}.wasm`));
+
+    // Create an object representing Faust DSP with metadata and module
+    /** @type {FaustDspDistribution} */
+    const faustDsp = { dspMeta, dspModule };
+
+    /** @type {FaustAudioWorkletNode} */
+    let faustNode;
+
+    // Create either a polyphonic or monophonic Faust audio node based on the number of voices
+    if (voices > 0) {
+
+        // Try to load optional mixer and effect modules
+        try {
+            faustDsp.mixerModule = await WebAssembly.compileStreaming(await fetch("./mixerModule.wasm"));
+            faustDsp.effectMeta = await (await fetch(`./${dspName}_effect.json`)).json();
+            faustDsp.effectModule = await WebAssembly.compileStreaming(await fetch(`./${dspName}_effect.wasm`));
+        } catch (e) { }
+
+        const generator = new FaustPolyDspGenerator();
+        faustNode = await generator.createNode(
+            audioContext,
+            voices,
+            "FaustPolyDSP",
+            { module: faustDsp.dspModule, json: JSON.stringify(faustDsp.dspMeta) },
+            faustDsp.mixerModule,
+            faustDsp.effectModule ? { module: faustDsp.effectModule, json: JSON.stringify(faustDsp.effectMeta) } : undefined
+        );
+    } else {
+        const generator = new FaustMonoDspGenerator();
+        faustNode = await generator.createNode(
+            audioContext,
+            "FaustMonoDSP",
+            { module: faustDsp.dspModule, json: JSON.stringify(faustDsp.dspMeta) }
+        );
+    }
+
+    // Return an object with the Faust audio node and the DSP metadata
+    return { faustNode, dspMeta };
+}
+
+/**
+ * @param {FaustAudioWorkletNode} faustNode 
+ */
+const createFaustUI = async (faustNode) => {
+    const { FaustUI } = await import("./faust-ui/index.js");
+    const $container = document.createElement("div");
+    $container.style.margin = "0";
+    $container.style.position = "absolute";
+    $container.style.overflow = "auto";
+    $container.style.display = "flex";
+    $container.style.flexDirection = "column";
+    $container.style.width = "100%";
+    $container.style.height = "100%";
+    $divFaustUI.appendChild($container);
+    const faustUI = new FaustUI({
+        ui: faustNode.getUI(),
+        root: $container,
+        listenWindowMessage: false,
+        listenWindowResize: true,
+    });
+    faustUI.paramChangeByUI = (path, value) => faustNode.setParamValue(path, value);
+    faustNode.setOutputParamHandler((path, value) => faustUI.paramChangeByDSP(path, value));
+    $container.style.minWidth = `${faustUI.minWidth}px`;
+    $container.style.minHeight = `${faustUI.minHeight}px`;
+    faustUI.resize();
+};
+
+(async () => {
+    const { faustNode, dspMeta: { name } } = await createFaustNode(audioContext, "bug", 16);
+    await createFaustUI(faustNode);
+    faustNode.connect(audioContext.destination);
+    if (faustNode.numberOfInputs) await buildAudioDeviceMenu(faustNode);
+    else $spanAudioInput.hidden = true;
+    if (navigator.requestMIDIAccess) await buildMidiDeviceMenu(faustNode);
+    else $spanMidiInput.hidden = true;
+    $buttonDsp.disabled = false;
+    document.title = name;
+})();

package/test/bug/bug.json

@@ -0,0 +1,122 @@
+{
+    "name": "bug",
+    "filename": "bug",
+    "version": "2.72.4",
+    "compile_options": "-lang wasm-e -ct 1 -es 1 -mcd 16 -mdd 1024 -mdy 33 -single -ftz 0",
+    "library_list": [
+        "/usr/share/faust/stdfaust.lib",
+        "/usr/share/faust/oscillators.lib",
+        "/usr/share/faust/maths.lib",
+        "/usr/share/faust/platform.lib",
+        "/usr/share/faust/envelopes.lib"
+    ],
+    "include_pathnames": [
+        "/share/faust",
+        "/usr/local/share/faust",
+        "/usr/share/faust",
+        "."
+    ],
+    "size": 76,
+    "code": "yEOP",
+    "inputs": 0,
+    "outputs": 2,
+    "meta": [
+        {
+            "compile_options": "-lang wasm-e -ct 1 -es 1 -mcd 16 -mdd 1024 -mdy 33 -single -ftz 0"
+        },
+        {
+            "envelopes.lib/adsr:author": "Yann Orlarey and Andrey Bundin"
+        },
+        {
+            "envelopes.lib/author": "GRAME"
+        },
+        {
+            "envelopes.lib/copyright": "GRAME"
+        },
+        {
+            "envelopes.lib/license": "LGPL with exception"
+        },
+        {
+            "envelopes.lib/name": "Faust Envelope Library"
+        },
+        {
+            "envelopes.lib/version": "1.3.0"
+        },
+        {
+            "filename": "bug"
+        },
+        {
+            "maths.lib/author": "GRAME"
+        },
+        {
+            "maths.lib/copyright": "GRAME"
+        },
+        {
+            "maths.lib/license": "LGPL with exception"
+        },
+        {
+            "maths.lib/name": "Faust Math Library"
+        },
+        {
+            "maths.lib/version": "2.7.0"
+        },
+        {
+            "name": "bug"
+        },
+        {
+            "oscillators.lib/name": "Faust Oscillator Library"
+        },
+        {
+            "oscillators.lib/saw2ptr:author": "Julius O. Smith III"
+        },
+        {
+            "oscillators.lib/saw2ptr:license": "STK-4.3"
+        },
+        {
+            "oscillators.lib/version": "1.5.0"
+        },
+        {
+            "platform.lib/name": "Generic Platform Library"
+        },
+        {
+            "platform.lib/version": "1.3.0"
+        }
+    ],
+    "ui": [
+        {
+            "type": "vgroup",
+            "label": "bug",
+            "items": [
+                {
+                    "type": "hslider",
+                    "label": "freq",
+                    "shortname": "freq",
+                    "address": "/bug/freq",
+                    "index": 16,
+                    "init": 200,
+                    "min": 50,
+                    "max": 1000,
+                    "step": 0.01
+                },
+                {
+                    "type": "hslider",
+                    "label": "gain",
+                    "shortname": "gain",
+                    "address": "/bug/gain",
+                    "index": 0,
+                    "init": 0.5,
+                    "min": 0,
+                    "max": 1,
+                    "step": 0.01
+                },
+                {
+                    "type": "button",
+                    "label": "gate",
+                    "shortname": "gate",
+                    "address": "/bug/gate",
+                    "index": 32
+                }
+            ]
+        }
+    ]
+}

package/test/bug/bug_effect.json

@@ -0,0 +1,92 @@
+{
+    "name": "bug",
+    "filename": "bug",
+    "version": "2.72.4",
+    "compile_options": "-lang wasm-e -inpl -ct 1 -es 1 -mcd 16 -mdd 1024 -mdy 33 -single -ftz 0",
+    "library_list": [
+        "/usr/share/faust/stdfaust.lib",
+        "/usr/share/faust/oscillators.lib",
+        "/usr/share/faust/maths.lib",
+        "/usr/share/faust/platform.lib",
+        "/usr/share/faust/envelopes.lib"
+    ],
+    "include_pathnames": [
+        "/share/faust",
+        "/usr/local/share/faust",
+        "/usr/share/faust",
+        "."
+    ],
+    "size": 4,
+    "code": "xI8e",
+    "inputs": 2,
+    "outputs": 2,
+    "meta": [
+        {
+            "compile_options": "-lang wasm-e -inpl -ct 1 -es 1 -mcd 16 -mdd 1024 -mdy 33 -single -ftz 0"
+        },
+        {
+            "envelopes.lib/adsr:author": "Yann Orlarey and Andrey Bundin"
+        },
+        {
+            "envelopes.lib/author": "GRAME"
+        },
+        {
+            "envelopes.lib/copyright": "GRAME"
+        },
+        {
+            "envelopes.lib/license": "LGPL with exception"
+        },
+        {
+            "envelopes.lib/name": "Faust Envelope Library"
+        },
+        {
+            "envelopes.lib/version": "1.3.0"
+        },
+        {
+            "filename": "bug"
+        },
+        {
+            "maths.lib/author": "GRAME"
+        },
+        {
+            "maths.lib/copyright": "GRAME"
+        },
+        {
+            "maths.lib/license": "LGPL with exception"
+        },
+        {
+            "maths.lib/name": "Faust Math Library"
+        },
+        {
+            "maths.lib/version": "2.7.0"
+        },
+        {
+            "name": "bug"
+        },
+        {
+            "oscillators.lib/name": "Faust Oscillator Library"
+        },
+        {
+            "oscillators.lib/saw2ptr:author": "Julius O. Smith III"
+        },
+        {
+            "oscillators.lib/saw2ptr:license": "STK-4.3"
+        },
+        {
+            "oscillators.lib/version": "1.5.0"
+        },
+        {
+            "platform.lib/name": "Generic Platform Library"
+        },
+        {
+            "platform.lib/version": "1.3.0"
+        }
+    ],
+    "ui": [
+        {
+            "type": "vgroup",
+            "label": "bug",
+            "items": []
+        }
+    ]
+}