@grame/faustwasm 0.7.9 → 0.8.0

package/assets/standalone/index-pwa.js

@@ -31,14 +31,14 @@ audioContext.suspend();
 
 (async () => {
 
-    const { createFaustNode } = await import("./create-node.js");
+    const { createFaustNode, createFaustUI, connectToAudioInput } = await import("./create-node.js");
+
     // To test the ScriptProcessorNode mode
     //const { faustNode, dspMeta: { name } } = await createFaustNode(audioContext, "osc", FAUST_DSP_VOICES, true, 512);
     const { faustNode, dspMeta: { name } } = await createFaustNode(audioContext, "osc", FAUST_DSP_VOICES);
     if (!faustNode) throw new Error("Faust DSP not compiled");
 
     // Create the Faust UI
-    const { createFaustUI } = await import("./create-node.js");
     await createFaustUI($divFaustUI, faustNode);
 
     // Function to start MIDI
@@ -85,11 +85,6 @@ audioContext.suspend();
     // Function to resume AudioContext, activate MIDI and Sensors on user interaction
     async function activateAudioMIDISensors() {
 
-        // Resume the AudioContext
-        if (audioContext.state === 'suspended') {
-            await audioContext.resume();
-        }
-
         // Activate sensor listeners
         if (!sensorHandlersBound) {
             await faustNode.startSensors();
@@ -107,9 +102,13 @@ audioContext.suspend();
 
         // Connect the Faust node to the audio input
         if (faustNode.numberOfInputs > 0) {
-            const { connectToAudioInput } = await import("./create-node.js");
             await connectToAudioInput(audioContext, null, faustNode, null);
         }
+
+        // Resume the AudioContext
+        if (audioContext.state === 'suspended') {
+            await audioContext.resume();
+        }
     }
 
     // Function to suspend AudioContext, deactivate MIDI and Sensors on user interaction

package/assets/standalone/index-template.js

@@ -2,7 +2,8 @@
 const FAUST_DSP_VOICES = 0;
 
 (async () => {
-    const { createFaustNode } = await import("./create-node.js");
+
+    const { createFaustNode, connectToAudioInput } = await import("./create-node.js");
 
     // Create audio context
     const AudioCtx = window.AudioContext || window.webkitAudioContext;
@@ -42,7 +43,6 @@ const FAUST_DSP_VOICES = 0;
 
     // Connect the Faust node to the audio input
     if (faustNode.getNumInputs() > 0) {
-        const { connectToAudioInput } = await import("./create-node.js");
         await connectToAudioInput(audioContext, null, faustNode, null);
     }
 

package/assets/standalone/index.js

@@ -41,82 +41,80 @@ audioContext.suspend();
 
 $buttonDsp.disabled = true;
 
-/**
- * @param {FaustAudioWorkletNode} faustNode 
- */
-const buildAudioDeviceMenu = async (faustNode) => {
-
-    const { connectToAudioInput } = await import("./create-node.js");
-
-    let inputStreamNode = null;
-    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);
+(async () => {
+
+    const { createFaustNode, connectToAudioInput, createFaustUI } = await import("./create-node.js");
+
+    /**
+    * @param {FaustAudioWorkletNode} faustNode 
+    */
+    const buildAudioDeviceMenu = async (faustNode) => {
+
+        let inputStreamNode = null;
+        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;
+            if (faustNode.getNumInputs() > 0) {
+                inputStreamNode = await connectToAudioInput(audioContext, id, faustNode, inputStreamNode);
             }
-        });
-    }
-    await handleDeviceChange();
-    navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange)
-    $selectAudioInput.onchange = async () => {
-        const id = $selectAudioInput.value;
+        };
+
+        // Connect to the default audio input device
         if (faustNode.getNumInputs() > 0) {
-            inputStreamNode = await connectToAudioInput(audioContext, id, faustNode, inputStreamNode);
+            inputStreamNode = await connectToAudioInput(audioContext, null, faustNode, inputStreamNode);
         }
     };
 
-    // Connect to the default audio input device
-    if (faustNode.getNumInputs() > 0) {
-        inputStreamNode = await connectToAudioInput(audioContext, null, faustNode, inputStreamNode);
-    }
-};
-
-/**
- * @param {FaustAudioWorkletNode} faustNode 
- */
-const buildMidiDeviceMenu = async (faustNode) => {
-    const midiAccess = await navigator.requestMIDIAccess();
-    /** @type {WebMidi.MIDIInput} */
-    let currentInput;
     /**
-     * @param {WebMidi.MIDIMessageEvent} e
+     * @param {FaustAudioWorkletNode} faustNode 
      */
-    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);
+    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);
+        };
     };
