node-web-audio-api 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v0.20.0 (29/04/2024)
+
+- Update upstream crate to [v0.44.0](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-0440-2024-04-22)
+- Implement ScriptProcessorNode
+- Fix memory leak introduced in v0.19.0
+- Improve events compliance
+
+## v0.19.0 (17/04/2024)
+
+- Update upstream crate to [1.0.0-rc.5](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-0430--100-rc5-2024-04-15)
+- Provide JS facades with proper inheritance chain for all exposed interfaces
+- Implement all AudioNode connect / disconnect alternatives
+- Improve compliance and error handling
+
 ## v0.18.0 (13/03/2024)
 
 - Fix `MediaStreamAudioSourceNode`

package/TODOS.md

@@ -1,21 +1,143 @@
 # TODO
 
-- [ ] Review AudioBuffer
-- [ ] Ended event in AudioScheduledSourceNode for offline audio context
-- [ ] `MediaStreamAudioSourceNode` 
-    + [x] properly handle `mediaStream`
-    + [ ] do not accept OfflineAudioContext (see if this can be delegated to upstream)
+## MISC
+
+- [x] decode audio data in dedicated thread
+- [x] Use node DOMExeption <https://nodejs.org/api/globals.html#domexception>
+- [x] connect / disconnect
+- [x] _napi_ review tsfn store implementation _or remove_
+- [x] implement ScriptProcesorNode _on going_
+- [x] _napi_ clean internal audio_buffer __internal_caller__, use JsNull instead
+- [x] Refactor Events:
+    + [x] extend Event for all specific event types
+    + [x] Register AudioScheduledSourceNode listener only on start
+    
+- [ ] reuse event objects across calls
+
+-> proxy EventListener
+    
+- [ ] wpt: mock for `URL.createObjectURL`
+- [ ] wpt: mock for `requestAnimationFrame` cf. https://github.com/nodejs/help/issues/2483
+- [ ] make sure we don't try to use `in` operator on null values
+
+- [ ] _rust_ AudioParam failing tests
+- [ ] _rust_ AudioBufferSourceNode failing tests
+- [ ] _rust_ IIRFilter node
+
+- [ ] refactor - Add context string in `throwSanitizedError` and to `toSanitizedSequence`
+- [ ] Rust - review Symbol.toStringTag https://github.com/nodejs/node/issues/41358
+      cf. https://github.com/nodejs/node/issues/41358#issuecomment-1003595890
+```
+// fails...
+let symbols = ctx
+    .env
+    .get_global()?
+    .get_named_property::<JsUnknown>("Symbol")?
+    .coerce_to_object()?;
+let to_string_tag = symbols.get_named_property("toStringTag")?;
+
+js_this.set_property(to_string_tag, &ctx.env.create_string("AudioContext")?);
+
+// ----
+151 |     js_this.set_property(to_string_tag, &ctx.env.create_string("AudioContext")?);
+    |             ------------ ^^^^^^^^^^^^^ the trait `napi::NapiRaw` is not implemented for `()`
+```
 
 - [ ] wpt bot
+- [ ] wpt - handle loading of 4-channels sound file
+
+- [ ] _rust_ decodeAudioData should throw EncodingError
+      - review JS side when done
+
+- [-] AnalyserNode -> requires script processor and request animation frame
+
+- [x] DelayNode
+- [x] protect AudioBuffer arguments
+- [x] AudioNode setters (handle enum types, cf audio param too)
+- [x] This is weird `jsExport.AudioBuffer = require('./AudioBuffer.js').AudioBuffer(nativeBinding.AudioBuffer);`
+- [x] Ended event in AudioScheduledSourceNode for offline audio context
+
+- cf. util.types.isSharedArrayBuffer(value)
+
+## Notes
+
+- wpt/webaudio/the-audio-api/the-dynamicscompressornode-interface/dynamicscompressor-basic.html sometimes pass, sometimes fail because audio context is resumed
+
+------------------------------------------------------------------------
+
+## `onstatechnage` and `onsinkchange`
+
+### https://webaudio.github.io/web-audio-api/#eventdef-baseaudiocontext-statechange
+ 
+> A newly-created AudioContext will always begin in the suspended state, and a state change event will be fired whenever the state changes to a different state. This event is fired before the complete event is fired.
 
-- [ ] OfflineAudioContext should not lock the process w/ event listeners if startRendering has not been called
+### https://webaudio.github.io/web-audio-api/#dom-audiocontext-onsinkchange
   
