@grame/faustwasm 0.2.2 → 0.3.0

package/src/FaustSensors.ts

@@ -0,0 +1,370 @@
+export interface AccParams {
+    isEnabled: boolean;
+    acc: string;
+    address: string;
+    min: number;
+    max: number;
+    init: number;
+    label: string;
+}
+
+/** Enum describing the axis of the accelerometer or gyroscope */
+export enum Axis { x, y, z }
+
+/** Enum describing the curve of the accelerometer */
+export enum Curve { Up, Down, UpDown, DownUp }
+
+/** Object describing value off accelerometer metadata values */
+class AccMeta {
+    axis: Axis;
+    curve: Curve;
+    amin: number;
+    amid: number;
+    amax: number;
+}
+
+interface Range {
+    fLo: number;
+    fHi: number;
+    clip(x: number): number;
+}
+
+interface InterpolateObject {
+    amin: number;
+    amax: number;
+}
+interface Interpolator {
+    fRange: Range;
+    fCoef: number;
+    fOffset: number;
+    returnMappedValue(v: number): number;
+    getLowHigh(amin: number, amax: number): InterpolateObject;
+}
+
+interface InterpolateObject3pt {
+    amin: number;
+    amid: number;
+    amax: number;
+}
+interface Interpolator3pt {
+    fSegment1: Interpolator;
+    fSegment2: Interpolator;
+    fMid: number;
+    returnMappedValue(v: number): number;
+    getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt;
+}
+
+/**
+ * ValueConverter interface
+ */
+interface ValueConverter {
+    uiToFaust(x: number): number;
+    faustToUi(x: number): number;
+}
+
+/**
+ * UpdatableValueConverter interface
+ */
+export interface UpdatableValueConverter extends ValueConverter {
+    fActive: boolean;
+
+    setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void;
+    getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt;
+
+    setActive(onOff: boolean): void;
+    getActive(): boolean;
+}
+
+
+
+export default class FaustSensors {
+    /**
+     * Function to convert a number to an axis type
+     * 
+     * @param value number
+     * @returns axis type
+     */
+    static convertToAxis(value: number): Axis {
+        switch (value) {
+            case 0:
+                return Axis.x;
+            case 1:
+                return Axis.y;
+            case 2:
+                return Axis.z;
+            default:
+                console.error("Error: Axis not found value: " + value);
+                return Axis.x;
+        }
+    }
+    /**
+     * Function to convert a number to a curve type
+     * 
+     * @param value number
+     * @returns curve type
+     */
+    static convertToCurve(value: number): Curve {
+        switch (value) {
+            case 0:
+                return Curve.Up;
+            case 1:
+                return Curve.Down;
+            case 2:
+                return Curve.UpDown;
+            case 3:
+                return Curve.DownUp;
+            default:
+                console.error("Error: Curve not found value: " + value);
+                return Curve.Up;
+        }
+    }
+
+    // Converter objects use to map acc and Faust value
+    static _Range: new (x: number, y: number) => Range;
+    static get Range() {
+        if (!this._Range) {
+            this._Range = class {
+                fLo: number;
+                fHi: number;
+
+                constructor(x: number, y: number) {
+                    this.fLo = Math.min(x, y);
+                    this.fHi = Math.max(x, y);
+                }
+
+                clip(x: number): number {
+                    if (x < this.fLo) return this.fLo;
+                    if (x > this.fHi) return this.fHi;
+                    return x;
+                }
+            };
+        }
+        return this._Range;
+    }
+
+    static _Interpolator: new (lo: number, hi: number, v1: number, v2: number) => Interpolator;
+    /**
+     * Interpolator class
+     */
+    static get Interpolator() {
+        if (!this._Interpolator) {
+            this._Interpolator = class {
+                fRange: Range;
+                fCoef: number;
+                fOffset: number;
+
+                constructor(lo: number, hi: number, v1: number, v2: number) {
+                    this.fRange = new FaustSensors.Range(lo, hi);
+                    if (hi !== lo) {
+                        // regular case
+                        this.fCoef = (v2 - v1) / (hi - lo);
+                        this.fOffset = v1 - lo * this.fCoef;
+                    } else {
+                        // degenerate case, avoids division by zero
+                        this.fCoef = 0;
+                        this.fOffset = (v1 + v2) / 2;
+                    }
+                }
+                returnMappedValue(v: number): number {
+                    var x = this.fRange.clip(v);
+                    return this.fOffset + x * this.fCoef;
+                }
+                getLowHigh(amin: number, amax: number): InterpolateObject {
+                    return { amin: this.fRange.fLo, amax: this.fRange.fHi };
+                }
+            };
+        }
+        return this._Interpolator;
+    }
+
+    static _Interpolator3pt: new (lo: number, mid: number, hi: number, v1: number, vMid: number, v2: number) => Interpolator3pt;
+    /**
+     * Interpolator3pt class, combine two interpolators
+     */
+    static get Interpolator3pt() {
+        if (!this._Interpolator3pt) {
+            this._Interpolator3pt = class {
+
+                fSegment1: Interpolator;
+                fSegment2: Interpolator;
+                fMid: number;
+
+                constructor(lo: number, mid: number, hi: number, v1: number, vMid: number, v2: number) {
+                    this.fSegment1 = new FaustSensors.Interpolator(lo, mid, v1, vMid);
+                    this.fSegment2 = new FaustSensors.Interpolator(mid, hi, vMid, v2);
+                    this.fMid = mid;
+                }
+                returnMappedValue(x: number): number {
+                    return (x < this.fMid) ? this.fSegment1.returnMappedValue(x) : this.fSegment2.returnMappedValue(x);
+                }
+
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    var lowHighSegment1 = this.fSegment1.getLowHigh(amin, amid);
+                    var lowHighSegment2 = this.fSegment2.getLowHigh(amid, amax);
+                    return { amin: lowHighSegment1.amin, amid: lowHighSegment2.amin, amax: lowHighSegment2.amax };
+                }
+            }
+
+        }
+        return this._Interpolator3pt;
+    }
+    static _UpConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    /**
+     * UpConverter class, convert accelerometer value to Faust value
+     */
+    static get UpConverter() {
+        if (!this._UpConverter) {
+            this._UpConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator3pt;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmin, fmid, fmax);
+                    this.fF2A = new FaustSensors.Interpolator3pt(fmin, fmid, fmax, amin, amid, amax);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, min, init, max);
+                    this.fF2A = new FaustSensors.Interpolator3pt(min, init, max, amin, amid, amax);
+                }
+
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+
+        }
+        return this._UpConverter;
+    }
+    static _DownConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    /**
+     * DownConverter class, convert accelerometer value to Faust value
+     */
+    static get DownConverter() {
+        if (!this._DownConverter) {
+            this._DownConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator3pt;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmax, fmid, fmin);
+                    this.fF2A = new FaustSensors.Interpolator3pt(fmin, fmid, fmax, amax, amid, amin);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, max, init, min);
+                    this.fF2A = new FaustSensors.Interpolator3pt(min, init, max, amax, amid, amin);
+                }
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+
+        }
+        return this._DownConverter;
+    }
+    static _UpDownConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    /**
+     * UpDownConverter class, convert accelerometer value to Faust value
+     */
+    static get UpDownConverter() {
+        if (!this._UpDownConverter) {
+            this._UpDownConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmin, fmax, fmin);
+                    this.fF2A = new FaustSensors.Interpolator(fmin, fmax, amin, amax);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, min, max, min);
+                    this.fF2A = new FaustSensors.Interpolator(min, max, amin, amax);
+                }
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+
+        }
+        return this._UpDownConverter;
+    }
+    /**
+     * DownUpConverter class, convert accelerometer value to Faust value
+     */
+    static _DownUpConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    static get DownUpConverter() {
+        if (!this._DownUpConverter) {
+            this._DownUpConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmax, fmin, fmax);
+                    this.fF2A = new FaustSensors.Interpolator(fmin, fmax, amin, amax);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, max, min, max);
+                    this.fF2A = new FaustSensors.Interpolator(min, max, amin, amax);
+                }
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+        }
+        return this._DownUpConverter;
+    }
+    /**
+     * Public function to build the accelerometer handler
+     *
+     * @returns `UpdatableValueConverter` built for the given curve
+     */
+    static buildHandler(curve: Curve, amin: number, amid: number, amax: number, min: number, init: number, max: number): UpdatableValueConverter {
+        switch (curve) {
+            case Curve.Up:
+                return new FaustSensors.UpConverter(amin, amid, amax, min, init, max);
+            case Curve.Down:
+                return new FaustSensors.DownConverter(amin, amid, amax, min, init, max);
+            case Curve.UpDown:
+                return new FaustSensors.UpDownConverter(amin, amid, amax, min, init, max);
+            case Curve.DownUp:
+                return new FaustSensors.DownUpConverter(amin, amid, amax, min, init, max);
+            default:
+                return new FaustSensors.UpConverter(amin, amid, amax, min, init, max);
+        }
+    }
+}

