[AUDIO_WORKLET] Added support for MEMORY64 and 2GB heap (including tests)

src/audio_worklet.js

@@ -31,12 +31,48 @@ function createWasmAudioWorkletProcessor(audioParams) {
       let opts = args.processorOptions;
       this.callbackFunction = Module['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
-      // 1.1: the typed array passed to process() should be the same size as this
-      // 'render quantum size', and this exercise of passing in the value
-      // shouldn't be required (to be verified).
+      // context that created this processor. Even though this 'render quantum
+      // size' is fixed at 128 samples in the 1.0 spec, it will be variable in
+      // the 1.1 spec. It's passed in now, just to prove it's settable, but will
+      // eventually be a property of the  AudioWorkletGlobalScope (globalThis).
       this.samplesPerChannel = opts['sc'];
+
+      // Create up-front as many typed views for marshalling the output data as
+      // may be required (with an arbitrary maximum of 10, for the case where a
+      // multi-MB stack is passed), allocated at the *top* of the worklet's
+      // stack (and whose addresses are fixed). The 'minimum alloc' firstly
+      // stops STACK_OVERFLOW_CHECK failing (since the stack will be full, and
+      // 16 being the minimum allocation size due to alignments) and leaves room
+      // for a single AudioSampleFrame as a minumum.
+      // Note: here and in the rest of the code the natural '>>> 2' unsigned
+      // shifts for bytes to HEAPU32 offsets have been replaced with '/ 4',
+      // otherwise the values are truncated to 32-bit addresses, which fails
+      // when compiling with MEMORY64.
+      this.maxBuffers = Math.min(((Module['sz'] - /*minimum alloc*/ 16) / (this.samplesPerChannel * 4)) | 0, /*sensible limit*/ 10);
+#if ASSERTIONS
+      console.assert(this.maxBuffers > 0, `AudioWorklet needs more stack allocating (at least ${this.samplesPerChannel * 4})`);
+#endif
+      // These are still alloc'd to take advantage of the overflow checks, etc.
+      var oldStackPtr = stackSave();
+      var viewDataIdx = stackAlloc(this.maxBuffers * this.samplesPerChannel * 4) / 4;
+#if WEBAUDIO_DEBUG
+      console.log(`AudioWorklet creating ${this.maxBuffers} buffer one-time views (for a stack size of ${Module['sz']} at address 0x${(viewDataIdx * 4).toString(16)})`);
+#endif
+      this.outputViews = [];
+      for (var i = this.maxBuffers; i > 0; i--) {
+        // Added in reverse so the lowest indices are closest to the stack top
+        this.outputViews.unshift(
+          HEAPF32.subarray(viewDataIdx, viewDataIdx += this.samplesPerChannel)
+        );
+      }
+      stackRestore(oldStackPtr);
+
+#if ASSERTIONS
+      // Explicitly verify this later in process()
+      this.ctorOldStackPtr = oldStackPtr;
+#endif
     }
 
     static get parameterDescriptors() {
@@ -52,74 +88,119 @@ function createWasmAudioWorkletProcessor(audioParams) {
         numOutputs = outputList.length,
         numParams = 0, i, j, k, dataPtr,
         bytesPerChannel = this.samplesPerChannel * 4,
+        outputViewsNeeded = 0,
         stackMemoryNeeded = (numInputs + numOutputs) * {{{ C_STRUCTS.AudioSampleFrame.__size__ }}},
         oldStackPtr = stackSave(),
-        inputsPtr, outputsPtr, outputDataPtr, paramsPtr,
+        inputsPtr, outputsPtr, paramsPtr,
         didProduceAudio, paramArray;
 
-      // Calculate how much stack space is needed.
+      // Calculate how much stack space is needed
       for (i of inputList) stackMemoryNeeded += i.length * bytesPerChannel;
-      for (i of outputList) stackMemoryNeeded += i.length * bytesPerChannel;
+      for (i of outputList) outputViewsNeeded += i.length;
+      stackMemoryNeeded += outputViewsNeeded * bytesPerChannel;
       for (i in parameters) stackMemoryNeeded += parameters[i].byteLength + {{{ C_STRUCTS.AudioParamFrame.__size__ }}}, ++numParams;
 
-      // Allocate the necessary stack space.
-      inputsPtr = stackAlloc(stackMemoryNeeded);
+#if ASSERTIONS
+      console.assert(oldStackPtr == this.ctorOldStackPtr, 'AudioWorklet stack address has unexpectedly moved');
+      console.assert(outputViewsNeeded <= this.outputViews.length, `Too many AudioWorklet outputs (need ${outputViewsNeeded} but have stack space for ${this.outputViews.length})`);
+#endif
+
+      // Allocate the necessary stack space (dataPtr is always in bytes, and
+      // advances as space for structs and data is taken, but note the switching
+      // between bytes and indices into the various heaps, usually in 'k'). This
+      // will be 16-byte aligned (from _emscripten_stack_alloc()), as were the
+      // output views, so we round up and advance the required bytes to ensure
+      // the addresses all work out at the end.
+      i = (stackMemoryNeeded + 15) & ~15;
+      dataPtr = stackAlloc(i) + (i - stackMemoryNeeded);
 
       // Copy input audio descriptor structs and data to Wasm
-      k = inputsPtr >> 2;
-      dataPtr = inputsPtr + numInputs * {{{ C_STRUCTS.AudioSampleFrame.__size__ }}};
+      inputsPtr = dataPtr;
+      k = inputsPtr / 4;
+      dataPtr += numInputs * {{{ C_STRUCTS.AudioSampleFrame.__size__ }}};
       for (i of inputList) {
         // Write the AudioSampleFrame struct instance
         HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.numberOfChannels / 4 }}}] = i.length;
         HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.samplesPerChannel / 4 }}}] = this.samplesPerChannel;
         HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.data / 4 }}}] = dataPtr;