-};
-
-(async () => {
 
-    const { createFaustNode } = await import("./create-node.js");
     // To test the ScriptProcessorNode mode
     // const { faustNode, dspMeta: { name } } = await createFaustNode(audioContext, "FAUST_DSP_NAME", FAUST_DSP_VOICES, true);
     const { faustNode, dspMeta: { name } } = await createFaustNode(audioContext, "FAUST_DSP_NAME", FAUST_DSP_VOICES);
     if (!faustNode) throw new Error("Faust DSP not compiled");
 
     // Create the Faust UI
-    const { createFaustUI } = await import("./create-node.js");
     await createFaustUI($divFaustUI, faustNode);
 
     // Connect the Faust node to the audio output

package/assets/standalone/service-worker.js

@@ -29,7 +29,7 @@ const POLY_EFFECT_RESOURCES = [
     "./effect-meta.json",
 ];
 
-/**@type {ServiceWorkerGlobalScope} */
+/** @type {ServiceWorkerGlobalScope} */
 const serviceWorkerGlobalScope = self;
 
 /**
@@ -48,26 +48,65 @@ serviceWorkerGlobalScope.addEventListener("install", (event) => {
     })());
 });
 
-serviceWorkerGlobalScope.addEventListener("activate", () => console.log("Service worker activated"));
+serviceWorkerGlobalScope.addEventListener("activate", (event) => {
+    console.log("Service worker activated");
+    event.waitUntil(
+        clients.claim().then(() => {
+            return clients.matchAll({ type: "window" }).then((clients) => {
+                clients.forEach((client) => {
+                    client.navigate(client.url);
+                });
+            });
+        })
+    );
+});
+
+/** @type {(response: Response) => Response} */
+const getCrossOriginIsolatedResponse = (response) => {
+    // Modify headers to include COOP & COEP
+    const headers = new Headers(response.headers);
+    headers.set("Cross-Origin-Opener-Policy", "same-origin");
+    headers.set("Cross-Origin-Embedder-Policy", "require-corp");
+
+    // Create a new response with the modified headers
+    const modifiedResponse = new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+    });
 
+    return modifiedResponse;
+};
+
+/**
+ * Intercept fetch requests to enforce COOP and COEP headers.
+ */
 serviceWorkerGlobalScope.addEventListener("fetch", (event) => {
+
     event.respondWith((async () => {
         const cache = await caches.open(CACHE_NAME);
         const cachedResponse = await cache.match(event.request);
+
         if (cachedResponse) {
-            return cachedResponse;
+            return getCrossOriginIsolatedResponse(cachedResponse);
         } else {
             try {
                 const fetchResponse = await fetch(event.request);
-                // Ensure the response is valid before caching it
+
                 if (event.request.method === "GET" && fetchResponse && fetchResponse.status === 200 && fetchResponse.type === "basic") {
-                    cache.put(event.request, fetchResponse.clone());
+                    const modifiedResponse = getCrossOriginIsolatedResponse(fetchResponse);
+                    // Store the modified response in the cache
+                    await cache.put(event.request, modifiedResponse.clone());
+                    // Return the modified response to the browser
+                    return modifiedResponse;
                 }
+
                 return fetchResponse;
-            } catch (e) {
-                // Network access failure
-                console.log("Network access error", e);
+            } catch (error) {
+                console.error("Network access error", error);
+                return new Response("Network error", { status: 503, statusText: "Service Unavailable" });
             }
         }
     })());
 });
+

package/dist/cjs/index.d.ts

@@ -230,6 +230,49 @@ interface AudioData$1 {
  * @param wasmFile path to `libfaust-wasm.wasm`
  */
 export declare const instantiateFaustModuleFromFile: (jsFile: string, dataFile?: string, wasmFile?: string) => Promise<FaustModule>;
+declare 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);
+	initializeBuffer(ab: SharedArrayBuffer | ArrayBuffer): void;
+	setNewAccDataAvailable(value: boolean): void;
+	getNewAccDataAvailable(): boolean;
+	setNewGyrDataAvailable(value: boolean): void;
+	getNewGyrDataAvailable(): boolean;
+	setAcc({ x, y, z }: {
+		x: number;
+		y: number;
+		z: number;
+	}, invert?: boolean): void;
+	getAcc(): {
+		x: number;
+		y: number;
+		z: number;
+		invert: boolean;
+	} | undefined;
+	setGyr({ alpha, beta, gamma }: {
+		alpha: number;
+		beta: number;
+		gamma: number;
+	}): void;
+	getGyr(): {
+		alpha: number;
+		beta: number;
+		gamma: number;
+	} | undefined;
+}
+declare class FaustAudioWorkletNodeCommunicator extends FaustAudioWorkletCommunicator {
+	constructor(port: MessagePort);
+}
+declare class FaustAudioWorkletProcessorCommunicator extends FaustAudioWorkletCommunicator {
+	constructor(port: MessagePort);
+}
 /**
  * The Faust wasm instance interface.
  */