-- [ ] wrap EventTarget::dispatchEvent in setTimeout(callback , 0); so that events are dispatched in the next microtask ?
+> NOTE: This is not dispatched for the initial device selection in the construction of AudioContext. The statechange event is available to check the readiness of the initial output device.
+
+cf. the-audiocontext-interface/audiocontext-sinkid-state-change.https.html
+
+### Notes
+
+We should explicitly resume context at startup, just as a context created in a console or localhost
+
+What happens when sinkId is changed while context is suspended? It seems that it is resumed:
+
+```rs
+Startup { graph } => {
+    debug_assert!(self.graph.is_none());
+    self.graph = Some(graph);
+    self.set_state(AudioContextState::Running);
+}
+```
+
+@todo - create a test bed
+
+- testing AudioContextOptions.sinkId requires this fix
+  the-audiocontext-interface/audiocontext-sinkid-constructor.https.html
+- setting sink on supended audioContext test too
+  the-audiocontext-interface/audiocontext-sinkid-state-change.https.html
+
+------------------------------------------------------------------------
+
+## Issue in spec / wpt
+
+- [ ] review waveshaper curve (need to be able to set back to null) 
+    <https://webaudio.github.io/web-audio-api/#dom-waveshapernode-curve>
+    To set the curve attribute, execute these steps:
+    - Let new curve be a Float32Array to be assigned to curve or null. .
+    - If new curve is not null and [[curve set]] is true, throw an InvalidStateError and abort these steps.
+    - If new curve is not null, set [[curve set]] to true.
+    - Assign new curve to the curve attribute.
+    
+    -> Spec is not inline with wpt tests, both chrome and firefox accept setting curve several times (which makes sens...), without passing to null first
+    -> Curve defined as sequence<float> in arguments but as Float32Array in attributes
+    -> Means that we can't pass non finite values in ctor but we can with setter
+
+- [ ] AudioDestination::numberOfOutputs
+    - implementation and wpt report 0
+      cf. webaudio/the-audio-api/the-audionode-interface/audionode.html
+    - spec specifies 1: https://webaudio.github.io/web-audio-api/#AudioDestinationNode
+    
+- [ ] Analyser::fftSize
+    - wpt defines that when set to -1 it should throw an IndexSizeError, when not a type error as it is defined as unsigned long?
+    cf. the-analysernode-interface/realtimeanalyser-fft-sizing.html
+    cf. https://webidl.spec.whatwg.org/#js-attributes
+        setter step 4.6
+    - same with getChannelData
+    
+- [ ] wpt - propose patch to remove patch regarding `audiobuffersource-multi-channels-expected.wav`in XMLHttpRequest Mock
+
+- [ ] Propose a test for decodeAudioData
+      "Let error be a DOMException whose name is EncodingError."
+
+- [ ] ScriptProcessorNode rehabilitation
+    - padenot mail vs spec
+
+------------------------------------------------------------------------
 
+ls wpt/webaudio/the-audio-api/the-audiocontext-interface | xargs -I {} ./run-wpt.sh {} 
+ls wpt/webaudio/the-audio-api/the-dynamicscompressornode-interface | xargs -I {} ./run-wpt.sh {} 
 
-## AudioBuffer notes
 
-- [x] `AudioBuffer` has to be a facade because `startRendering`, `decodeAudioData`
-- [x] need to adapt `AudioBufferSourceNode` and `ConvolverNode` so 
-that `set buffer(value)` retrieve the wrapped value
-- [ ] No fucking sound when buffer comes from `decodeAudioData`..., but ok when `createBuffer`
+971

package/index.mjs

@@ -20,18 +20,32 @@
 // re-export index.cjs to support esm import syntax
 // see https://github.com/nodejs/node/issues/40541#issuecomment-951609570
 