+#if MEMORY64
+        // See the note in the constructor for dealing with 64-bit addresses
+        HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.data / 4 + 1 }}}] = dataPtr / 0x100000000;
+#endif
         k += {{{ C_STRUCTS.AudioSampleFrame.__size__ / 4 }}};
         // Marshal the input audio sample data for each audio channel of this input
         for (j of i) {
-          HEAPF32.set(j, dataPtr>>2);
+          HEAPF32.set(j, dataPtr / 4);
           dataPtr += bytesPerChannel;
         }
       }
 
-      // Copy output audio descriptor structs to Wasm
+      // Copy parameters descriptor structs and data to Wasm
+      paramsPtr = dataPtr;
+      k = paramsPtr / 4;
+      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;
+        HEAPU32[k + {{{ C_STRUCTS.AudioParamFrame.data / 4 }}}] = dataPtr;
+#if MEMORY64
+        HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.data / 4 + 1 }}}] = dataPtr / 0x100000000;
+#endif
+        k += {{{ C_STRUCTS.AudioParamFrame.__size__ / 4 }}};
+        // Marshal the audio parameters array
+        HEAPF32.set(paramArray, dataPtr / 4);
+        dataPtr += paramArray.length * 4;
+      }
+
+      // Copy output audio descriptor structs to Wasm (note that dataPtr after
+      // the struct offsets should now be 16-byte aligned).
       outputsPtr = dataPtr;
-      k = outputsPtr >> 2;
-      outputDataPtr = (dataPtr += numOutputs * {{{ C_STRUCTS.AudioSampleFrame.__size__ }}}) >> 2;
+      k = outputsPtr / 4;
+      dataPtr += numOutputs * {{{ C_STRUCTS.AudioSampleFrame.__size__ }}};
       for (i of outputList) {
         // Write the AudioSampleFrame struct instance
         HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.numberOfChannels / 4 }}}] = i.length;
         HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.samplesPerChannel / 4 }}}] = this.samplesPerChannel;
         HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.data / 4 }}}] = dataPtr;
