@grame/faustwasm 0.0.25

package/libfaust-wasm/libfaust-wasm.wasm.d.ts

@@ -0,0 +1,2 @@
+declare const data: Uint8Array;
+export default data;

package/library.md

@@ -0,0 +1,91 @@
+# Faust Web Audio Library
+
+The Faust Web Audio library provides a high level Javascript API over the [Faust](https://faust.grame.fr) compiler. The interface is designed to be used with [TypeScript](https://www.typescriptlang.org/), but describes and documents the API for pure Javascript as well. This document provides an overview of the differents levels of the API. Examples of use are also provided in the `test` folder.
+
+
+## Table of Content
+
+-  [Organisation of the API](#org)
+
+  - [Faust Compiler WebAssembly module](#module)
+  - [Faust Compiler Javascript Interface](#compiler)
+  - [Faust Wasm Instance](#wasm)
+  - [Faust Audio Nodes Instances and Offline Processor ](#audio)
+  - [High-level API](#high)
+  - [How to use with typescript](#tsuse)
+- [Dynamic and Static Instances](#ds)
+- [Misc. services](#misc)
+- [Important note](#note)
+
+
+## Organisation of the API <a name="org"></a>
+
+The API is organised from low to high level as illustrated by the figure below.
+
+<img src="rsrc/overview.png" class="mx-auto d-block" width="60%">
+
+### Faust Compiler WebAssembly module <a name="module"></a>
+
+The first level is the Faust compiler compiled as a wasm library named `libfaust-wasm`.
+It consists in 3 different files:
+
+- `libfaust-wasm.wasm` : the Faust compiler provided as a WebAssembly module 
+- `libfaust-wasm.js` : a Javascript loader of the WebAssembly module
+- `libfaust-wasm.data` : a virtual file system containing the Faust libraries.
+
+The C++ code is compiled with [Emscripten](https://emscripten.org) and interfaced in `LibFaust.ts` and `types.ts`files. The loader will take care of providing an instance of the Faust WebAssembly module and of the associated virtual file system (libfaust-wasm.data).
+
+### Faust Compiler Javascript Interface <a name="compiler"></a>
+
+The Faust Compiler Javascript interface is described in `FaustCompiler.ts`.   
+It provides *classic* Faust compilation services, which output is a raw WebAssembly module with an associated JSON description of the module.
+
+### Faust Wasm Instance <a name="wasm"></a>
+
+This level takes a WebAssembly module produced by the Faust compiler or a precompiled module loaded from a file, and builds an instance of this module with the proper Wasm memory layout, ready to run, but not yet connected to any audio node. It is described in `FaustDspGenerator.ts`, `FaustWasmInstantiator.ts`, `FaustWebAudioDsp.ts` and `FaustDspInstance.ts` files.   
+
+### Faust Audio Nodes Instances and Offline Processor <a name="audio"></a>
+
+This level takes a Faust Wasm instance to build an audio node. [AudioWorklet](https://developer.mozilla.org/fr/docs/Web/API/AudioWorklet) and [ScriptProcessor](https://developer.mozilla.org/en-US/docs/Web/API/ScriptProcessorNode) nodes are supported.  It is described in `FaustAudioWorkletNode.ts` and `FaustAudioWorkletProcessor.ts` files.   
+  
+**Warning**: AudioWorklet is a recent technology and may not be supported by all the browsers. Check the [compatibility](https://developer.mozilla.org/fr/docs/Web/API/AudioWorklet) chart.
+
+Note that ScriptProcessor is marked as [deprecated](https://developer.mozilla.org/en-US/docs/Web/API/ScriptProcessorNode) but it's the only audio architecture available in older Safari versions. Both monophonic (generators, effects...) or polyphonic (instruments) nodes can be created. It is described in `FaustScriptProcessorNode.ts` file.
+
+By default, and to save CPU, created audio nodes are not processing audio buffers. They have to be explicitely started with the `start` method (and possibly stopped if needed using the `stop`method).
+
+An offline processor to render a DSP in a non real-time context and get the computed frames is available. It is described in `FaustOfflineProcessor.ts`. It will automatically use the `start` and `stop` methods internally to activate actual rendering in its `plot` method. 
+
+### High-level API <a name="high"></a>
+
+A high-level API is available to compile a DSP program and create the audio node, either monophonic or polyphonic using `createNode`. Offline processing monophonic or polyphonic nodes can be created using `createOfflineProcessor`. FFT processing nodes can be created using `createFFTNode`. It is described in `FaustDspGenerator.ts`. 
+
+### How to use with typescript <a name="tsuse"></a>
+
+Simply include the following to get access to types and functions:
+~~~~~~~~~~~~~~~
+///<reference types="@grame/libfaust"/>
+~~~~~~~~~~~~~~~
+
+## Dynamic and Static Instances <a name="ds"></a>
+
+The Faust Wasm and Audio Node levels make it possible to generate instances from Faust dsp code as well as from pre-compiled WebAssembly modules.
+In the latter case, it is not necessary to include the `libfaust-wasm.js` library, `index.js` is sufficient to provide the required services.
+This allows to generate lighter and faster-loading HTML pages.
+
+## Misc. services <a name="misc"></a>
+
+- `FaustSvgDiagrams.ts`: provides facilities to browse Faust generated SVG diagrams
+- `FaustFFTAudioWorkletProcessor`: provides FFT processing
+
+## Important note <a name="note"></a>
+
+Html pages embedding the Faust compiler must be served using https, unless using http://localhost.
+
+----
+<a href="http://faust.grame.fr"><img src=https://faust.grame.fr/community/logos/img/LOGO_FAUST_COMPLET_ORANGE.png width=200 /></a>
+
+
+
+
+

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@grame/faustwasm",
+  "version": "0.0.25",
+  "description": "WebAssembly version of Faust Compiler",
+  "main": "dist/cjs/index.js",
+  "types": "dist/esm/index.d.ts",
+  "module": "dist/esm/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "npm run build-cjs && npm run build-cjs-bundle && npm run build-esm && npm run build-esm-bundle && node postbuild-bundled.js & npm run build-types & npm run build-types-bundle",
+    "build-cjs": "esbuild src/index.ts --target=es2019 --bundle --sourcemap --outdir=dist/cjs --format=iife --external:fs --external:url",
+    "build-cjs-bundle": "node prebuild-bundled.js && esbuild src/index-bundle-iife.ts --target=es2019 --bundle --sourcemap --loader:.wasm=binary --loader:.data=binary --outfile=dist/cjs-bundle/index.js --format=iife --external:fs --external:url --external:path && node postbuild-bundled.js",
+    "build-esm": "esbuild src/index.ts --target=es2019 --bundle --sourcemap --outdir=dist/esm --format=esm --external:fs --external:url",
+    "build-esm-bundle": "node prebuild-bundled.js && esbuild src/index-bundle.ts --target=es2019 --bundle --sourcemap --loader:.wasm=binary --loader:.data=binary --outfile=dist/esm-bundle/index.js --format=esm --external:fs --external:url --external:path && node postbuild-bundled.js",
+    "build-types": "dts-bundle-generator -o dist/cjs/index.d.ts src/index.ts --external-imports",
+    "build-types-bundle": "dts-bundle-generator -o dist/cjs-bundle/index.d.ts src/index-bundle.ts --external-imports",
+    "postbuild": "node postbuild.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grame-cncm/faustwasm.git"
+  },
+  "keywords": [
+    "faust",
+    "webassembly"
+  ],
+  "author": "Grame-CNCM",
+  "license": "LGPL-3.0",
+  "bugs": {
+    "url": "https://github.com/grame-cncm/faustwasm/issues"
+  },
+  "homepage": "https://github.com/grame-cncm/faustwasm#readme",
+  "devDependencies": {
+    "@aws-crypto/sha256-js": "^2.0.1",
+    "@shren/faust-ui": "^1.1.2",
+    "@types/emscripten": "^1.39.5",
+    "@types/node": "^16.11.7",
+    "@types/webmidi": "^2.0.6",
+    "dts-bundle-generator": "^6.13.0",
+    "esbuild": "^0.14.27",
+    "typescript": "^4.4.4"
+  }
+}

package/postbuild-bundled.js

@@ -0,0 +1,11 @@
+//@ts-check
+import { rmSync } from "./fileutils.js"
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+// @ts-ignore
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// @ts-ignore
+const __filename = fileURLToPath(import.meta.url);
+
+rmSync(path.join(__dirname, "./libfaust-wasm/libfaust-wasm.cjs"));

package/postbuild.js

@@ -0,0 +1,63 @@
+//@ts-check
+import { cpSync, rmSync } from "./fileutils.js";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+// @ts-ignore
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// @ts-ignore
+const __filename = fileURLToPath(import.meta.url);
+
+const faustUiDistPath = path.join(__dirname, "./node_modules/@shren/faust-ui/dist/esm");
+const faustUiDistDest = path.join(__dirname, "./assets/standalone/faust-ui");
+const faustUiDistDest2 = path.join(__dirname, "./test/faustlive-wasm/faust-ui");
+
+try {
+    rmSync(faustUiDistDest);
+    rmSync(faustUiDistDest2);
+} catch (e) {
+    console.warn(e);
+}
+try {
+    fs.mkdirSync(faustUiDistDest);
+    fs.mkdirSync(faustUiDistDest2);
+} catch (e) {
+    console.warn(e);
+}
+
+cpSync(faustUiDistPath, faustUiDistDest);
+cpSync(faustUiDistPath, faustUiDistDest2);
+const faustUiDts = `export * from "@shren/faust-ui";\n`;
+fs.writeFileSync(path.join(faustUiDistDest, "index.d.ts"), faustUiDts);
+fs.writeFileSync(path.join(faustUiDistDest2, "index.d.ts"), faustUiDts);
+
+console.log("FaustUI files copied.")
+
+const faustWasmDistPath = path.join(__dirname, "./dist/cjs");
+const faustWasmDistEsmPath = path.join(__dirname, "./dist/esm");
+const faustWasmDistBundlePath = path.join(__dirname, "./dist/cjs-bundle");
+const faustWasmDistEsmBundlePath = path.join(__dirname, "./dist/esm-bundle");
+const faustWasmDistDest = path.join(__dirname, "./assets/standalone/faustwasm");
+const faustWasmDistDest2 = path.join(__dirname, "./test/faustlive-wasm/faustwasm");
+
+fs.copyFileSync(path.join(faustWasmDistPath, "index.d.ts"), path.join(faustWasmDistEsmPath, "index.d.ts"));
+fs.copyFileSync(path.join(faustWasmDistBundlePath, "index.d.ts"), path.join(faustWasmDistEsmBundlePath, "index.d.ts"));
+
+try {
+    rmSync(faustWasmDistDest);
+    rmSync(faustWasmDistDest2);
+} catch (e) {
+    console.warn(e);
+}
+try {
+    fs.mkdirSync(faustWasmDistDest);
+    fs.mkdirSync(faustWasmDistDest2);
+} catch (e) {
+    console.warn(e);
+}
+
+cpSync(faustWasmDistEsmPath, faustWasmDistDest);
+cpSync(faustWasmDistEsmPath, faustWasmDistDest2);
+
+console.log("FaustWasm files copied.")

package/prebuild-bundled.js

@@ -0,0 +1,11 @@
+//@ts-check
+import { cpSync } from "./fileutils.js"
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+// @ts-ignore
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// @ts-ignore
+const __filename = fileURLToPath(import.meta.url);
+
+cpSync(path.join(__dirname, "./libfaust-wasm/libfaust-wasm.js"), path.join(__dirname, "./libfaust-wasm/libfaust-wasm.cjs"));

package/scripts/faust2sndfile.js

@@ -0,0 +1,43 @@
+//@ts-check
+import * as process from "process";
+import faust2wavFiles from "../src/faust2wavFiles.js";
+
+const argv = process.argv.slice(2);
+
+if (argv[0] === "-help" || argv[0] === "-h") {
+    console.log(`
+faust2sndfile.js <file.dsp> <outputWav.wav>
+Generates audio file from a Faust DSP.
+\t -bs\t <num> to setup the rendering buffer size in frames (default: 64)
+\t -bd\t 16|24|32 to setup the output file bit-depth (default: 16)
+\t -c \t <samples> to setup the output file length in frames, when -ct is not used (default: SR*5)
+\t -in\t <inputWav.wav> specify an input file to process
+\t -sr\t <num> to setup the output file sample rate (default: 44100)
+`);
+    process.exit();
+}
+
+const $in = argv.indexOf("-in");
+/** @type {string} */let inputWav;
+if ($in !== -1) [, inputWav] = argv.splice($in, 2);
+
+const $bs = argv.indexOf("-bs");
+/** @type {number} */let bufferSize;
+if ($bs !== -1) bufferSize = +argv.splice($bs, 2)[1];
+
+const $bd = argv.indexOf("-bd");
+/** @type {number} */let bitDepth;
+if ($bd !== -1) bitDepth = +argv.splice($bd, 2)[1];
+
+const $c = argv.indexOf("-c");
+/** @type {number} */let samples;
+if ($c !== -1) samples = +argv.splice($c, 2)[1];
+
+const $sr = argv.indexOf("-sr");
+/** @type {number} */let sampleRate;
+if ($sr !== -1) sampleRate = +argv.splice($sr, 2)[1];
+
+const [inputFile, outputWav, ...argvFaust] = argv;
+
+
+faust2wavFiles(inputFile, inputWav, outputWav, bufferSize, sampleRate, samples, bitDepth, argvFaust);

package/scripts/faust2svg.js

@@ -0,0 +1,17 @@
+//@ts-check
+import * as process from "process";
+import faust2svgFiles from "../src/faust2svgFiles.js";
+
+const argv = process.argv.slice(2);
+
+if (argv[0] === "-help" || argv[0] === "-h") {
+    console.log(`
+faust2svg.js <file.dsp> <outputDir>
+Generates Diagram SVGs of a given Faust DSP.
+`);
+    process.exit();
+}
+
+const [inputFile, outputDir, ...argvFaust] = argv;
+
+faust2svgFiles(inputFile, outputDir, argvFaust);

package/scripts/faust2wasm.js

@@ -0,0 +1,29 @@
+//@ts-check
+import * as process from "process";
+import faust2wasmFiles from "../src/faust2wasmFiles.js";
+import copyWebStandaloneAssets from "../src/copyWebStandaloneAssets.js";
+
+const argv = process.argv.slice(2);
+
+if (argv[0] === "-help" || argv[0] === "-h") {
+    console.log(`
+faust2wasm.js <file.dsp> <outputDir> [-poly] [-standalone]
+Generates WebAssembly and metadata JSON files of a given Faust DSP.
+`);
+    process.exit();
+}
+
+const $poly = argv.indexOf("-poly");
+const poly = $poly !== -1;
+if (poly) argv.splice($poly, 1);
+
+const $standalone = argv.indexOf("-standalone");
+const standalone = $standalone !== -1;
+if (standalone) argv.splice($standalone, 1);
+
+const [inputFile, outputDir, ...argvFaust] = argv;
+
+(async () => {
+    await faust2wasmFiles(inputFile, outputDir, argvFaust, poly);
+    if (standalone) copyWebStandaloneAssets(outputDir);
+})();

package/src/FaustAudioWorkletNode.ts

@@ -0,0 +1,264 @@
+import { OutputParamHandler, ComputeHandler, PlotHandler, UIHandler, MetadataHandler, FaustBaseWebAudioDsp, IFaustMonoWebAudioDsp, IFaustPolyWebAudioDsp } from "./FaustWebAudioDsp";
+import type { FaustAudioWorkletNodeOptions } from "./FaustAudioWorkletProcessor";
+import type { LooseFaustDspFactory, FaustDspMeta, FaustUIInputItem, FaustUIItem } from "./types";
+
+/**
+ * Base class for Monophonic and Polyphonic AudioWorkletNode
+ */
+export class FaustAudioWorkletNode<Poly extends boolean = false> extends (globalThis.AudioWorkletNode || null) {
+
+    protected fJSONDsp: FaustDspMeta;
+    protected fJSON: string;
+    protected fInputsItems: string[];
+    protected fOutputHandler: OutputParamHandler | null;
+    protected fComputeHandler: ComputeHandler | null;
+    protected fPlotHandler: PlotHandler | null;
+    protected fUICallback: UIHandler;
+    protected fDescriptor: FaustUIInputItem[];
+
+    constructor(context: BaseAudioContext, name: string, factory: LooseFaustDspFactory, options: FaustAudioWorkletNodeOptions<Poly>["processorOptions"], nodeOptions: Partial<FaustAudioWorkletNodeOptions> = {}) {
+
+        // Create JSON object
+        const JSONObj: FaustDspMeta = JSON.parse(factory.json);
+
+        // Create proxy FaustAudioWorkletProcessor
+        super(context, name, {
+            numberOfInputs: JSONObj.inputs > 0 ? 1 : 0,
+            numberOfOutputs: JSONObj.outputs > 0 ? 1 : 0,
+            channelCount: Math.max(1, JSONObj.inputs),
+            outputChannelCount: [JSONObj.outputs],
+            channelCountMode: "explicit",
+            channelInterpretation: "speakers",
+            processorOptions: options,
+            ...nodeOptions
+        });
+
+        this.fJSONDsp = JSONObj;
+        this.fJSON = factory.json;
+        this.fOutputHandler = null;
+        this.fComputeHandler = null;
+        this.fPlotHandler = null;
+        this.fDescriptor = [];
+
+        // Parse UI
+        this.fInputsItems = [];
+        this.fUICallback = (item: FaustUIItem) => {
+            if (item.type === "vslider" || item.type === "hslider" || item.type === "button" || item.type === "checkbox" || item.type === "nentry") {
+                // Keep inputs adresses
+                this.fInputsItems.push(item.address);
+                this.fDescriptor.push(item);
+            }
+        }
+        FaustBaseWebAudioDsp.parseUI(this.fJSONDsp.ui, this.fUICallback);
+
+        // Patch it with additional functions
+        this.port.onmessage = (e: MessageEvent) => {
+            if (e.data.type === "param" && this.fOutputHandler) {
+                this.fOutputHandler(e.data.path, e.data.value);
+            } else if (e.data.type === "plot" && this.fPlotHandler) {
+                this.fPlotHandler(e.data.value, e.data.index, e.data.events);
+            }
+        };
+    }
+
+    // Public API
+    setOutputParamHandler(handler: OutputParamHandler | null) {
+        this.fOutputHandler = handler;
+    }
+    getOutputParamHandler() {
+        return this.fOutputHandler;
+    }
+
+    setComputeHandler(handler: ComputeHandler | null) {
+        this.fComputeHandler = handler;
+    }
+    getComputeHandler(): ComputeHandler | null {
+        return this.fComputeHandler;
+    }
+
+    setPlotHandler(handler: PlotHandler | null) {
+        this.fPlotHandler = handler;
+        // Set PlotHandler on processor side
+        if (this.fPlotHandler) {
+            this.port.postMessage({ type: "setPlotHandler", data: true });
+        } else {
+            this.port.postMessage({ type: "setPlotHandler", data: false });
+        }
+    }
+    getPlotHandler(): PlotHandler | null {
+        return this.fPlotHandler;
+    }
+
+    getNumInputs() {
+        return this.fJSONDsp.inputs;
+    }
+    getNumOutputs() {
+        return this.fJSONDsp.outputs;
+    }
+
+    // Implemented in subclasses
+    compute(inputs: Float32Array[], outputs: Float32Array[]) {
+        return false;
+    }
+
+    metadata(handler: MetadataHandler) {
+        if (this.fJSONDsp.meta) {
+            this.fJSONDsp.meta.forEach(meta => handler(Object.keys(meta)[0], meta[Object.keys(meta)[0]]));
+        }
+    }
+
+    midiMessage(data: number[] | Uint8Array): void {
+        const cmd = data[0] >> 4;
+        const channel = data[0] & 0xf;
+        const data1 = data[1];
+        const data2 = data[2];
+        if (cmd === 11) this.ctrlChange(channel, data1, data2);
+        else if (cmd === 14) this.pitchWheel(channel, data2 * 128.0 + data1);
+        else this.port.postMessage({ type: "midi", data: data });
+    }
+
+    ctrlChange(channel: number, ctrl: number, value: number) {
+        const e = { type: "ctrlChange", data: [channel, ctrl, value] };
+        this.port.postMessage(e);
+    }
+    pitchWheel(channel: number, wheel: number) {
+        const e = { type: "pitchWheel", data: [channel, wheel] };
+        this.port.postMessage(e);
+    }
+
+    setParamValue(path: string, value: number) {
+        const e = { type: "param", data: { path, value } };
+        this.port.postMessage(e);
+        // Set value on AudioParam (but this is not used on Processor side for now)
+        const param = this.parameters.get(path);
+        if (param) param.setValueAtTime(value, this.context.currentTime);
+
+    }
+    getParamValue(path: string) {
+        // Get value of AudioParam
+        const param = this.parameters.get(path);
+        return (param) ? param.value : 0;
+    }
+
+    getParams() { return this.fInputsItems; }
+    getMeta() { return this.fJSONDsp; }
+    getJSON() { return JSON.stringify(this.getMeta()); }
+    getUI() { return this.fJSONDsp.ui; }
+    getDescriptors() { return this.fDescriptor; }
+
+    start() {
+        this.port.postMessage({ type: "start" });
+    }
+
+    stop() {
+        this.port.postMessage({ type: "stop" });
+    }
+
+    destroy() {
+        this.port.postMessage({ type: "destroy" });
+        this.port.close();
+    }
+}
+
+/**
+ * Monophonic AudioWorkletNode
+ */
+export class FaustMonoAudioWorkletNode extends FaustAudioWorkletNode<false> implements IFaustMonoWebAudioDsp {
+
+    onprocessorerror = (e: Event) => {
+        // console.error("Error from " + this.fJSONDsp.name + " FaustMonoAudioWorkletNode");
+        throw e;
+    }
+
+    constructor(context: BaseAudioContext, name: string, factory: LooseFaustDspFactory, sampleSize: number, nodeOptions: Partial<FaustAudioWorkletNodeOptions> = {}) {
+        super(context, name, factory, { name, factory, sampleSize }, nodeOptions);
+    }
+}
+
+/**
+ * Polyphonic AudioWorkletNode
+ */
+export class FaustPolyAudioWorkletNode extends FaustAudioWorkletNode<true> implements IFaustPolyWebAudioDsp {
+
+    private fJSONEffect: FaustDspMeta | null;
+
+    onprocessorerror = (e: Event) => {
+        // console.error("Error from " + this.fJSONDsp.name + " FaustPolyAudioWorkletNode");
+        throw e;
+    }
+
+    constructor(context: BaseAudioContext,
+        name: string,
+        voiceFactory: LooseFaustDspFactory,
+        mixerModule: WebAssembly.Module,
+        voices: number,
+        sampleSize: number,
+        effectFactory?: LooseFaustDspFactory, nodeOptions: Partial<FaustAudioWorkletNodeOptions> = {}) {
+
+        super(
+            context,
+            name,
+            voiceFactory,
+            {
+                name,
+                voiceFactory,
+                mixerModule,
+                voices,
+                sampleSize,
+                effectFactory
+            },
+            nodeOptions
+        );
+
+        this.fJSONEffect = effectFactory ? JSON.parse(effectFactory.json) : null;
+
+        if (this.fJSONEffect) {
+            FaustBaseWebAudioDsp.parseUI(this.fJSONEffect.ui, this.fUICallback);
+        }
+    }
+
+    // Public API
+    keyOn(channel: number, pitch: number, velocity: number) {
+        const e = { type: "keyOn", data: [channel, pitch, velocity] };
+        this.port.postMessage(e);
+    }
+
+    keyOff(channel: number, pitch: number, velocity: number) {
+        const e = { type: "keyOff", data: [channel, pitch, velocity] };
+        this.port.postMessage(e);
+    }
+
+    allNotesOff(hard: boolean) {
+        const e = { type: "ctrlChange", data: [0, 123, 0] };
+        this.port.postMessage(e);
+    }
+
+    getMeta() {
+        const o = this.fJSONDsp;
+        const e = this.fJSONEffect;
+        const r = { ...o };
+        if (e) {
+            r.ui = [{
+                type: "tgroup", label: "Sequencer", items: [
+                    { type: "vgroup", label: "Instrument", items: o.ui },
+                    { type: "vgroup", label: "Effect", items: e.ui }
+                ]
+            }];
+        } else {
+            r.ui = [{
+                type: "tgroup", label: "Polyphonic", items: [
+                    { type: "vgroup", label: "Voices", items: o.ui }
+                ]
+            }];
+        }
+        return r as FaustDspMeta;
+    }
+
+    getJSON() {
+        return JSON.stringify(this.getMeta());
+    }
+
+    getUI() {
+        return this.getMeta().ui;
+    }
+}