-import { createRequire } from 'module';
+import {
+  createRequire,
+} from 'module';
 const require = createRequire(import.meta.url);
 
 const nativeModule = require('./index.cjs');
 export const {
+  // events
+  OfflineAudioCompletionEvent,
+  AudioProcessingEvent,
+
+  // manually written nodes
+  BaseAudioContext,
   AudioContext,
   OfflineAudioContext,
+
+  AudioNode,
+  AudioScheduledSourceNode,
   AudioParam,
   AudioDestinationNode,
-  AudioBuffer,
+  AudioListener,
+
   PeriodicWave,
-  // generated supported nodes
+  AudioBuffer,
+  // generated nodes
+  ScriptProcessorNode,
   AnalyserNode,
   AudioBufferSourceNode,
   BiquadFilterNode,
@@ -54,6 +68,3 @@ export const {
 } = nativeModule;
 
 export default nativeModule;
-
-
-  

package/js/AnalyserNode.js

@@ -17,114 +17,298 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// eslint-disable-next-line no-unused-vars
-const { throwSanitizedError } = require('./lib/errors.js');
-// eslint-disable-next-line no-unused-vars
-const { AudioParam } = require('./AudioParam.js');
-const EventTargetMixin = require('./EventTarget.mixin.js');
-const AudioNodeMixin = require('./AudioNode.mixin.js');
+/* eslint-disable no-unused-vars */
+const conversions = require('webidl-conversions');
+const {
+  toSanitizedSequence,
+} = require('./lib/cast.js');
+const {
+  isFunction,
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  kNapiObj,
+  kAudioBuffer,
+} = require('./lib/symbols.js');
+/* eslint-enable no-unused-vars */
 
+const AudioNode = require('./AudioNode.js');
 
-module.exports = (NativeAnalyserNode) => {
-
-  const EventTarget = EventTargetMixin(NativeAnalyserNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
-
+module.exports = (jsExport, nativeBinding) => {
   class AnalyserNode extends AudioNode {
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'AnalyserNode': argument 2 is not of type 'AnalyserOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'AnalyserNode': 1 argument required, but only ${arguments.length} present`);
       }
 
-      super(context, options);
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'AnalyserNode': argument 1 is not of type BaseAudioContext`);
+      }
 
-    }
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
 
-    // getters
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'AnalyserNode\': argument 2 is not of type \'AnalyserOptions\'');
+      }
 
-    get fftSize() {
-      return super.fftSize;
-    }
+      if (options && options.fftSize !== undefined) {
+        parsedOptions.fftSize = conversions['unsigned long'](options.fftSize, {
+          enforceRange: true,
+          context: `Failed to construct 'AnalyserNode': Failed to read the 'fftSize' property from AnalyserOptions: The provided value (${options.fftSize}})`,
+        });
+      } else {
+        parsedOptions.fftSize = 2048;
+      }
 
-    get frequencyBinCount() {
-      return super.frequencyBinCount;
-    }
+      if (options && options.maxDecibels !== undefined) {
+        parsedOptions.maxDecibels = conversions['double'](options.maxDecibels, {
+          context: `Failed to construct 'AnalyserNode': Failed to read the 'maxDecibels' property from AnalyserOptions: The provided value (${options.maxDecibels}})`,
+        });
+      } else {
+        parsedOptions.maxDecibels = -30;
+      }
 
-    get minDecibels() {
-      return super.minDecibels;
-    }
+      if (options && options.minDecibels !== undefined) {
+        parsedOptions.minDecibels = conversions['double'](options.minDecibels, {
+          context: `Failed to construct 'AnalyserNode': Failed to read the 'minDecibels' property from AnalyserOptions: The provided value (${options.minDecibels}})`,
+        });
+      } else {
+        parsedOptions.minDecibels = -100;
+      }
 
-    get maxDecibels() {
-      return super.maxDecibels;
-    }
+      if (options && options.smoothingTimeConstant !== undefined) {
+        parsedOptions.smoothingTimeConstant = conversions['double'](options.smoothingTimeConstant, {
+          context: `Failed to construct 'AnalyserNode': Failed to read the 'smoothingTimeConstant' property from AnalyserOptions: The provided value (${options.smoothingTimeConstant}})`,
+        });
+      } else {
+        parsedOptions.smoothingTimeConstant = 0.8;
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'AnalyserNode': Failed to read the 'channelCount' property from AnalyserOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'AnalyserNode': Failed to read the 'channelCount' property from AnalyserOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'AnalyserNode': Failed to read the 'channelInterpretation' property from AnalyserOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.AnalyserNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
 
-    get smoothingTimeConstant() {
-      return super.smoothingTimeConstant;
     }
 
-    // setters
+    get fftSize() {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      return this[kNapiObj].fftSize;
+    }
 
     set fftSize(value) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      // @fixme - wpt pretends that when set to -1, this should throw IndexSizeError, not a TypeError.
+      // For now let's just cast it to Number without further checks, and let Rust do the job
+      // as 0 is an invalid value too
+      // value = conversions['unsigned long'](value, {
+      //   enforceRange: true,
+      //   context: `Failed to set the 'fftSize' property on 'AnalyserNode': Value`
+      // });
+      value = conversions['unrestricted double'](value, {
+        context: `Failed to set the 'fftSize' property on 'AnalyserNode': Value`,
+      });
+
       try {
-        super.fftSize = value;
+        this[kNapiObj].fftSize = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
+    get frequencyBinCount() {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      return this[kNapiObj].frequencyBinCount;
+    }
+
+    get minDecibels() {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      return this[kNapiObj].minDecibels;
+    }
+
     set minDecibels(value) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      value = conversions['double'](value, {
+        context: `Failed to set the 'minDecibels' property on 'AnalyserNode': Value`,
+      });
+
       try {
-        super.minDecibels = value;
+        this[kNapiObj].minDecibels = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
+    get maxDecibels() {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      return this[kNapiObj].maxDecibels;
+    }
+
     set maxDecibels(value) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      value = conversions['double'](value, {
+        context: `Failed to set the 'maxDecibels' property on 'AnalyserNode': Value`,
+      });
+
       try {
-        super.maxDecibels = value;
+        this[kNapiObj].maxDecibels = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
+    get smoothingTimeConstant() {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      return this[kNapiObj].smoothingTimeConstant;
+    }
+
     set smoothingTimeConstant(value) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      value = conversions['double'](value, {
+        context: `Failed to set the 'smoothingTimeConstant' property on 'AnalyserNode': Value`,
+      });
+
       try {
-        super.smoothingTimeConstant = value;
+        this[kNapiObj].smoothingTimeConstant = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    // methods
-    
-    getFloatFrequencyData(...args) {
+    getFloatFrequencyData(array) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'getFloatFrequencyData' on 'AnalyserNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(array instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFloatFrequencyData' on 'AnalyserNode': Parameter 1 is not of type 'Float32Array'`);
+      }
+
       try {
-        return super.getFloatFrequencyData(...args);
+        return this[kNapiObj].getFloatFrequencyData(array);
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    getByteFrequencyData(...args) {
+    getByteFrequencyData(array) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'getByteFrequencyData' on 'AnalyserNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(array instanceof Uint8Array)) {
+        throw new TypeError(`Failed to execute 'getByteFrequencyData' on 'AnalyserNode': Parameter 1 is not of type 'Uint8Array'`);
+      }
+
       try {
-        return super.getByteFrequencyData(...args);
+        return this[kNapiObj].getByteFrequencyData(array);
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    getFloatTimeDomainData(...args) {
+    getFloatTimeDomainData(array) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'getFloatTimeDomainData' on 'AnalyserNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(array instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFloatTimeDomainData' on 'AnalyserNode': Parameter 1 is not of type 'Float32Array'`);
+      }
+
       try {
-        return super.getFloatTimeDomainData(...args);
+        return this[kNapiObj].getFloatTimeDomainData(array);
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    getByteTimeDomainData(...args) {
+    getByteTimeDomainData(array) {
+      if (!(this instanceof AnalyserNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AnalyserNode\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'getByteTimeDomainData' on 'AnalyserNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(array instanceof Uint8Array)) {
+        throw new TypeError(`Failed to execute 'getByteTimeDomainData' on 'AnalyserNode': Parameter 1 is not of type 'Uint8Array'`);
+      }
+
       try {
-        return super.getByteTimeDomainData(...args);
+        return this[kNapiObj].getByteTimeDomainData(array);
       } catch (err) {
         throwSanitizedError(err);
       }
@@ -132,8 +316,35 @@ module.exports = (NativeAnalyserNode) => {
 
   }
 
-  return AnalyserNode;
-};
+  Object.defineProperties(AnalyserNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
 
+  Object.defineProperties(AnalyserNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'AnalyserNode',
+    },
 
-  
+    fftSize: kEnumerableProperty,
+    frequencyBinCount: kEnumerableProperty,
+    minDecibels: kEnumerableProperty,
+    maxDecibels: kEnumerableProperty,
+    smoothingTimeConstant: kEnumerableProperty,
+    getFloatFrequencyData: kEnumerableProperty,
+    getByteFrequencyData: kEnumerableProperty,
+    getFloatTimeDomainData: kEnumerableProperty,
+    getByteTimeDomainData: kEnumerableProperty,
+  });
+
+  return AnalyserNode;
+};