+#if MEMORY64
+        HEAPU32[k + {{{ C_STRUCTS.AudioSampleFrame.data / 4 + 1 }}}] = dataPtr / 0x100000000;
+#endif
         k += {{{ C_STRUCTS.AudioSampleFrame.__size__ / 4 }}};
-        // Reserve space for the output data
+        // Advance the output pointer to the next output (matching the pre-allocated views)
         dataPtr += bytesPerChannel * i.length;
       }
 
-      // Copy parameters descriptor structs and data to Wasm
-      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;
-        HEAPU32[k + {{{ C_STRUCTS.AudioParamFrame.data / 4 }}}] = dataPtr;
-        k += {{{ C_STRUCTS.AudioParamFrame.__size__ / 4 }}};
-        // Marshal the audio parameters array
-        HEAPF32.set(paramArray, dataPtr>>2);
-        dataPtr += paramArray.length*4;
+#if ASSERTIONS
+      // If all the maths worked out, we arrived at the original stack address
+      console.assert(dataPtr == oldStackPtr, `AudioWorklet stack missmatch (audio data finishes at ${dataPtr} instead of ${oldStackPtr})`);
+
+      // Sanity checks. If these trip the most likely cause, beyond unforeseen
+      // stack shenanigans, is that the 'render quantum size' changed.
+      if (numOutputs) {
+        // First that the output view addresses match the stack positions.
+        k = dataPtr - bytesPerChannel;
+        for (i = 0; i < outputViewsNeeded; i++) {
+          console.assert(k == this.outputViews[i].byteOffset, 'AudioWorklet internal error in addresses of the output array views');
+          k -= bytesPerChannel;
+        }
+        // And that the views' size match the passed in output buffers
+        for (i of outputList) {
+          for (j of i) {
+            console.assert(j.byteLength == bytesPerChannel, `AudioWorklet unexpected output buffer size (expected ${bytesPerChannel} got ${j.byteLength})`);
+          }
+        }
       }
+#endif
 
       // Call out to Wasm callback to perform audio processing
-      if (didProduceAudio = this.callbackFunction(numInputs, inputsPtr, numOutputs, outputsPtr, numParams, paramsPtr, this.userData)) {
+      if (didProduceAudio =  this.callbackFunction(numInputs, {{{ toIndexType('inputsPtr') }}}, numOutputs, {{{ toIndexType('outputsPtr') }}}, numParams, {{{ toIndexType('paramsPtr') }}}, this.userData)) {
         // Read back the produced audio data to all outputs and their channels.
-        // (A garbage-free function TypedArray.copy(dstTypedArray, dstOffset,
-        // srcTypedArray, srcOffset, count) would sure be handy..  but web does
-        // not have one, so manually copy all bytes in)
+        // The preallocated 'outputViews' already have the correct offsets and
+        // sizes into the stack (recall from the ctor that they run backwards).
+        k = outputViewsNeeded - 1;
         for (i of outputList) {
           for (j of i) {
-            for (k = 0; k < this.samplesPerChannel; ++k) {
-              j[k] = HEAPF32[outputDataPtr++];
-            }
+            j.set(this.outputViews[k--]);
           }
         }
       }
@@ -195,12 +276,7 @@ class BootstrapMessages extends AudioWorkletProcessor {
         // 'ud' the passed user data
         p.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']);
+        Module['wasmTable'].get({{{ toIndexType('d[\'_wsc\']') }}})(...d['x']);
       };
     }
   }

src/lib/libwebaudio.js

@@ -78,7 +78,7 @@ let LibraryWebAudio = {
 #if WEBAUDIO_DEBUG
       console.log(`emscripten_resume_audio_context_async() callback: New audio state="${EmAudio[contextHandle].state}", ID=${state}`);
 #endif
-      {{{ makeDynCall('viii', 'callback') }}}(contextHandle, state, userData);
+      {{{ makeDynCall('viip', 'callback') }}}(contextHandle, state, userData);
     }
 #if WEBAUDIO_DEBUG
     console.log(`emscripten_resume_audio_context_async() resuming...`);
