node-web-audio-api 0.14.0 → 0.16.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## v0.16.0 (09/02/2024)
+
+- Update upstream create to [v0.42.0](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-0420-2024-02-05)
+- Improve Error handling
+- Add channelCounnt to media constraints
+
+## v0.15.0 (16/01/2024)
+
+- Update upstream create to [v0.41.1](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-0411-2024-01-11)
+- Better error handling
+- Implement online AudioContext and AudioScheduledSourceNode events
+- Test against wpt
+
 ## v0.14.0 (06/12/2023)
 
 - Update upstream create to [v0.38.0](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-0380-2023-12-03)

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2021-2022 IRCAM – Centre Pompidou (France, Paris)
+Copyright (c) 2021-present IRCAM – Centre Pompidou (France, Paris)
 
 All rights reserved.
 

package/README.md

@@ -2,9 +2,9 @@
 
 [![npm version](https://badge.fury.io/js/node-web-audio-api.svg)](https://badge.fury.io/js/node-web-audio-api)
 
-Node.js bindings for the Rust implementation of the Web Audio API Specification
+Node.js bindings for the Rust implementation of the [Web Audio API](https://www.w3.org/TR/webaudio/).
 
-The goal of this library is to provide an implementation that is both efficient and _exactly_ matches the browsers' API.
+This library aims to provide an implementation that is both efficient and compliant with the specification.
 
 - see [`orottier/web-audio-api-rs`](https://github.com/orottier/web-audio-api-rs/) for the "real" audio guts
 - use [`napi-rs`](https://github.com/napi-rs/napi-rs/) for the Node.js bindings
@@ -19,23 +19,22 @@ npm install [--save] node-web-audio-api
 
 ```js
 import { AudioContext, OscillatorNode, GainNode } from 'node-web-audio-api';
-// or using old fashionned commonjs syntax:
+// or using old fashioned commonjs syntax:
 // const { AudioContext, OscillatorNode, GainNode } = require('node-web-audio-api');
-
 const audioContext = new AudioContext();
 
 setInterval(() => {
   const now = audioContext.currentTime;
+  const frequency = 200 + Math.random() * 2800;
 
-  const env = new GainNode(audioContext);
+  const env = new GainNode(audioContext, { gain: 0 });
   env.connect(audioContext.destination);
-  env.gain.value = 0;
-  env.gain.setValueAtTime(0, now);
-  env.gain.linearRampToValueAtTime(1, now + 0.02);
-  env.gain.exponentialRampToValueAtTime(0.0001, now + 1);
+  env.gain
+    .setValueAtTime(0, now)
+    .linearRampToValueAtTime(0.2, now + 0.02)
+    .exponentialRampToValueAtTime(0.0001, now + 1);
 
-  const osc = new OscillatorNode(audioContext);
-  osc.frequency.value = 200 + Math.random() * 2800;
+  const osc = new OscillatorNode(audioContext, { frequency });
   osc.connect(env);
   osc.start(now);
   osc.stop(now + 1);
@@ -66,8 +65,9 @@ node examples/granular-scrub.mjs
 
 ## Caveats
 
-- The async methods are not trully async for now and are just patched on the JS side. This will evolve once the "trully" async version of the methods are implemented in the upstream library.
-- On Raspberry Pi, the `Linux arm gnueabihf` binary provided only works on 32bit OS. We will provide a version for the 64 bit OS in the future.
+- Missing nodes: `ScriptProcessorNode`, `AudioWorkletNode`.
+- Streams: only a minimial audio input stream and the `MediaStreamSourceNode` are provided. All other `MediaStream` features are left on the side for now as they principaly concern a different API specification, which is not a trivial problem.
+- Some async methods (e.g. `decodeAudioData`, `setSinkId`) are not trully async yet. This will evolve with the implemetation of the async version in the upstream crate.
 
 ## Supported Platforms
 
@@ -76,7 +76,7 @@ node examples/granular-scrub.mjs
 | Windows x64                  | ✓        |        |
 | Windows arm64                | ✓        |        |
 | macOS x64                    | ✓        | ✓      |
-| macOS aarch64                | ✓        |        |
+| macOS aarch64                | ✓        | ✓      |
 | Linux x64 gnu                | ✓        |        |
 | Linux arm gnueabihf (RPi)    | ✓        | ✓      |
 | Linux arm64 gnu (RPi)        | ✓        | ✓      |
@@ -90,14 +90,14 @@ Using the library on Linux with the ALSA backend might lead to unexpected cranky
 const audioContext = new AudioContext({ latencyHint: 'playback' });
 ```
 
-You can pass the `WEB_AUDIO_LATENCY=playback` env variable to all examples to create the audio context with the playback latency hint, e.g.:
+For real-time and interactive applications where low latency is crucial, you should instead rely on the JACK backend provided by `cpal`. By default the audio context will use that backend if a running JACK server is found.
+
+If you don't have JACK installed, you can still pass the `WEB_AUDIO_LATENCY=playback` env variable to all examples to create the audio context with the playback latency hint, e.g.:
 
 ```sh
 WEB_AUDIO_LATENCY=playback node examples/amplitude-modulation.mjs
 ```
 
-For real-time and interactive applications where low latency is crucial, you should instead rely on the JACK backend provided by `cpal`. By default the audio context will use that backend if a running JACK server is found.
-
 ### Manual Build
 
 If prebuilt binaries are not shippped for your platform, you will need to:
@@ -129,6 +129,24 @@ The npm `postversion` script rely on [`cargo-bump`](https://crates.io/crates/car
 cargo install cargo-bump
 ```
 
+## Running the web-platform-test suite
+
+Follow the steps for 'Manual Build' first. Then checkout the web-platform-tests submodule with:
+
+```
+git submodule init
+git submodule update
+```
+
+Then run:
+
+```
+npm run wpt                      # build in debug mode and run all wpt test
+npm run wpt:only                 # run all wpt test without build
+npm run wpt -- --list            # list all wpt test files
+npm run wpt -- --filter <string> # apply <string> filter on executed/listed wpt tests 
+```
+
 ## License
 
 [BSD-3-Clause](./LICENSE)

package/index.cjs

@@ -83,7 +83,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding for OS: ${platform}, architecture: ${arch}`);
 }
 
-const monkeyPatch = require('./monkey-patch.js');
+const monkeyPatch = require('./js/monkey-patch.js');
 nativeBinding = monkeyPatch(nativeBinding);
 
 module.exports = nativeBinding;

package/index.mjs

@@ -17,7 +17,7 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// re-export index.js to support clean esm syntax
+// re-export index.cjs to support esm import syntax
 // see https://github.com/nodejs/node/issues/40541#issuecomment-951609570
 
 import { createRequire } from 'module';
@@ -54,4 +54,5 @@ export const {
 
 export default nativeModule;
 
+
   

package/js/AnalyserNode.js

@@ -0,0 +1,135 @@
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+//                                                                            //
+//                                                                            //
+//                                                                            //
+//    ██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗               //
+//    ██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝               //
+//    ██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗              //
+//    ██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║              //
+//    ╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝              //
+//     ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝               //
+//                                                                            //
+//                                                                            //
+//    - This file has been generated ---------------------------              //
+//                                                                            //
+//                                                                            //
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+
+// 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');
+
+
+module.exports = (NativeAnalyserNode) => {
+
+  const EventTarget = EventTargetMixin(NativeAnalyserNode);
+  const AudioNode = AudioNodeMixin(EventTarget);
+
+  class AnalyserNode extends AudioNode {
+    constructor(context, options) {
+      super(context, options);
+
+    }
+
+    // getters
+
+    get fftSize() {
+      return super.fftSize;
+    }
+
+    get frequencyBinCount() {
+      return super.frequencyBinCount;
+    }
+
+    get minDecibels() {
+      return super.minDecibels;
+    }
+
+    get maxDecibels() {
+      return super.maxDecibels;
+    }
+
+    get smoothingTimeConstant() {
+      return super.smoothingTimeConstant;
+    }
+
+    // setters
+
+    set fftSize(value) {
+      try {
+        super.fftSize = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set minDecibels(value) {
+      try {
+        super.minDecibels = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set maxDecibels(value) {
+      try {
+        super.maxDecibels = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set smoothingTimeConstant(value) {
+      try {
+        super.smoothingTimeConstant = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    // methods
+    
+    getFloatFrequencyData(...args) {
+      try {
+        return super.getFloatFrequencyData(...args);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    getByteFrequencyData(...args) {
+      try {
+        return super.getByteFrequencyData(...args);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    getFloatTimeDomainData(...args) {
+      try {
+        return super.getFloatTimeDomainData(...args);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    getByteTimeDomainData(...args) {
+      try {
+        return super.getByteTimeDomainData(...args);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+  }
+
+  return AnalyserNode;
+};
+
+
+  

package/js/AudioBufferSourceNode.js

@@ -0,0 +1,105 @@
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+//                                                                            //
+//                                                                            //
+//                                                                            //
+//    ██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗               //
+//    ██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝               //
+//    ██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗              //
+//    ██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║              //
+//    ╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝              //
+//     ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝               //
+//                                                                            //
+//                                                                            //
+//    - This file has been generated ---------------------------              //
+//                                                                            //
+//                                                                            //
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+
+// 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');
+const AudioScheduledSourceNodeMixin = require('./AudioScheduledSourceNode.mixin.js');
+
+module.exports = (NativeAudioBufferSourceNode) => {
+
+  const EventTarget = EventTargetMixin(NativeAudioBufferSourceNode, ['ended']);
+  const AudioNode = AudioNodeMixin(EventTarget);
+  const AudioScheduledSourceNode = AudioScheduledSourceNodeMixin(AudioNode);
+
+  class AudioBufferSourceNode extends AudioScheduledSourceNode {
+    constructor(context, options) {
+      super(context, options);
+      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
+      // bound to this, then we can safely finalize event target initialization
+      super.__initEventTarget__();
+
+      this.playbackRate = new AudioParam(this.playbackRate);
+      this.detune = new AudioParam(this.detune);
+    }
+
+    // getters
+
+    get buffer() {
+      return super.buffer;
+    }
+
+    get loop() {
+      return super.loop;
+    }
+
+    get loopStart() {
+      return super.loopStart;
+    }
+
+    get loopEnd() {
+      return super.loopEnd;
+    }
+
+    // setters
+
+    set buffer(value) {
+      try {
+        super.buffer = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set loop(value) {
+      try {
+        super.loop = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set loopStart(value) {
+      try {
+        super.loopStart = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set loopEnd(value) {
+      try {
+        super.loopEnd = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    // methods
+    
+  }
+
+  return AudioBufferSourceNode;
+};
+
+
+  

package/js/AudioContext.js

@@ -0,0 +1,60 @@
+let contextId = 0;
+
+const kProcessId = Symbol('processId');
+const kKeepAwakeId = Symbol('keepAwakeId');
+
+module.exports = function(bindings) {
+  const {
+    MediaStreamAudioSourceNode,
+  } = bindings;
+
+  const EventTarget = require('./EventTarget.mixin.js')(bindings.AudioContext, ['statechange', 'sinkchange']);
+  const BaseAudioContext = require('./BaseAudioContext.mixin.js')(EventTarget, bindings);
+
+  class AudioContext extends BaseAudioContext {
+  // class AudioContext extends NativeAudioContext {
+    constructor(options = {}) {
+      super(options);
+      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
+      // bound to this, then we can safely finalize event target initialization
+      super.__initEventTarget__();
+
+      // prevent garbage collection and process exit
+      const id = contextId++;
+      // store in process to prevent garbage collection
+      const processId = Symbol(`__AudioContext_${id}`);
+      process[processId] = this;
+      // keep process symbol around to delete later
+      this[kProcessId] = processId;
+      // keep process awake until context is closed
+      const keepAwakeId = setInterval(() => {}, 10 * 1000);
+      this[kKeepAwakeId] = keepAwakeId;
+
+      // clear on close
+      this.addEventListener('statechange', () => {
+        if (this.state === 'closed') {
+          // allow to garbage collect the context and to the close the process
+          delete process[this[kProcessId]];
+          clearTimeout(this[kKeepAwakeId]);
+        }
+      });
+    }
+
+    setSinkId(sinkId) {
+      try {
+        super.setSinkId(sinkId);
+        return Promise.resolve(undefined);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+
+    // online context only AudioNodes
+    createMediaStreamSource(mediaStream) {
+      const options = { mediaStream };
+      return new MediaStreamAudioSourceNode(this, options);
+    }
+  }
+
+  return AudioContext;
+};

package/js/AudioNode.mixin.js

@@ -0,0 +1,121 @@
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+//                                                                            //
+//                                                                            //
+//                                                                            //
+//    ██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗               //
+//    ██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝               //
+//    ██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗              //
+//    ██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║              //
+//    ╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝              //
+//     ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝               //
+//                                                                            //
+//                                                                            //
+//    - This file has been generated ---------------------------              //
+//                                                                            //
+//                                                                            //
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+
+const { throwSanitizedError } = require('./lib/errors.js');
+
+const { AudioParam, kNativeAudioParam } = require('./AudioParam.js');
+
+module.exports = (superclass) => {
+  class AudioNode extends superclass {
+    /* eslint-disable constructor-super */
+    constructor(...args) {
+      try {
+        super(...args);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+    /* eslint-enable constructor-super */
+
+    // getters
+
+    get context() {
+      return super.context;
+    }
+
+    get numberOfInputs() {
+      return super.numberOfInputs;
+    }
+
+    get numberOfOutputs() {
+      return super.numberOfOutputs;
+    }
+
+    get channelCount() {
+      return super.channelCount;
+    }
+
+    get channelCountMode() {
+      return super.channelCountMode;
+    }
+
+    get channelInterpretation() {
+      return super.channelInterpretation;
+    }
+
+    // setters
+
+    set channelCount(value) {
+      try {
+        super.channelCount = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set channelCountMode(value) {
+      try {
+        super.channelCountMode = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    set channelInterpretation(value) {
+      try {
+        super.channelInterpretation = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    // methods - connect / disconnect
+    
+    connect(...args) {
+      // unwrap raw audio params from facade
+      if (args[0] instanceof AudioParam) {
+        args[0] = args[0][kNativeAudioParam];
+      }
+
+      try {
+        return super.connect(...args);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    disconnect(...args) {
+      // unwrap raw audio params from facade
+      if (args[0] instanceof AudioParam) {
+        args[0] = args[0][kNativeAudioParam];
+      }
+
+      try {
+        return super.disconnect(...args);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+  }
+
+  return AudioNode;
+};
+
+