@grame/faustwasm 0.0.25

package/src/faust2wavFiles.js

@@ -0,0 +1,58 @@
+//@ts-check
+import * as fs from "fs";
+import * as path from "path";
+import * as process from "process";
+import {
+    instantiateFaustModuleFromFile,
+    LibFaust,
+    FaustCompiler,
+    FaustMonoDspGenerator,
+    WavDecoder,
+    WavEncoder
+} from "../dist/esm/index.js";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __filename = fileURLToPath(import.meta.url);
+
+/**
+ * @param {string} inputFile
+ * @param {string} inputWav
+ * @param {string} outputWav
+ * @param {number} bufferSize
+ * @param {number} sampleRate
+ * @param {number} samples
+ * @param {number} bitDepth
+ * @param {string[]} [argv]
+ */
+const faust2wavFiles = async (inputFile, inputWav, outputWav, bufferSize = 64, sampleRate = 44100, samples = 5 * sampleRate, bitDepth = 16, argv = []) => {
+    const faustModule = await instantiateFaustModuleFromFile(path.join(__dirname, "../libfaust-wasm/libfaust-wasm.js"));
+    const libFaust = new LibFaust(faustModule);
+    const compiler = new FaustCompiler(libFaust);
+    console.log(`Faust Compiler version: ${compiler.version()}`);
+    console.log(`Reading file ${inputFile}`);
+    const code = fs.readFileSync(inputFile, { encoding: "utf8" });
+    if (!argv.find(a => a === "-I")) argv.push("-I", "libraries/");
+    const { name } = path.parse(inputFile);
+    const gen = new FaustMonoDspGenerator();
+    await gen.compile(compiler, name, code, argv.join(" "));
+    const processor = await gen.createOfflineProcessor(sampleRate, bufferSize);
+    if (!processor) throw Error("Processor not generated");
+    /** @type {Float32Array[] | undefined} */
+    let input = undefined;
+    if (inputWav) {
+        console.log(`Reading input wav file ${inputWav}.`);
+        const inputBuffer = fs.readFileSync(inputWav).buffer;
+        console.log(`Decoding...`);
+        input = WavDecoder.decode(inputBuffer).channelData;
+    }
+    console.log(`Processing...`);
+    const output = processor.render(input, samples, sample => process.stdout.write(`\r${sample} / ${samples}`));
+    console.log("");
+    console.log(`Encoding...`);
+    const outputBuffer = WavEncoder.encode(output, { bitDepth, sampleRate });
+    console.log(`Writing output wav file ${outputWav}.`);
+    fs.writeFileSync(outputWav, new Uint8Array(outputBuffer));
+};
+
+export default faust2wavFiles;

package/src/index-bundle-iife.ts

@@ -0,0 +1,7 @@
+import * as faustwasm from "./exports-bundle";
+// export default faustwasm;
+// Bug with dts-bundle-generator
+
+export * from "./exports-bundle";
+
+(globalThis as any).faustwasm = faustwasm;

package/src/index-bundle.ts

@@ -0,0 +1,5 @@
+// import * as faustwasm from "./exports-bundle";
+// export default faustwasm;
+// Bug with dts-bundle-generator
+
+export * from "./exports-bundle";

package/src/index.ts

@@ -0,0 +1,5 @@
+// import * as faustwasm from "./exports";
+// export default faustwasm;
+// Bug with dts-bundle-generator
+
+export * from "./exports";

package/src/instantiateFaustModule.ts

