[AUDIO_WORKLET] Inline .aw.js file into the main output .js file (#24190)

This is similar to what we already did for pthreads (#24163) and normal
wasm workers (#24163). By integrating this file we can also share
more startup code with normal wasm workers.

Author: sbc100

src/audio_worklet.js

@@ -12,24 +12,16 @@
 // the node constructor's "processorOptions" field, we can share the necessary
 // bootstrap information from the main thread to the AudioWorkletGlobalScope.
 
+if (ENVIRONMENT_IS_AUDIO_WORKLET) {
+
 function createWasmAudioWorkletProcessor(audioParams) {
   class WasmAudioWorkletProcessor extends AudioWorkletProcessor {
     constructor(args) {
       super();
 
-      // Copy needed stack allocation functions from the Module object
-      // to global scope, these will be accessed in hot paths, so maybe
-      // they'll be a bit faster to access directly, rather than referencing
-      // them as properties of the Module object.
-      globalThis.stackAlloc = Module['stackAlloc'];
-      globalThis.stackSave = Module['stackSave'];
-      globalThis.stackRestore = Module['stackRestore'];
-      globalThis.HEAPU32 = Module['HEAPU32'];
-      globalThis.HEAPF32 = Module['HEAPF32'];
-
       // Capture the Wasm function callback to invoke.
       let opts = args.processorOptions;
-      this.callbackFunction = Module['wasmTable'].get(opts['cb']);
+      this.callbackFunction = wasmTable.get(opts['cb']);
       this.userData = opts['ud'];
       // Then the samples per channel to process, fixed for the lifetime of the
       // context that created this processor. Note for when moving to Web Audio
@@ -43,6 +35,9 @@ function createWasmAudioWorkletProcessor(audioParams) {
       return audioParams;
     }
 
+    /**
+     * @param {Object} parameters
+     */
     process(inputList, outputList, parameters) {
       // Marshal all inputs and parameters to the Wasm memory on the thread stack,
       // then perform the wasm audio worklet call,
@@ -99,6 +94,7 @@ function createWasmAudioWorkletProcessor(audioParams) {
       paramsPtr = dataPtr;
       k = paramsPtr >> 2;
       dataPtr += numParams * {{{ C_STRUCTS.AudioParamFrame.__size__ }}};
+
       for (i = 0; paramArray = parameters[i++];) {
         // Write the AudioParamFrame struct instance
         HEAPU32[k + {{{ C_STRUCTS.AudioParamFrame.length / 4 }}}] = paramArray.length;
@@ -134,53 +130,29 @@ function createWasmAudioWorkletProcessor(audioParams) {
   return WasmAudioWorkletProcessor;
 }
 
+var messagePort;
+
 // Specify a worklet processor that will be used to receive messages to this
 // AudioWorkletGlobalScope.  We never connect this initial AudioWorkletProcessor
 // to the audio graph to do any audio processing.
 class BootstrapMessages extends AudioWorkletProcessor {
   constructor(arg) {
     super();
-    // Audio worklets need to show up as wasm workers.  This is the way we signal
-    // that.
-    globalThis.name = 'em-ww';
-    // Initialize the global Emscripten Module object that contains e.g. the
-    // Wasm Module and Memory objects.  After this we are ready to load in the
-    // main application JS script, which the main thread will addModule()
-    // to this scope.
-    globalThis.Module = arg['processorOptions'];
-#if !MINIMAL_RUNTIME
-    // Default runtime relies on an injected instantiateWasm() function to
-    // initialize the Wasm Module.
-    globalThis.Module['instantiateWasm'] = (info, receiveInstance) => {
-      var instance = new WebAssembly.Instance(Module['wasm'], info);
-      return receiveInstance(instance, Module['wasm']);
-    };
-#endif
+    startWasmWorker(arg['processorOptions'])
 #if WEBAUDIO_DEBUG
     console.log('AudioWorklet global scope looks like this:');
     console.dir(globalThis);
 #endif
     // Listen to messages from the main thread. These messages will ask this
     // scope to create the real AudioWorkletProcessors that call out to Wasm to
     // do audio processing.
-    let p = globalThis['messagePort'] = this.port;
-    p.onmessage = async (msg) => {
+    messagePort = this.port;
+    /** @suppress {checkTypes} */
+    messagePort.onmessage = async (msg) => {
       let d = msg.data;
       if (d['_wpn']) {
         // '_wpn' is short for 'Worklet Processor Node', using an identifier
         // that will never conflict with user messages
-#if MODULARIZE
-        // Instantiate the MODULARIZEd Module function, which is stored for us
-        // under the special global name AudioWorkletModule in
-        // MODULARIZE+AUDIO_WORKLET builds.
-        if (globalThis.AudioWorkletModule) {
-          // This populates the Module object with all the Wasm properties
-          globalThis.Module = await AudioWorkletModule(Module);
-          // We have now instantiated the Module function, can discard it from
-          // global scope
-          delete globalThis.AudioWorkletModule;
-        }
-#endif
         // Register a real AudioWorkletProcessor that will actually do audio processing.
         // 'ap' being the audio params
         registerProcessor(d['_wpn'], createWasmAudioWorkletProcessor(d['ap']));
@@ -196,14 +168,14 @@ class BootstrapMessages extends AudioWorkletProcessor {
         // 'cb' the callback function
         // 'ch' the context handle
         // 'ud' the passed user data
-        p.postMessage({'_wsc': d['cb'], 'x': [d['ch'], 1/*EM_TRUE*/, d['ud']] });
+        messagePort.postMessage({'_wsc': d['cb'], 'x': [d['ch'], 1/*EM_TRUE*/, d['ud']] });
       } else if (d['_wsc']) {
 #if MEMORY64
         var ptr = BigInt(d['_wsc']);
 #else
         var ptr = d['_wsc'];
 #endif
-        Module['wasmTable'].get(ptr)(...d['x']);
+        wasmTable.get(ptr)(...d['x']);
       };
     }
   }
@@ -220,4 +192,6 @@ class BootstrapMessages extends AudioWorkletProcessor {
 };
 
 // Register the dummy processor that will just receive messages.
-registerProcessor('message', BootstrapMessages);
+registerProcessor('em-bootstrap', BootstrapMessages);
+
+} // ENVIRONMENT_IS_AUDIO_WORKLET

src/closure-externs/closure-externs.js

@@ -271,3 +271,5 @@ Symbol.dispose;
 
 // Common between node-externs and v8-externs
 var os = {};
+
+AudioWorkletProcessor.parameterDescriptors;

src/lib/libwebaudio.js

@@ -181,47 +181,27 @@ let LibraryWebAudio = {
       return audioWorkletCreationFailed();
     }
 
-    // TODO: In MINIMAL_RUNTIME builds, read this file off of a preloaded Blob,
-    // and/or embed from a string like with WASM_WORKERS==2 mode.
-    audioWorklet.addModule('{{{ TARGET_BASENAME }}}.aw.js').then(() => {
+    audioWorklet.addModule({{{ wasmWorkerJs }}}).then(() => {
 #if WEBAUDIO_DEBUG
-      console.log(`emscripten_start_wasm_audio_worklet_thread_async() addModule('audioworklet.js') completed`);
+      console.log(`emscripten_start_wasm_audio_worklet_thread_async() addModule() completed`);
 #endif
-      audioWorklet.bootstrapMessage = new AudioWorkletNode(audioContext, 'message', {
+      audioWorklet.bootstrapMessage = new AudioWorkletNode(audioContext, 'em-bootstrap', {
         processorOptions: {
           // Assign the loaded AudioWorkletGlobalScope a Wasm Worker ID so that
           // it can utilized its own TLS slots, and it is recognized to not be
           // the main browser thread.
           '$ww': _wasmWorkersID++,
 #if MINIMAL_RUNTIME
           'wasm': Module['wasm'],
-          'mem': wasmMemory,
 #else
           'wasm': wasmModule,
-          'wasmMemory': wasmMemory,
 #endif
+          'mem': wasmMemory,
           'sb': stackLowestAddress, // sb = stack base
           'sz': stackSize,          // sz = stack size
         }
       });
       audioWorklet.bootstrapMessage.port.onmessage = _EmAudioDispatchProcessorCallback;
-
-      // AudioWorklets do not have a importScripts() function like Web Workers
-      // do (and AudioWorkletGlobalScope does not allow dynamic import()
-      // either), but instead, the main thread must load all JS code into the
-      // worklet scope. Send the application main JS script to the audio
-      // worklet.
-      return audioWorklet.addModule(
-#if MINIMAL_RUNTIME
-        Module['js']
-#else
-        Module['mainScriptUrlOrBlob'] || _scriptName
-#endif
-      );
-    }).then(() => {
-#if WEBAUDIO_DEBUG
-      console.log(`emscripten_start_wasm_audio_worklet_thread_async() addModule() of main application JS completed`);
-#endif
       {{{ makeDynCall('viii', 'callback') }}}(contextHandle, 1/*EM_TRUE*/, userData);
     }).catch(audioWorkletCreationFailed);
   },
@@ -335,11 +315,11 @@ let LibraryWebAudio = {
   emscripten_current_thread_is_audio_worklet: () => typeof AudioWorkletGlobalScope !== 'undefined',
 
   emscripten_audio_worklet_post_function_v: (audioContext, funcPtr) => {
-    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : globalThis['messagePort']).postMessage({'_wsc': funcPtr, 'x': [] }); // "WaSm Call"
+    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : messagePort).postMessage({'_wsc': funcPtr, 'x': [] }); // "WaSm Call"
   },
 
   $emscripten_audio_worklet_post_function_1: (audioContext, funcPtr, arg0) => {
-    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : globalThis['messagePort']).postMessage({'_wsc': funcPtr, 'x': [arg0] }); // "WaSm Call"
+    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : messagePort).postMessage({'_wsc': funcPtr, 'x': [arg0] }); // "WaSm Call"
   },
 
   emscripten_audio_worklet_post_function_vi__deps: ['$emscripten_audio_worklet_post_function_1'],
@@ -353,7 +333,7 @@ let LibraryWebAudio = {
   },
 
   $emscripten_audio_worklet_post_function_2: (audioContext, funcPtr, arg0, arg1) => {
-    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : globalThis['messagePort']).postMessage({'_wsc': funcPtr, 'x': [arg0, arg1] }); // "WaSm Call"
+    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : messagePort).postMessage({'_wsc': funcPtr, 'x': [arg0, arg1] }); // "WaSm Call"
   },
 
   emscripten_audio_worklet_post_function_vii__deps: ['$emscripten_audio_worklet_post_function_2'],
@@ -367,7 +347,7 @@ let LibraryWebAudio = {
   },
 
   $emscripten_audio_worklet_post_function_3: (audioContext, funcPtr, arg0, arg1, arg2) => {
-    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : globalThis['messagePort']).postMessage({'_wsc': funcPtr, 'x': [arg0, arg1, arg2] }); // "WaSm Call"
+    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : messagePort).postMessage({'_wsc': funcPtr, 'x': [arg0, arg1, arg2] }); // "WaSm Call"
   },
   emscripten_audio_worklet_post_function_viii__deps: ['$emscripten_audio_worklet_post_function_3'],
   emscripten_audio_worklet_post_function_viii: (audioContext, funcPtr, arg0, arg1, arg2) => {
@@ -387,7 +367,7 @@ let LibraryWebAudio = {
     assert(UTF8ToString(sigPtr)[0] != 'v', 'Do NOT specify the return argument in the signature string for a call to emscripten_audio_worklet_post_function_sig(), just pass the function arguments.');
     assert(varargs);
 #endif
-    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : globalThis['messagePort']).postMessage({'_wsc': funcPtr, 'x': readEmAsmArgs(sigPtr, varargs) });
+    (audioContext ? EmAudio[audioContext].audioWorklet.bootstrapMessage.port : messagePort).postMessage({'_wsc': funcPtr, 'x': readEmAsmArgs(sigPtr, varargs) });
   }
 };
 

src/postamble_minimal.js

@@ -118,7 +118,7 @@ var imports = {
 #if ASSERTIONS && !WASM2JS
 // Module['wasm'] should contain a typed array of the Wasm object data, or a
 // precompiled WebAssembly Module.
-if (!WebAssembly.instantiateStreaming && !Module['wasm']) throw 'Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM';
+assert(WebAssembly.instantiateStreaming || Module['wasm'], 'Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM');
 #endif
 (WebAssembly.instantiateStreaming
   ? WebAssembly.instantiateStreaming(fetch('{{{ TARGET_BASENAME }}}.wasm'), imports)
@@ -131,7 +131,7 @@ WebAssembly.instantiateStreaming(fetch('{{{ TARGET_BASENAME }}}.wasm'), imports)
 #if ASSERTIONS && !WASM2JS
 // Module['wasm'] should contain a typed array of the Wasm object data, or a
 // precompiled WebAssembly Module.
-if (!Module['wasm']) throw 'Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM';
+assert(Module['wasm'], 'Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM');
 #endif
 
 <<< ATMODULES >>>
@@ -259,8 +259,5 @@ WebAssembly.instantiate(Module['wasm'], imports).then((output) => {
 }
 
 // When running in a background thread we delay module loading until we have
-#if AUDIO_WORKLET
-if (ENVIRONMENT_IS_AUDIO_WORKLET) loadModule();
-#endif
 {{{ runIfMainThread('loadModule();') }}}
 #endif

src/runtime_init_memory.js

@@ -12,9 +12,6 @@
 // check for full engine support (use string 'subarray' to avoid closure compiler confusion)
 
 function initMemory() {
-#if AUDIO_WORKLET
-  if (!ENVIRONMENT_IS_AUDIO_WORKLET)
-#endif
   {{{ runIfWorkerThread('return') }}}
 
 #if expectToReceiveOnModule('wasmMemory')

src/runtime_shared.js

@@ -47,6 +47,10 @@ if (ENVIRONMENT_IS_NODE && {{{ ENVIRONMENT_IS_WORKER_THREAD() }}}) {
 #include "wasm_worker.js"
 #endif
 
+#if AUDIO_WORKLET
+#include "audio_worklet.js"
+#endif
+
 #if LOAD_SOURCE_MAP
 var wasmSourceMap;
 #include "source_map_support.js"
@@ -64,11 +68,6 @@ var wasmOffsetConverter;
     let shouldExport = false;
     if (MODULARIZE && EXPORT_ALL) {
       shouldExport = true;
-    } else if (AUDIO_WORKLET && (x == 'HEAPU32' || x == 'HEAPF32')) {
-      // Export to the AudioWorkletGlobalScope the needed variables to access
-      // the heap. AudioWorkletGlobalScope is unable to access global JS vars
-      // in the compiled main JS file.
-      shouldExport = true;
     } else if (EXPORTED_RUNTIME_METHODS.includes(x)) {
       shouldExport = true;
     }

src/shell.js

@@ -53,13 +53,21 @@ var readyPromise = new Promise((resolve, reject) => {
 });
 #endif
 
-// Determine the runtime environment we are in. You can customize this by
-// setting the ENVIRONMENT setting at compile time (see settings.js).
+#if WASM_WORKERS
+// The way we signal to a worker that it is hosting a pthread is to construct
+// it with a specific name.
+var ENVIRONMENT_IS_WASM_WORKER = globalThis.name == 'em-ww';
+#endif
 
 #if AUDIO_WORKLET
 var ENVIRONMENT_IS_AUDIO_WORKLET = typeof AudioWorkletGlobalScope !== 'undefined';
+// Audio worklets behave as wasm workers.
+if (ENVIRONMENT_IS_AUDIO_WORKLET) ENVIRONMENT_IS_WASM_WORKER = true;
 #endif
 
+// Determine the runtime environment we are in. You can customize this by
+// setting the ENVIRONMENT setting at compile time (see settings.js).
+
 #if ENVIRONMENT && !ENVIRONMENT.includes(',')
 var ENVIRONMENT_IS_WEB = {{{ ENVIRONMENT === 'web' }}};
 #if PTHREADS && ENVIRONMENT_MAY_BE_NODE
@@ -102,12 +110,6 @@ if (ENVIRONMENT_IS_PTHREAD) {
 #endif
 #endif
 
-#if WASM_WORKERS
-// The way we signal to a worker that it is hosting a pthread is to construct
-// it with a specific name.
-var ENVIRONMENT_IS_WASM_WORKER = globalThis.name == 'em-ww';
-#endif
-
 #if ENVIRONMENT_MAY_BE_NODE
 if (ENVIRONMENT_IS_NODE) {
 #if EXPORT_ES6

src/shell_minimal.js

@@ -51,10 +51,6 @@ var ENVIRONMENT_IS_NODE = typeof process == 'object' && process.type != 'rendere
 var ENVIRONMENT_IS_SHELL = typeof read == 'function';
 #endif
 
-#if AUDIO_WORKLET
-var ENVIRONMENT_IS_AUDIO_WORKLET = typeof AudioWorkletGlobalScope !== 'undefined';
-#endif
-
 #if ASSERTIONS || PTHREADS
 #if !ENVIRONMENT_MAY_BE_NODE && !ENVIRONMENT_MAY_BE_SHELL
 var ENVIRONMENT_IS_WEB = true
@@ -88,6 +84,11 @@ if (ENVIRONMENT_IS_NODE) {
 #endif
 #endif
 
+#if AUDIO_WORKLET
+var ENVIRONMENT_IS_AUDIO_WORKLET = typeof AudioWorkletGlobalScope !== 'undefined';
+if (ENVIRONMENT_IS_AUDIO_WORKLET) ENVIRONMENT_IS_WASM_WORKER = true;
+#endif
+
 #if ASSERTIONS && ENVIRONMENT_MAY_BE_NODE && ENVIRONMENT_MAY_BE_SHELL
 if (ENVIRONMENT_IS_NODE && ENVIRONMENT_IS_SHELL) {
   throw 'unclear environment';