@grame/faustwasm 0.7.10 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grame/faustwasm",
-  "version": "0.7.10",
+  "version": "0.8.2",
   "description": "WebAssembly version of Faust Compiler",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
@@ -39,7 +39,7 @@
   "homepage": "https://github.com/grame-cncm/faustwasm#readme",
   "devDependencies": {
     "@aws-crypto/sha256-js": "^5.2.0",
-    "@shren/faust-ui": "^1.1.13",
+    "@shren/faust-ui": "^1.1.16",
     "@types/node": "^20.12.7",
     "@types/webmidi": "^2.0.10",
     "@webaudiomodules/api": "^2.0.0-alpha.6",

package/src/FaustAudioWorkletCommunicator.ts

@@ -0,0 +1,143 @@
+
+/**
+ * Layout:
+ * 
+ * 
+ * invert-isAndroid (uint8)
+ * new-acc-data-available (uint8)
+ * new-gyr-data-available (uint8)
+ * empty (uint8)
+ * 
+ * acc.x, acc.y, acc.z (f32)
+ * 
+ * gyr.alpha, gyr.beta, gyr.gamma (f32)
+ */
+export class FaustAudioWorkletCommunicator {
+    protected readonly port: MessagePort;
+    protected readonly supportSharedArrayBuffer: boolean;
+    protected readonly byteLength: number;
+    protected uin8Invert: Uint8ClampedArray;
+    protected uin8NewAccData: Uint8ClampedArray;
+    protected uin8NewGyrData: Uint8ClampedArray;
+    protected f32Acc: Float32Array;
+    protected f32Gyr: Float32Array;
+    constructor(port: MessagePort) {
+        this.port = port;
+        this.supportSharedArrayBuffer = !!globalThis.SharedArrayBuffer;
+        this.byteLength
+            = 4 * Uint8Array.BYTES_PER_ELEMENT
+            + 3 * Float32Array.BYTES_PER_ELEMENT
+            + 3 * Float32Array.BYTES_PER_ELEMENT;
+    }
+    initializeBuffer(ab: SharedArrayBuffer | ArrayBuffer) {
+        let ptr = 0;
+        this.uin8Invert = new Uint8ClampedArray(ab, ptr, 1);
+        ptr += Uint8ClampedArray.BYTES_PER_ELEMENT;
+        this.uin8NewAccData = new Uint8ClampedArray(ab, ptr, 1);
+        ptr += Uint8ClampedArray.BYTES_PER_ELEMENT;
+        this.uin8NewGyrData = new Uint8ClampedArray(ab, ptr, 1);
+        ptr += Uint8ClampedArray.BYTES_PER_ELEMENT;
+        ptr += Uint8ClampedArray.BYTES_PER_ELEMENT;; // empty
+        this.f32Acc = new Float32Array(ab, ptr, 3);
+        ptr += 3 * Float32Array.BYTES_PER_ELEMENT;
+        this.f32Gyr = new Float32Array(ab, ptr, 3);
+        ptr += 3 * Float32Array.BYTES_PER_ELEMENT;
+    }
+    setNewAccDataAvailable(value: boolean) {
+        if (!this.uin8NewAccData) return;
+        this.uin8NewAccData[0] = +value;
+    }
+    getNewAccDataAvailable() {
+        return !!this.uin8NewAccData?.[0];
+    }
+    setNewGyrDataAvailable(value: boolean) {
+        if (!this.uin8NewGyrData) return;
+        this.uin8NewGyrData[0] = +value;
+    }
+    getNewGyrDataAvailable() {
+        return !!this.uin8NewGyrData?.[0];
+    }
+    setAcc({ x, y, z }: { x: number, y: number, z: number }, invert = false) {
+        if (!this.supportSharedArrayBuffer) {
+            const e = { type: "acc", data: { x, y, z }, invert };
+            this.port.postMessage(e);
+        }
+        if (!this.uin8NewAccData) return;
+        this.uin8Invert[0] = +invert;
+        this.f32Acc[0] = x;
+        this.f32Acc[1] = y;
+        this.f32Acc[2] = z;
+        this.uin8NewAccData[0] = 1;
+    }
+    getAcc() {
+        if (!this.uin8NewAccData) return;
+        const invert = !!this.uin8Invert[0];
+        const [x, y, z] = this.f32Acc;
+        return { x, y, z, invert };
+    }
+    setGyr({ alpha, beta, gamma }: { alpha: number, beta: number, gamma: number }) {
+        if (!this.supportSharedArrayBuffer) {
+            const e = { type: "gyr", data: { alpha, beta, gamma } };
+            this.port.postMessage(e);
+        }
+        if (!this.uin8NewGyrData) return;
+        this.f32Gyr[0] = alpha;
+        this.f32Gyr[1] = beta;
+        this.f32Gyr[2] = gamma;
+        this.uin8NewGyrData[0] = 1;
+    }
+    getGyr() {
+        if (!this.uin8NewGyrData) return;
+        const [alpha, beta, gamma] = this.f32Gyr;
+        return { alpha, beta, gamma };
+    }
+}
+
+export class FaustAudioWorkletNodeCommunicator extends FaustAudioWorkletCommunicator {
+    constructor(port: MessagePort) {
+        super(port);
+        if (this.supportSharedArrayBuffer) {
+            const sab = new SharedArrayBuffer(this.byteLength);
+            this.initializeBuffer(sab);
+            this.port.postMessage({ type: "initSab", sab });
+        } else {
+            const ab = new ArrayBuffer(this.byteLength);
+            this.initializeBuffer(ab);
+        }
+    }
+}
+
+export class FaustAudioWorkletProcessorCommunicator extends FaustAudioWorkletCommunicator {
+    constructor(port: MessagePort) {
+        super(port);
+
+        if (this.supportSharedArrayBuffer) {
+            this.port.addEventListener("message", (event) => {
+                const { data } = event;
+                if (data.type === "initSab") {
+                    this.initializeBuffer(data.sab);
+                }
+            });
+        } else {
+            const ab = new ArrayBuffer(this.byteLength);
+            this.initializeBuffer(ab);
+            this.port.addEventListener("message", (event) => {
+                const msg = event.data;
+
+                switch (msg.type) {
+                    // Sensors messages
+                    case "acc": {
+                        this.setAcc(msg.data, msg.invert);
+                        break;
+                    }
+                    case "gyr": {
+                        this.setGyr(msg.data);
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            });
+        }
+    }
+}

package/src/FaustAudioWorkletNode.ts

@@ -1,6 +1,7 @@
 import { OutputParamHandler, ComputeHandler, PlotHandler, UIHandler, MetadataHandler, FaustBaseWebAudioDsp, IFaustMonoWebAudioDsp, IFaustPolyWebAudioDsp } from "./FaustWebAudioDsp";
 import type { FaustAudioWorkletNodeOptions } from "./FaustAudioWorkletProcessor";
 import type { LooseFaustDspFactory, FaustDspMeta, FaustUIInputItem, FaustUIItem } from "./types";
+import { FaustAudioWorkletNodeCommunicator } from "./FaustAudioWorkletCommunicator";
 
 /**
  * Base class for Monophonic and Polyphonic AudioWorkletNode
@@ -15,6 +16,7 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
     protected fPlotHandler: PlotHandler | null;
     protected fUICallback: UIHandler;
     protected fDescriptor: FaustUIInputItem[];
+    protected fCommunicator: FaustAudioWorkletNodeCommunicator;
     #hasAccInput = false;
     #hasGyrInput = false;
 
@@ -60,17 +62,20 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
 
         FaustBaseWebAudioDsp.parseUI(this.fJSONDsp.ui, this.fUICallback);
 
+        this.fCommunicator = new FaustAudioWorkletNodeCommunicator(this.port);
+
         // 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);
-            }
-        };
+        this.port.addEventListener("message", this.handleMessageAux);
+        this.port.start();
     }
 
-    // Public API
+    protected handleMessageAux = (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);
+        }
+    };
 
     // Accelerometer and gyroscope handlers
     private handleDeviceMotion = ({ accelerationIncludingGravity }: DeviceMotionEvent) => {
@@ -84,25 +89,14 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         this.propagateGyr({ alpha, beta, gamma });
     };
 
+    // Public API
+
     /** Setup accelerometer and gyroscope handlers */
     async startSensors() {
         if (this.hasAccInput) {
             if (window.DeviceMotionEvent) {
-                if (typeof (window.DeviceMotionEvent as any).requestPermission === "function") { // for iOS 13+
-                    try {
-                        const response = await (window.DeviceMotionEvent as any).requestPermission();
-                        if (response === "granted") {
-                            window.addEventListener("devicemotion", this.handleDeviceMotion, true);
-                        } else if (response === "denied") {
-                            alert('You have denied access to motion and orientation data. To enable it, go to Settings > Safari > Motion & Orientation Access.');
-                            throw new Error("Unable to access the accelerometer.");
-                        }
-                    } catch (error) {
-                        console.error(error);
-                    }
-                } else {
-                    window.addEventListener("devicemotion", this.handleDeviceMotion, true);
-                }
+                // iOS 13+ requires a user gesture to enable DeviceMotionEvent, to be done in the main thread
+                window.addEventListener("devicemotion", this.handleDeviceMotion, true);
             } else {
                 // Browser doesn't support DeviceMotionEvent
                 console.log("Cannot set the accelerometer handler.");
@@ -110,21 +104,8 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         }
         if (this.hasGyrInput) {
             if (window.DeviceMotionEvent) {
-                if (typeof (window.DeviceOrientationEvent as any).requestPermission === "function") { // for iOS 13+
-                    try {
-                        const response = await (window.DeviceOrientationEvent as any).requestPermission();
-                        if (response === "granted") {
-                            window.addEventListener("deviceorientation", this.handleDeviceOrientation, true);
-                        } else if (response === "denied") {
-                            alert('You have denied access to motion and orientation data. To enable it, go to Settings > Safari > Motion & Orientation Access.');
-                            throw new Error("Unable to access the gyroscope.");
-                        }
-                    } catch (error) {
-                        console.error(error);
-                    }
-                } else {
-                    window.addEventListener("deviceorientation", this.handleDeviceOrientation, true);
-                }
+                // iOS 13+ requires a user gesture to enable DeviceMotionEvent, to be done in the main thread
+                window.addEventListener("deviceorientation", this.handleDeviceOrientation, true);
             } else {
                 // Browser doesn't support DeviceMotionEvent
                 console.log("Cannot set the gyroscope handler.");
@@ -140,6 +121,7 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
             window.removeEventListener("deviceorientation", this.handleDeviceOrientation, true);
         }
     }
+
     setOutputParamHandler(handler: OutputParamHandler | null) {
         this.fOutputHandler = handler;
     }
@@ -166,6 +148,7 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
     getPlotHandler(): PlotHandler | null {
         return this.fPlotHandler;
     }
+
     setupWamEventHandler() {
         this.port.postMessage({ type: "setupWamEventHandler" });
     }
@@ -208,17 +191,19 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
     }
 
     get hasAccInput() { return this.#hasAccInput; }
+
     propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>, invert: boolean = false) {
         if (!accelerationIncludingGravity) return;
-        const e = { type: "acc", data: accelerationIncludingGravity, invert: invert };
-        this.port.postMessage(e);
+        const { x, y, z } = accelerationIncludingGravity;
+        this.fCommunicator.setAcc({ x: x!, y: y!, z: z! }, invert);
     }
 
     get hasGyrInput() { return this.#hasGyrInput; }
+
     propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
         if (!event) return;
-        const e = { type: "gyr", data: event };
-        this.port.postMessage(e);
+        const { alpha, beta, gamma } = event;
+        this.fCommunicator.setGyr({ alpha: alpha!, beta: beta!, gamma: gamma! });
     }
 
     setParamValue(path: string, value: number) {

package/src/FaustAudioWorkletProcessor.ts

@@ -1,3 +1,4 @@
+import type { FaustAudioWorkletProcessorCommunicator } from "./FaustAudioWorkletCommunicator";
 import type FaustWasmInstantiator from "./FaustWasmInstantiator";
 import type { FaustBaseWebAudioDsp, FaustWebAudioDspVoice, FaustMonoWebAudioDsp, FaustPolyWebAudioDsp } from "./FaustWebAudioDsp";
 import type { AudioParamDescriptor, AudioWorkletGlobalScope, LooseFaustDspFactory, FaustDspMeta, FaustUIItem } from "./types";
@@ -19,6 +20,7 @@ export interface FaustAudioWorkletProcessorDependencies<Poly extends boolean = f
     FaustPolyWebAudioDsp: Poly extends true ? typeof FaustPolyWebAudioDsp : undefined;
     FaustWebAudioDspVoice: Poly extends true ? typeof FaustWebAudioDspVoice : undefined;
     FaustWasmInstantiator: typeof FaustWasmInstantiator;
+    FaustAudioWorkletProcessorCommunicator: typeof FaustAudioWorkletProcessorCommunicator;
 }
 export interface FaustAudioWorkletNodeOptions<Poly extends boolean = false> extends AudioWorkletNodeOptions {
     processorOptions: Poly extends true ? FaustPolyAudioWorkletProcessorOptions : FaustMonoAudioWorkletProcessorOptions;
@@ -52,7 +54,8 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
 
     const {
         FaustBaseWebAudioDsp,
-        FaustWasmInstantiator
+        FaustWasmInstantiator,
+        FaustAudioWorkletProcessorCommunicator
     } = dependencies;
 
     const {
@@ -79,7 +82,7 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
     /**
      * Base class for Monophonic and Polyphonic AudioWorkletProcessor
      */
-    class FaustAudioWorkletProcessor<Poly extends boolean = false> extends AudioWorkletProcessor {
+    abstract 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;
@@ -87,18 +90,19 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
         protected paramValuesCache: Record<string, number> = {};
 
         protected wamInfo?: { moduleId: string; instanceId: string };
+        protected fCommunicator: FaustAudioWorkletProcessorCommunicator;
 
         constructor(options: FaustAudioWorkletNodeOptions<Poly>) {
             super(options);
 
             // Setup port message handling
-            this.port.onmessage = (e: MessageEvent) => this.handleMessageAux(e);
+            this.fCommunicator = new FaustAudioWorkletProcessorCommunicator(this.port);
 
             const { parameterDescriptors } = (this.constructor as typeof AudioWorkletProcessor);
             parameterDescriptors.forEach((pd) => {
                 this.paramValuesCache[pd.name] = pd.defaultValue || 0;
             })
-            
+
             const { moduleId, instanceId } = options.processorOptions;
             if (!moduleId || !instanceId) return;
             this.wamInfo = { moduleId, instanceId };
@@ -120,7 +124,7 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
         setupWamEventHandler() {
             if (!this.wamInfo) return;
             const { moduleId, instanceId } = this.wamInfo;
-	        const { webAudioModules } = (globalThis as unknown as WamAudioWorkletGlobalScope);
+            const { webAudioModules } = (globalThis as unknown as WamAudioWorkletGlobalScope);
             const ModuleScope = webAudioModules.getModuleScope(moduleId) as WamParamMgrSDKBaseModuleScope;
             const paramMgrProcessor = ModuleScope?.paramMgrProcessors?.[instanceId];
             if (!paramMgrProcessor) return;
@@ -140,6 +144,21 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
                     this.paramValuesCache[path] = paramValue;
                 }
             }
+            if (this.fCommunicator.getNewAccDataAvailable()) {
+                const acc = this.fCommunicator.getAcc();
+                if (acc) {
+                    this.fCommunicator.setNewAccDataAvailable(false);
+                    const { invert, ...data } = acc;
+                    this.propagateAcc(data, invert);
+                }
+            }
+            if (this.fCommunicator.getNewGyrDataAvailable()) {
+                const gyr = this.fCommunicator.getGyr();
+                if (gyr) {
+                    this.fCommunicator.setNewGyrDataAvailable(false);
+                    this.propagateGyr(gyr);
+                }
+            }
 
             return this.fDSPCode.compute(inputs[0], outputs[0]);
         }
@@ -148,15 +167,6 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
             const msg = e.data;
 
             switch (msg.type) {
-                // Sensors messages
-                case "acc": {
-                    this.propagateAcc(msg.data, msg.invert);
-                    break;
-                }
-                case "gyr": {
-                    this.propagateGyr(msg.data);
-                    break;
-                }
                 // Generic MIDI message
                 case "midi": {
                     this.midiMessage(msg.data);
@@ -248,11 +258,19 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
             // Create Monophonic DSP
             this.fDSPCode = new FaustMonoWebAudioDsp(instance, sampleRate, sampleSize, 128, factory.soundfiles);
 
+            // Setup port message handling
+            this.port.addEventListener("message", this.handleMessageAux);
+            this.port.start();
+
             // Setup output handler
             this.fDSPCode.setOutputParamHandler((path, value) => this.port.postMessage({ path, value, type: "param" }));
 
             this.fDSPCode.start();
         }
+
+        protected handleMessageAux = (e: MessageEvent) => { // use arrow function for binding
+            super.handleMessageAux(e);
+        }
     }
 
     /**
@@ -273,7 +291,8 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
             this.fDSPCode = new FaustPolyWebAudioDsp(instance, sampleRate, sampleSize, 128, soundfiles);
 
             // Setup port message handling
-            this.port.onmessage = (e: MessageEvent) => this.handleMessageAux(e);
+            this.port.addEventListener("message", this.handleMessageAux);
+            this.port.start();
 
             // Setup output handler
             this.fDSPCode.setOutputParamHandler((path, value) => this.port.postMessage({ path, value, type: "param" }));

package/src/FaustDspGenerator.ts

@@ -10,6 +10,7 @@ import SoundfileReader from "./SoundfileReader";
 import FaustSensors from "./FaustSensors";
 import type { IFaustCompiler } from "./FaustCompiler";
 import type { FaustDspFactory, FaustUIDescriptor, FaustDspMeta, FFTUtils, LooseFaustDspFactory, AudioData } from "./types";
+import { FaustAudioWorkletCommunicator, FaustAudioWorkletProcessorCommunicator } from "./FaustAudioWorkletCommunicator";
 
 
 export interface GeneratorSupportingSoundfiles {
@@ -294,11 +295,16 @@ var ${WasmAllocator.name} = ${WasmAllocator.toString()}
 var WasmAllocator = ${WasmAllocator.name};
 var ${FaustSensors.name} = ${FaustSensors.toString()}
 var FaustSensors = ${FaustSensors.name};
+var ${FaustAudioWorkletCommunicator.name} = ${FaustAudioWorkletCommunicator.toString()}
+var FaustAudioWorkletCommunicator = ${FaustAudioWorkletCommunicator.name};
+var ${FaustAudioWorkletProcessorCommunicator.name} = ${FaustAudioWorkletProcessorCommunicator.toString()}
+var FaustAudioWorkletProcessorCommunicator = ${FaustAudioWorkletProcessorCommunicator.name};
 // Put them in dependencies
 const dependencies = {
     FaustBaseWebAudioDsp,
     FaustMonoWebAudioDsp,
-    FaustWasmInstantiator
+    FaustWasmInstantiator,
+    FaustAudioWorkletProcessorCommunicator
 };
 // Generate the actual AudioWorkletProcessor code
 (${getFaustAudioWorkletProcessor.toString()})(dependencies, faustData);
@@ -361,12 +367,17 @@ var ${WasmAllocator.name} = ${WasmAllocator.toString()}
 var WasmAllocator = ${WasmAllocator.name};
 var ${FaustSensors.name} = ${FaustSensors.toString()}
 var FaustSensors = ${FaustSensors.name};
+var ${FaustAudioWorkletCommunicator.name} = ${FaustAudioWorkletCommunicator.toString()}
+var FaustAudioWorkletCommunicator = ${FaustAudioWorkletCommunicator.name};
+var ${FaustAudioWorkletProcessorCommunicator.name} = ${FaustAudioWorkletProcessorCommunicator.toString()}
+var FaustAudioWorkletProcessorCommunicator = ${FaustAudioWorkletProcessorCommunicator.name};
 var FFTUtils = ${fftUtils.toString()}
 // Put them in dependencies
 const dependencies = {
     FaustBaseWebAudioDsp,
     FaustMonoWebAudioDsp,
     FaustWasmInstantiator,
+    FaustAudioWorkletProcessorCommunicator,
     FFTUtils
 };
 // Generate the actual AudioWorkletProcessor code
@@ -415,6 +426,7 @@ const dependencies = {
             FaustBaseWebAudioDsp,
             FaustMonoWebAudioDsp,
             FaustWasmInstantiator,
+            FaustAudioWorkletProcessorCommunicator,
             FaustPolyWebAudioDsp: undefined,
             FaustWebAudioDspVoice: undefined,
         }
@@ -631,11 +643,16 @@ var ${WasmAllocator.name} = ${WasmAllocator.toString()}
 var WasmAllocator = ${WasmAllocator.name};
 var ${FaustSensors.name} = ${FaustSensors.toString()}
 var FaustSensors = ${FaustSensors.name};
+var ${FaustAudioWorkletCommunicator.name} = ${FaustAudioWorkletCommunicator.toString()}
+var FaustAudioWorkletCommunicator = ${FaustAudioWorkletCommunicator.name};
+var ${FaustAudioWorkletProcessorCommunicator.name} = ${FaustAudioWorkletProcessorCommunicator.toString()}
+var FaustAudioWorkletProcessorCommunicator = ${FaustAudioWorkletProcessorCommunicator.name};
 // Put them in dependencies
 const dependencies = {
     FaustBaseWebAudioDsp,
     FaustPolyWebAudioDsp,
-    FaustWasmInstantiator
+    FaustWasmInstantiator,
+    FaustAudioWorkletProcessorCommunicator
 };
 // Generate the actual AudioWorkletProcessor code
 (${getFaustAudioWorkletProcessor.toString()})(dependencies, faustData);
@@ -676,6 +693,7 @@ const dependencies = {
                 FaustWasmInstantiator,
                 FaustPolyWebAudioDsp,
                 FaustWebAudioDspVoice,
+                FaustAudioWorkletProcessorCommunicator
             };
             // DSP name and JSON string for DSP are generated
             const faustData = {

package/src/FaustFFTAudioWorkletProcessor.ts

@@ -1,3 +1,4 @@
+import type { FaustAudioWorkletProcessorCommunicator } from "./FaustAudioWorkletCommunicator";
 import type { FaustMonoDspInstance } from "./FaustDspInstance";
 import type FaustWasmInstantiator from "./FaustWasmInstantiator";
 import type { FaustBaseWebAudioDsp, FaustMonoWebAudioDsp, PlotHandler } from "./FaustWebAudioDsp";
@@ -25,6 +26,7 @@ export interface FaustFFTAudioWorkletProcessorDependencies {
     FaustBaseWebAudioDsp: typeof FaustBaseWebAudioDsp;
     FaustMonoWebAudioDsp: typeof FaustMonoWebAudioDsp;
     FaustWasmInstantiator: typeof FaustWasmInstantiator;
+    FaustAudioWorkletProcessorCommunicator: typeof FaustAudioWorkletProcessorCommunicator;
     FFTUtils: typeof FFTUtils;
 }
 export interface FaustFFTAudioWorkletNodeOptions extends AudioWorkletNodeOptions {
@@ -48,6 +50,7 @@ const getFaustFFTAudioWorkletProcessor = (dependencies: FaustFFTAudioWorkletProc
         FaustBaseWebAudioDsp,
         FaustWasmInstantiator,
         FaustMonoWebAudioDsp,
+        FaustAudioWorkletProcessorCommunicator,
         FFTUtils
     } = dependencies;
     
@@ -127,6 +130,7 @@ const getFaustFFTAudioWorkletProcessor = (dependencies: FaustFFTAudioWorkletProc
         protected paramValuesCache: Record<string, number> = {};
 
         protected wamInfo?: { moduleId: string; instanceId: string };
+        protected communicator: FaustAudioWorkletProcessorCommunicator;
 
         private dspInstance!: FaustMonoDspInstance;
         private sampleSize!: number;
@@ -178,7 +182,9 @@ const getFaustFFTAudioWorkletProcessor = (dependencies: FaustFFTAudioWorkletProc
             super(options);
 
             // Setup port message handling
-            this.port.onmessage = (e: MessageEvent) => this.handleMessageAux(e);
+            this.port.addEventListener("message", this.handleMessageAux);
+            this.port.start();
+            this.communicator = new FaustAudioWorkletProcessorCommunicator(this.port);
             
             const { parameterDescriptors } = (this.constructor as typeof AudioWorkletProcessor);
             parameterDescriptors.forEach((pd) => {
@@ -360,6 +366,21 @@ const getFaustFFTAudioWorkletProcessor = (dependencies: FaustFFTAudioWorkletProc
                     this.paramValuesCache[path] = paramValue;
                 }
             }
+            if (this.communicator.getNewAccDataAvailable()) {
+                const acc = this.communicator.getAcc();
+                if (acc) {
+                    this.communicator.setNewAccDataAvailable(false);
+                    const { invert, ...data } = acc;
+                    this.propagateAcc(data, invert);
+                }
+            }
+            if (this.communicator.getNewGyrDataAvailable()) {
+                const gyr = this.communicator.getGyr();
+                if (gyr) {
+                    this.communicator.setNewGyrDataAvailable(false);
+                    this.propagateGyr(gyr);
+                }
+            }
 
             // Write audio input into fftInput buffer, advance pointers
             if (input?.length) {
@@ -400,7 +421,7 @@ const getFaustFFTAudioWorkletProcessor = (dependencies: FaustFFTAudioWorkletProc
             return true;
         }
 
-        protected handleMessageAux(e: MessageEvent) { // use arrow function for binding
+        protected handleMessageAux = (e: MessageEvent) => { // use arrow function for binding
             const msg = e.data;
 
             switch (msg.type) {
@@ -462,6 +483,14 @@ const getFaustFFTAudioWorkletProcessor = (dependencies: FaustFFTAudioWorkletProc
             this.fDSPCode?.pitchWheel(channel, wheel);
         }
 
+        protected propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>, invert: boolean = false) {
+            this.fDSPCode.propagateAcc(accelerationIncludingGravity, invert);
+        }
+
+        protected propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+            this.fDSPCode.propagateGyr(event);
+        }
+
         resetFFT(sizeIn: number, overlapIn: number, windowFunctionIn: number, inputChannels: number, outputChannels: number, bufferSize: number) {
             const fftSize = ~~ceil(Math.max(2, sizeIn || 1024), 2);
             const fftOverlap = ~~Math.min(fftSize, Math.max(1, overlapIn));

package/src/FaustOfflineProcessor.ts

@@ -82,15 +82,21 @@ export class FaustOfflineProcessor<Poly extends boolean = false> {
     destroy() { this.fDSPCode.destroy(); }
 
     get hasAccInput() { return this.fDSPCode.hasAccInput; }
+
     propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>, invert: boolean = false) {
         this.fDSPCode.propagateAcc(accelerationIncludingGravity, invert);
     }
 
     get hasGyrInput() { return this.fDSPCode.hasGyrInput; }
+
     propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
         this.fDSPCode.propagateGyr(event);
     }
 
+    startSensors(): void { }
+
+    stopSensors(): void { }
+
     /**
      * Render frames in an array.
      *