@@ -0,0 +1,32 @@
+import factoryFn from "../libfaust-wasm/libfaust-wasm.cjs";
+import wasmBinary from "../libfaust-wasm/libfaust-wasm.wasm";
+import dataBinary from "../libfaust-wasm/libfaust-wasm.data";
+
+export const FaustModuleFactoryFn = factoryFn;
+export const FaustModuleFactoryWasm = wasmBinary;
+export const FaustModuleFactoryData = dataBinary;
+
+/**
+ * Instantiate `FaustModule` using bundled binaries. Module constructor and files can be overriden.
+ */
+const instantiateFaustModule = async (FaustModuleFactoryIn = factoryFn, dataBinaryIn = dataBinary, wasmBinaryIn = wasmBinary) => {
+    const g = globalThis as any;
+    if (g.AudioWorkletGlobalScope) {
+        g.importScripts = () => {};
+        g.self = { location: { href: "" } };
+    }
+    const faustModule = await FaustModuleFactoryIn({
+        wasmBinary: wasmBinaryIn,
+        getPreloadedPackage: (remotePackageName: string, remotePackageSize: number) => {
+            if (remotePackageName === "libfaust-wasm.data") return dataBinaryIn.buffer;
+            return new ArrayBuffer(0);
+        }
+    });
+    if (g.AudioWorkletGlobalScope) {
+		delete g.importScripts;
+		delete g.self;
+    }
+    return faustModule;
+};
+
+export default instantiateFaustModule;

package/src/instantiateFaustModuleFromFile.ts