@@ -620,6 +663,29 @@ export interface IFaustBaseWebAudioDsp {
 	 * @return the DSP JSON description
 	 */
 	getJSON(): string;
+	/**
+	* Start accelerometer and gyroscope handlers.
+	*/
+	startSensors(): void;
+	/**
+	 * Stop accelerometer and gyroscope handlers.
+	 */
+	stopSensors(): void;
+	/** Indicating if the DSP handles the accelerometer */
+	readonly hasAccInput: boolean;
+	/**
+	 * Accelerometer handling.
+	 * accelerationIncludingGravity: DeviceMotionEvent["accelerationIncludingGravity"]
+	 * invert: boolean
+	 */
+	propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>, invert: boolean): void;
+	/** Indicating if the DSP handles the gyroscope */
+	readonly hasGyrInput: boolean;
+	/**
+	 * Gyroscope handling.
+	 * event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">
+	 */
+	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
 	/**
 	 * Start the DSP audio processing.
 	 */
@@ -632,14 +698,6 @@ 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"]>, invert: boolean): 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 {
 }
@@ -780,6 +838,8 @@ export declare class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
 	start(): void;
 	stop(): void;
 	destroy(): void;
+	startSensors(): void;
+	stopSensors(): void;
 }
 export declare class FaustMonoWebAudioDsp extends FaustBaseWebAudioDsp implements IFaustMonoWebAudioDsp {
 	private fInstance;
@@ -876,6 +936,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;
@@ -926,6 +987,7 @@ export interface FaustFFTAudioWorkletProcessorDependencies {
 	FaustBaseWebAudioDsp: typeof FaustBaseWebAudioDsp;
 	FaustMonoWebAudioDsp: typeof FaustMonoWebAudioDsp;
 	FaustWasmInstantiator: typeof FaustWasmInstantiator;
+	FaustAudioWorkletProcessorCommunicator: typeof FaustAudioWorkletProcessorCommunicator;
 	FFTUtils: typeof FFTUtils;
 }
 export interface FaustFFTAudioWorkletNodeOptions extends AudioWorkletNodeOptions {
@@ -1132,6 +1194,8 @@ export declare class FaustOfflineProcessor<Poly extends boolean = false> {
 	propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>, invert?: boolean): void;
 	get hasGyrInput(): boolean;
 	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
+	startSensors(): void;
+	stopSensors(): void;
 	/**
 	 * Render frames in an array.
 	 *
@@ -1288,7 +1352,9 @@ export declare class FaustAudioWorkletNode<Poly extends boolean = false> extends
 	protected fPlotHandler: PlotHandler | null;
 	protected fUICallback: UIHandler;
 	protected fDescriptor: FaustUIInputItem[];
+	protected fCommunicator: FaustAudioWorkletNodeCommunicator;
 	constructor(context: BaseAudioContext, name: string, factory: LooseFaustDspFactory, options?: Partial<FaustAudioWorkletNodeOptions<Poly>>);
+	protected handleMessageAux: (e: MessageEvent) => void;
 	private handleDeviceMotion;
 	private handleDeviceOrientation;
 	/** Setup accelerometer and gyroscope handlers */
@@ -1358,8 +1424,9 @@ export declare class FaustScriptProcessorNode<Poly extends boolean = false> exte
 	protected handleDeviceMotion: any;
 	protected handleDeviceOrientation: any;
 	init(instance: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp): void;
-	/** Setup accelerometer and gyroscope handlers */
+	/** Start accelerometer and gyroscope handlers */
 	startSensors(): Promise<void>;
+	/** Stop accelerometer and gyroscope handlers */
 	stopSensors(): void;
 	compute(input: Float32Array[], output: Float32Array[]): boolean;
 	setOutputParamHandler(handler: OutputParamHandler): void;