package/src/FaustWebAudioDsp.ts

@@ -1,5 +1,6 @@
 import type { FaustMonoDspInstance, FaustPolyDspInstance, IFaustDspInstance } from "./FaustDspInstance";
 import type { AudioData, FaustDspMeta, FaustUIDescriptor, FaustUIGroup, FaustUIInputItem, FaustUIItem, LooseFaustDspFactory } from "./types";
+import FaustSensors, { Axis, Curve, UpdatableValueConverter } from "./FaustSensors";
 
 // Public API
 export type OutputParamHandler = (path: string, value: number) => void;
@@ -10,6 +11,16 @@ export type MetadataHandler = (key: string, value: string) => void;
 // Implementation API
 export type UIHandler = (item: FaustUIItem) => void;
 
+// Accelerometer or gyroscope handler
+export type SensorEventHandler = (val: number) => void;
+
+// Define a type for the accelerometer or gyroscope handlers
+export type SensorEventHandlers = {
+    x: SensorEventHandler[];
+    y: SensorEventHandler[];
+    z: SensorEventHandler[];
+};
+
 /** Definition of the AudioBufferItem type */
 export interface AudioBufferItem {
     pathName: string;
@@ -134,16 +145,16 @@ export class WasmAllocator {
 export class Soundfile {
     /** Maximum number of soundfile parts. */
     static get MAX_SOUNDFILE_PARTS() { return 256; }
-    
+
     /** Maximum number of channels. */
     static get MAX_CHAN() { return 64; }
-    
+
     /** Maximum buffer size in frames. */
     static get BUFFER_SIZE() { return 1024; }
-    
+
     /** Default sample rate. */
     static get SAMPLE_RATE() { return 44100; }
-    
+
     /** Pointer to the soundfile structure in wasm memory */
     private readonly fPtr: number;
     private readonly fBuffers: number;
@@ -332,10 +343,10 @@ export class Soundfile {
 }
 
 /**
- * DSP implementation: mimic the C++ 'dsp' class:
+ * DSP implementation that mimic the C++ 'dsp' class:
  * - adding MIDI control: metadata are decoded and incoming MIDI messages will control the associated controllers
  * - an output handler can be set to treat produced output controllers (like 'bargraph') 
- * - regular controllers are handled using setParamValue/getParamValue
+ * - regular controllers are handled using setParamValue/getParamValue and getParams methods
  */
 export interface IFaustBaseWebAudioDsp {
     /**
@@ -464,13 +475,6 @@ export interface IFaustBaseWebAudioDsp {
      */
     getMeta(): FaustDspMeta;
 
-    /**
-     * Get DSP JSON description with its UI and metadata.
-     *
-     * @return the DSP JSON description
-     */
-    getJSON(): string;
-
     /**
      * Get DSP UI description.
      *
@@ -485,6 +489,13 @@ export interface IFaustBaseWebAudioDsp {
     */
     getDescriptors(): FaustUIInputItem[];
 
+    /**
+     * Get DSP JSON description with its UI and metadata.
+     *
+     * @return the DSP JSON description
+     */
+    getJSON(): string;
+
     /**
      * Start the DSP.
      */
@@ -499,6 +510,16 @@ export interface IFaustBaseWebAudioDsp {
      * Destroy the DSP.
      */
     destroy(): void;
+
+    /** Indicating if the DSP handles the accelerometer */
+    readonly hasAccInput: boolean;
+    /** Accelerometer handling */
+    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>): void;
+
+    /** Indicating if the DSP handles the gyroscope */
+    readonly hasGyrInput: boolean;
+    /** Gyroscope handling */
+    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
 }
 
 export interface IFaustMonoWebAudioDsp extends IFaustBaseWebAudioDsp { }
@@ -557,6 +578,10 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
     /** Keep the end of memory offset before soundfiles */
     protected fEndMemory: number;
 
+    // Accelerometer handling
+    protected fAcc: SensorEventHandlers; // array of accelerometer handlers on x,y,y axes, to be called with DeviceMotionEvent
+    protected fGyr: SensorEventHandlers; // array of gyroscope handlers on alpha,beta,gama axes, to be called with DeviceMotionEvent
+
     // Buffers in wasm memory
     protected fAudioInputs!: number;
     protected fAudioOutputs!: number;
@@ -579,18 +604,30 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
             this.fInputsItems.push(item.address);
             this.fPathTable[item.address] = item.index;
             this.fDescriptor.push(item);
-            // Parse 'midi' metadata
             if (!item.meta) return;
             item.meta.forEach((meta) => {
-                const { midi } = meta;
-                if (!midi) return;
-                const strMidi = midi.trim();
-                if (strMidi === "pitchwheel") {
-                    this.fPitchwheelLabel.push({ path: item.address, min: item.min as number, max: item.max as number });
-                } else {
-                    const matched = strMidi.match(/^ctrl\s(\d+)/);
-                    if (!matched) return;
-                    this.fCtrlLabel[parseInt(matched[1])].push({ path: item.address, min: item.min as number, max: item.max as number });
+                const { midi, acc, gyr } = meta;
+                // Parse 'midi' metadata
+                if (midi) {
+                    const strMidi = midi.trim();
+                    if (strMidi === "pitchwheel") {
+                        this.fPitchwheelLabel.push({ path: item.address, min: item.min as number, max: item.max as number });
+                    } else {
+                        const matched = strMidi.match(/^ctrl\s(\d+)/);
+                        if (matched) {
+                            this.fCtrlLabel[parseInt(matched[1])].push({ path: item.address, min: item.min as number, max: item.max as number });
+                        }
+                    }
+                }
+                // Parse 'acc' metadata
+                if (acc) {
+                    const numAcc: number[] = acc.trim().split(" ").map(Number);
+                    this.setupAccHandler(item.address, FaustSensors.convertToAxis(numAcc[0]), FaustSensors.convertToCurve(numAcc[1]), numAcc[2], numAcc[3], numAcc[4], item.min as number, item.init as number, item.max as number);
+                }
+                // Parse 'gyr' metadata
+                if (gyr) {
+                    const numAcc: number[] = gyr.trim().split(" ").map(Number);
+                    this.setupGyrHandler(item.address, FaustSensors.convertToAxis(numAcc[0]), FaustSensors.convertToCurve(numAcc[1]), numAcc[2], numAcc[3], numAcc[4], item.min as number, item.init as number, item.max as number);
                 }
             });
         } else if (item.type === "soundfile") {
@@ -610,6 +647,8 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
         this.fPtrSize = sampleSize; // Done on wast/wasm backend side
         this.fSampleSize = sampleSize;
         this.fSoundfileBuffers = soundfiles;
+        this.fAcc = { x: [], y: [], z: [] };
+        this.fGyr = { x: [], y: [], z: [] };
     }
 
     // Tools
@@ -647,6 +686,65 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
         return trimmed.split(";").map(str => str.length <= 2 ? '' : str.substring(1, str.length - 1));
     }
 
+    get hasAccInput() { return this.fAcc.x.length + this.fAcc.y.length + this.fAcc.z.length > 0; }
+    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>) {
+
+        // Get accelerometervalues
+        const { x, y, z } = accelerationIncludingGravity;
+
+        // Call the accelerometer handlers
+        if (x !== null) this.fAcc.x.forEach(handler => handler(x));
+        if (y !== null) this.fAcc.y.forEach(handler => handler(y));
+        if (z !== null) this.fAcc.z.forEach(handler => handler(z));
+    }
+
+    get hasGyrInput() { return this.fGyr.x.length + this.fGyr.y.length + this.fGyr.z.length > 0; }
+    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+
+        // Get gyroscope values
+        const { alpha, beta, gamma } = event;
+
+        // Call the gyroscope handlers
+        if (alpha !== null) this.fGyr.x.forEach(handler => handler(alpha));
+        if (beta !== null) this.fGyr.y.forEach(handler => handler(beta));
+        if (gamma !== null) this.fGyr.z.forEach(handler => handler(gamma));
+    }
+
+    /** Build the accelerometer handler */
+    private setupAccHandler(path: string, axis: Axis, curve: Curve, amin: number, amid: number, amax: number, min: number, init: number, max: number) {
+
+        const handler: UpdatableValueConverter = FaustSensors.buildHandler(curve, amin, amid, amax, min, init, max);
+        switch (axis) {
+            case Axis.x:
+                this.fAcc.x.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.y:
+                this.fAcc.y.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.z:
+                this.fAcc.z.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+        }
+    }
+
+    /** Build the gyroscope handler */
+    private setupGyrHandler(path: string, axis: Axis, curve: Curve, amin: number, amid: number, amax: number, min: number, init: number, max: number) {
+
+        const handler: UpdatableValueConverter = FaustSensors.buildHandler(curve, amin, amid, amax, min, init, max);
+        switch (axis) {
+            case Axis.x:
+                this.fGyr.x.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.y:
+                this.fGyr.y.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.z:
+                this.fGyr.z.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+        }
+    }
+
+
     static extractUrlsFromMeta(dspMeta: FaustDspMeta): string[] {
         // Find the entry with the "soundfiles" key
         const soundfilesEntry = dspMeta.meta.find(entry => entry.soundfiles !== undefined);
@@ -911,6 +1009,7 @@ export class FaustMonoWebAudioDsp extends FaustBaseWebAudioDsp implements IFaust
             // Init soundfiles memory
             this.initSoundfileMemory(allocator, this.fDSP);
         }
+
     }
 
     private initMemory(): number {