@@ -0,0 +1,57 @@
+import type { FaustModuleFactory } from "./types";
+
+/**
+ * Load libfaust-wasm files, than instantiate libFaust
+ * @param jsFile path to `libfaust-wasm.js`
+ * @param dataFile path to `libfaust-wasm.data`
+ * @param wasmFile path to `libfaust-wasm.wasm`
+ */
+const instantiateFaustModuleFromFile = async (jsFile: string, dataFile = jsFile.replace(/c?js$/, "data"), wasmFile = jsFile.replace(/c?js$/, "wasm")) => {
+    let FaustModule: FaustModuleFactory;
+    let dataBinary: ArrayBuffer;
+    let wasmBinary: Uint8Array | ArrayBuffer;
+    const jsCodeHead = /var (.+) = \(/;
+    if (typeof window === "object") {
+        let jsCode = await (await fetch(jsFile)).text();
+        jsCode = `${jsCode}
+export default ${jsCode.match(jsCodeHead)?.[1]};
+`;
+        const jsFileMod = URL.createObjectURL(new Blob([jsCode], { type: "text/javascript" }));
+        FaustModule = (await import(/* webpackIgnore: true */jsFileMod)).default;
+        dataBinary = await (await fetch(dataFile)).arrayBuffer();
+        wasmBinary = new Uint8Array(await (await fetch(wasmFile)).arrayBuffer());
+    } else {
+        const { promises: fs } = await import("fs");
+        const { pathToFileURL } = await import("url");
+        let jsCode = (await fs.readFile(jsFile, { encoding: "utf-8" }));
+        jsCode = `
+import process from "process";
+import * as path from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __filename = fileURLToPath(import.meta.url);
+const require = createRequire(import.meta.url);
+
+${jsCode}
+
+export default ${jsCode.match(jsCodeHead)?.[1]};
+`;
+        const jsFileMod = jsFile.replace(/c?js$/, "mjs");
+        await fs.writeFile(jsFileMod, jsCode);
+        FaustModule = (await import(/* webpackIgnore: true */pathToFileURL(jsFileMod).href)).default;
+        await fs.unlink(jsFileMod);
+        dataBinary = (await fs.readFile(dataFile)).buffer;
+        wasmBinary = (await fs.readFile(wasmFile)).buffer;
+    }
+    const faustModule = await FaustModule({
+        wasmBinary,
+        getPreloadedPackage: (remotePackageName: string, remotePackageSize: number) => {
+            if (remotePackageName === "libfaust-wasm.data") return dataBinary;
+            return new ArrayBuffer(0);
+        }});
+    return faustModule;
+};
+
+export default instantiateFaustModuleFromFile;

package/src/types.ts

@@ -0,0 +1,234 @@
+export type FaustModuleFactory = EmscriptenModuleFactory<FaustModule>;
+
+export interface FaustModule extends EmscriptenModule {
+    ccall: typeof ccall;
+    cwrap: typeof cwrap;
+    UTF8ArrayToString(u8Array: number[], ptr: number, maxBytesToRead?: number): string;
+    stringToUTF8Array(str: string, outU8Array: number[], outIdx: number, maxBytesToWrite: number): number;
+    UTF8ToString: typeof UTF8ToString;
+    UTF16ToString: typeof UTF16ToString;
+    UTF32ToString: typeof UTF32ToString;
+    stringToUTF8: typeof stringToUTF8;
+    stringToUTF16: typeof stringToUTF16;
+    stringToUTF32: typeof stringToUTF32;
+    allocateUTF8: typeof allocateUTF8;
+    lengthBytesUTF8: typeof lengthBytesUTF8;
+    lengthBytesUTF16: typeof lengthBytesUTF16;
+    lengthBytesUTF32: typeof lengthBytesUTF32;
+    FS: typeof FS;
+    libFaustWasm: new () => LibFaustWasm;
+}
+
+export type FaustInfoType = "help" | "version" | "libdir" | "includedir" | "archdir" | "dspdir" | "pathslist";
+
+export interface IntVector {
+    size(): number;
+    get(i: number): number;
+    delete(): void;
+}
+
+export interface FaustDspWasm {
+    /* The C++ factory pointer as in integer */
+    cfactory: number;
+    /* The compiled wasm binary code */
+    data: IntVector;
+    /* The DSP JSON description */
+    json: string;
+}
+
+export interface LibFaustWasm {
+    /**
+     * Return the Faust compiler version.
+     * 
+     * @returns the version
+     */
+    version(): string;
+
+    /**
+     * Create a dsp factory from Faust code.
+     *
+     * @param name - an arbitrary name for the Faust module
+     * @param code - Faust dsp code
+     * @param args - the compiler options
+     * @param useInternalMemory - tell the compiler to generate static embedded memory or not
+     * @returns an opaque reference to the factory
+     */
+    createDSPFactory(name: string, code: string, args: string, useInternalMemory: boolean): FaustDspWasm;
+
+    /**
+     * Delete a dsp factory.
+     *
+     * @param cFactory - the factory C++ internal pointer as a number
+     */
+    deleteDSPFactory(cFactory: number): void;
+
+    /**
+     * Expand Faust code i.e. linearize included libraries.
+     *
+     * @param name - an arbitrary name for the Faust module
+     * @param code - Faust dsp code
+     * @param args - the compiler options
+     * @returns return the expanded dsp code
+     */
+    expandDSP(name: string, code: string, args: string): string;
+
+    /**
+     * 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
+     */
+    generateAuxFiles(name: string, code: string, args: string): boolean;
+
+    /**
+     * Delete all existing dsp factories.
+     */
+    deleteAllDSPFactories(): void;
+
+    /**
+     * Exception management: gives an error string
+     */
+    getErrorAfterException(): string;
+
+    /**
+     * Exception management: cleanup
+     * Should be called after each exception generated by the LibFaust methods.
+     */
+    cleanupAfterException(): void;
+
+    /**
+     * Get info about the embedded Faust engine
+     * @param what - the requested info
+     */
+    getInfos(what: FaustInfoType): string;
+}
+
+/**
+ * The Factory structure.
+ * cfactory: a "pointer" (as an integer) on the internal C++ factory 
+ * code: the WASM code as a binary array
+ * module: the compule WASM module
+ * json: the compiled DSP JSON description
+ * poly: whether the factory is a polyphonic one or not
+ */
+export interface FaustDspFactory extends Required<LooseFaustDspFactory> {}
+
+export interface LooseFaustDspFactory {
+    cfactory?: number;
+    code?: Uint8Array;
+    module: WebAssembly.Module;
+    json: string;
+    poly?: boolean;
+    shaKey?: string;
+}
+
+export interface FaustDspMeta {
+    name: string;
+    filename: string;
+    compile_options: string;
+    include_pathnames: string[];
+    inputs: number;
+    outputs: number;
+    size: number;
+    version: string;
+    library_list: string[];
+    meta: { [key: string]: string }[];
+    ui: FaustUIDescriptor;
+}
+
+export type FaustUIDescriptor = FaustUIGroup[];
+export type FaustUIItem = FaustUIInputItem | FaustUIOutputItem | FaustUIGroup;
+export interface FaustUIInputItem {
+    type: FaustUIInputType;
+    label: string;
+    address: string;
+    index: number;
+    init?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    meta?: FaustUIMeta[];
+}
+export interface FaustUIOutputItem {
+    type: FaustUIOutputType;
+    label: string;
+    address: string;
+    index: number;
+    min?: number;
+    max?: number;
+    meta?: FaustUIMeta[];
+}
+export interface FaustUIMeta {
+    [order: number]: string;
+    style?: string; // "knob" | "menu{'Name0':value0;'Name1':value1}" | "radio{'Name0':value0;'Name1':value1}" | "led";
+    unit?: string;
+    scale?: "linear" | "exp" | "log";
+    tooltip?: string;
+    hidden?: string;
+    [key: string]: string | undefined;
+}
+export type FaustUIGroupType = "vgroup" | "hgroup" | "tgroup";
+export type FaustUIOutputType = "hbargraph" | "vbargraph";
+export type FaustUIInputType = "vslider" | "hslider" | "button" | "checkbox" | "nentry";
+export interface FaustUIGroup {
+    type: FaustUIGroupType;
+    label: string;
+    items: FaustUIItem[];
+}
+export type FaustUIType = FaustUIGroupType | FaustUIOutputType | FaustUIInputType;
+
+export interface AudioParamDescriptor {
+    automationRate?: AutomationRate;
+    defaultValue?: number;
+    maxValue?: number;
+    minValue?: number;
+    name: string;
+}
+
+export interface AudioWorkletProcessor {
+    port: MessagePort;
+    process(inputs: Float32Array[][], outputs: Float32Array[][], parameters: Record<string, Float32Array>): boolean;
+}
+export declare const AudioWorkletProcessor: {
+    prototype: AudioWorkletProcessor;
+    parameterDescriptors: AudioParamDescriptor[];
+    new (options: AudioWorkletNodeOptions): AudioWorkletProcessor;
+};
+
+export interface AudioWorkletGlobalScope {
+    AudioWorkletGlobalScope: any;
+    globalThis: AudioWorkletGlobalScope;
+    registerProcessor: (name: string, constructor: new (options: any) => AudioWorkletProcessor) => void;
+    currentFrame: number;
+    currentTime: number;
+    sampleRate: number;
+    AudioWorkletProcessor: typeof AudioWorkletProcessor;
+}
+
+export interface InterfaceFFT {
+    forward(arr: ArrayLike<number> | ((arr: Float32Array) => any)): Float32Array;
+    inverse(arr: ArrayLike<number> | ((arr: Float32Array) => any)): Float32Array;
+    dispose(): void;
+}
+export declare const InterfaceFFT: {
+    new (size: number): InterfaceFFT;
+}
+
+export type TWindowFunction = (index: number, length: number, ...args: any[]) => number;
+export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
+export type TypedArrayConstructor = typeof Int8Array | typeof Uint8Array | typeof Int16Array | typeof Uint16Array | typeof Int32Array | typeof Uint32Array | typeof Uint8ClampedArray | typeof Float32Array | typeof Float64Array;
+
+export declare const FFTUtils: {
+    /** Inject window functions as array, no need to add rectangular (no windowing) */
+    windowFunctions?: TWindowFunction[];
+    /** Get a FFT interface constructor */
+    getFFT: () => Promise<typeof InterfaceFFT>;
+    /** Convert from FFTed (spectral) signal to three arrays for Faust processor's input, fft is readonly, real/imag/index length = *fftSize* / 2 + 1; fft length depends on the FFT implementation */
+    fftToSignal: (fft: Float32Array | Float64Array, real: Float32Array | Float64Array, imag?: Float32Array | Float64Array, index?: Float32Array | Float64Array) => any;
+    /** Convert from Faust processor's output to spectral data for Inversed FFT, real/imag are readonly, real/imag length = *fftSize* / 2 + 1; fft length depends on the FFT implementation */
+    signalToFFT: (real: Float32Array | Float64Array, imag: Float32Array | Float64Array, fft: Float32Array | Float64Array) => any;
+    /** Convert from Faust processor's output to direct audio output, real/imag are readonly, fft length = fftSize = (real/imag length - 1) * 2 */
+    signalToNoFFT: (real: Float32Array | Float64Array, imag: Float32Array | Float64Array, fft: Float32Array | Float64Array) => any;
+}

package/test/clarinet.dsp

@@ -0,0 +1 @@
+import("stdfaust.lib"); process = pm.clarinet_ui_MIDI <: _,_;