@@ -162,9 +162,13 @@ let LibraryWebAudio = {
     console.log(`emscripten_start_wasm_audio_worklet_thread_async() adding audioworklet.js...`);
 #endif
 
-    let audioWorkletCreationFailed = () => {
+    let audioWorkletCreationFailed = (err) => {
 #if WEBAUDIO_DEBUG
-      console.error(`emscripten_start_wasm_audio_worklet_thread_async() addModule() failed!`);
+      // Note about Cross-Origin here: a lack of Cross-Origin-Opener-Policy and
+      // Cross-Origin-Embedder-Policy headers to the client request will result
+      // in the worklet file failing to load.
+      console.error(`emscripten_start_wasm_audio_worklet_thread_async() addModule() failed! Are the Cross-Origin headers being set?`);
+      if (err) console.error(err);
 #endif
       {{{ makeDynCall('viip', 'callback') }}}(contextHandle, 0/*EM_FALSE*/, userData);
     };
@@ -178,7 +182,7 @@ let LibraryWebAudio = {
         console.error(`AudioWorklets are not supported by current browser.`);
       }
 #endif
-      return audioWorkletCreationFailed();
+      return audioWorkletCreationFailed(null);
     }
 
     // TODO: In MINIMAL_RUNTIME builds, read this file off of a preloaded Blob,
@@ -222,7 +226,7 @@ let LibraryWebAudio = {
 #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);
+      {{{ makeDynCall('viip', 'callback') }}}(contextHandle, 1/*EM_TRUE*/, userData);
     }).catch(audioWorkletCreationFailed);
   },
 
@@ -266,11 +270,13 @@ let LibraryWebAudio = {
       // Processor Name' used as a 'key' to verify the message type so as to
       // not get accidentally mixed with user submitted messages, the remainder
       // for space saving reasons, abbreviated from their variable names).
+      // Note: we can only pass clonable object, so need to pass the function
+      // pointer and not the wasm function object.
       '_wpn': UTF8ToString(HEAPU32[options]),
       'ap': audioParams,
       'ch': contextHandle,
-      'cb': callback,
-      'ud': userData
+      'cb': {{{ toIndexType('callback') }}},
+      'ud': {{{ toIndexType('userData') }}}
     });
   },
 
@@ -294,8 +300,8 @@ let LibraryWebAudio = {
       numberOfOutputs: HEAP32[options+1],
       outputChannelCount: HEAPU32[options+2] ? readChannelCountArray(HEAPU32[options+2]>>2, HEAP32[options+1]) : void 0,
       processorOptions: {
-        'cb': callback,
-        'ud': userData,
+        'cb': {{{ toIndexType('callback') }}},
+        'ud': {{{ toIndexType('userData') }}},
         'sc': emscriptenGetContextQuantumSize(contextHandle)
       }
     } : void 0;

test/test_interactive.py

@@ -334,6 +334,20 @@ def test_audio_worklet_2x_hard_pan_io(self):
     shutil.copy(test_file('webaudio/audio_files/emscripten-bass-mono.mp3'), 'audio_files/')
     self.btest_exit('webaudio/audioworklet_2x_in_hard_pan.c', args=['-sAUDIO_WORKLET', '-sWASM_WORKERS'])
 
+  # Same as 'test_audio_worklet_2x_stereo_io' but as wasm64 with the worklet stack starting 2GB in (tests for unsigned shifts in the memory offsets)
+  def test_audio_worklet_stereo_io_2gb(self):
+    os.mkdir('audio_files')
+    shutil.copy(test_file('webaudio/audio_files/emscripten-beat.mp3'), 'audio_files/')
+    shutil.copy(test_file('webaudio/audio_files/emscripten-bass.mp3'), 'audio_files/')
+    self.btest_exit('webaudio/audioworklet_in_out_stereo.c', args=['-sAUDIO_WORKLET', '-sWASM_WORKERS', '-sMEMORY64', '-sINITIAL_MEMORY=4200mb', '-DTEST_OFFSET_GB=2'])
+
+  # Same as 'test_audio_worklet_stereo_io_2gb' but with a 4GB offset
+  def test_audio_worklet_stereo_io_4gb(self):
+    os.mkdir('audio_files')
+    shutil.copy(test_file('webaudio/audio_files/emscripten-beat.mp3'), 'audio_files/')
+    shutil.copy(test_file('webaudio/audio_files/emscripten-bass.mp3'), 'audio_files/')
+    self.btest_exit('webaudio/audioworklet_in_out_stereo.c', args=['-sAUDIO_WORKLET', '-sWASM_WORKERS', '-sMEMORY64', '-sINITIAL_MEMORY=4200mb', '-DTEST_OFFSET_GB=4'])
+
 
 class interactive64(interactive):
   def setUp(self):

test/webaudio/audioworklet_test_shared.inc

@@ -28,6 +28,10 @@ EM_JS(EMSCRIPTEN_WEBAUDIO_T, createTrack, (EMSCRIPTEN_WEBAUDIO_T ctxID, const ch
   var context = emscriptenGetAudioObject(ctxID);
   if (context) {
     var audio = document.createElement('audio');
+#if __wasm64__
+    // Workaround for UTF8ToString() needing a JS number and from64() not working in EM_JS
+    url = Number(url);
+#endif
     audio.src = UTF8ToString(url);
     audio.loop = looping;
     var track = context.createMediaElementSource(audio);
@@ -82,14 +86,50 @@ void initialised(EMSCRIPTEN_WEBAUDIO_T context, bool success, void* data) {
   emscripten_create_wasm_audio_worklet_processor_async(context, &opts, &processorCreated, NULL);
 }
 
+// Common entry point for the mixer tests
+// stackSize - audio worklet stack size in bytes
+// return true if the requested memory could be allocated
+bool _main_(int stackSize) {
+  // Optional empty space before the audio worklet's stack
+#if TEST_OFFSET_GB > 0
+  char* const emptySpace = malloc(1073741824L * TEST_OFFSET_GB);
+  if (emptySpace) {
+    printf("Empty space allocated (%dGB)\n", TEST_OFFSET_GB);
+  } else {
+    printf("Failed to allocate the required memory offset\n");
+    return false;
+  }
+#endif
+
+  char* const workletStack = memalign(16, stackSize);
+  if (!workletStack) {
+      printf("Failed to allocate the required worklet stack\n");
+      return false;
+  }
+
+#if TEST_OFFSET_GB > 0
+    free(emptySpace);
+#endif
+
+  EMSCRIPTEN_WEBAUDIO_T context = emscripten_create_audio_context(NULL);
+  emscripten_start_wasm_audio_worklet_thread_async(context, workletStack, stackSize, &initialised, NULL);
+#ifndef BROWSER_TEST
+  // Special case: browser tests need to exit instantly, interactive tests need to wait
+  emscripten_runtime_keepalive_push();
+#endif
+  return true;
+}
+
 // Common entry point for the mixer tests
 int main() {
-  static char workletStack[AUDIO_STACK_SIZE];
+  char* const workletStack = memalign(16, AUDIO_STACK_SIZE);
+  printf("Audio worklet stack at 0x%p\n", workletStack);
+  assert(workletStack);
   EMSCRIPTEN_WEBAUDIO_T context = emscripten_create_audio_context(NULL);
-  emscripten_start_wasm_audio_worklet_thread_async(context, workletStack, sizeof workletStack, &initialised, NULL);
+  emscripten_start_wasm_audio_worklet_thread_async(context, workletStack, AUDIO_STACK_SIZE, &initialised, NULL);
 #ifndef BROWSER_TEST
   // Special case: browser tests need to exit instantly, interactive tests need to wait
   emscripten_runtime_keepalive_push();
 #endif
-  return 0;
+  return EXIT_SUCCESS;
 }