node-web-audio-api 0.18.0 → 0.19.0

package/js/AudioBuffer.js

@@ -0,0 +1,244 @@
+const conversions = require("webidl-conversions");
+
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  kEnumerableProperty,
+  kHiddenProperty,
+} = require('./lib/utils.js');
+const {
+  kNapiObj,
+  kAudioBuffer,
+} = require('./lib/symbols.js');
+
+
+module.exports = (_jsExport, nativeBinding) => {
+  class AudioBuffer {
+    constructor(options) {
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'AudioBuffer': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'AudioBuffer': argument 1 is not of type 'AudioBufferOptions'");
+      }
+
+      if (kNapiObj in options) {
+        // internal constructor for `startRendering` and `decodeAudioData` cases
+        Object.defineProperty(this, kNapiObj, {
+          value: options[kNapiObj],
+          ...kHiddenProperty,
+        });
+      } else {
+        // Regular public constructor
+        // dictionary AudioBufferOptions {
+        //     unsigned long numberOfChannels = 1;
+        //     required unsigned long length;
+        //     required float sampleRate;
+        // };
+        const parsedOptions = {};
+
+        if (options.numberOfChannels !== undefined) {
+          parsedOptions.numberOfChannels = conversions['unsigned long'](options.numberOfChannels, {
+            enforceRange: true,
+            context: `Failed to construct 'AudioBuffer': Failed to read the 'numberOfChannels' property from AudioBufferOptions: numberOfCHannels`,
+          });
+        } else {
+          parsedOptions.numberOfChannels = 1;
+        }
+
+        if (options.length === undefined) {
+          throw new TypeError(`Failed to construct 'AudioBuffer': Failed to read the 'numberOfChannels' property from AudioBufferOptions: required member is undefined`);
+        }
+
+        parsedOptions.length = conversions['unsigned long'](options.length, {
+          enforceRange: true,
+          context: `Failed to construct 'AudioBuffer': Failed to read the 'length' property from AudioBufferOptions: length`,
+        });
+
+        if (options.sampleRate === undefined) {
+          throw new TypeError(`Failed to construct 'AudioBuffer': Failed to read the 'numberOfChannels' property from AudioBufferOptions: required member is undefined`);
+        }
+
+        parsedOptions.sampleRate = conversions['float'](options.sampleRate, {
+          context: `Failed to construct 'AudioBuffer': Failed to read the 'sampleRate' property from AudioBufferOptions: sampleRate`,
+        });
+
+        let napiObj;
+
+        try {
+          napiObj = new nativeBinding.AudioBuffer(parsedOptions);
+        } catch (err) {
+          throwSanitizedError(err);
+        }
+
+        Object.defineProperty(this, kNapiObj, {
+          value: napiObj,
+          ...kHiddenProperty,
+        });
+      }
+    }
+
+    get sampleRate() {
+      if (!(this instanceof AudioBuffer)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'AudioBuffer'");
+      }
+
+      return this[kNapiObj].sampleRate;
+    }
+
+    get duration() {
+      if (!(this instanceof AudioBuffer)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'AudioBuffer'");
+      }
+
+      return this[kNapiObj].duration;
+    }
+
+    get length() {
+      if (!(this instanceof AudioBuffer)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'AudioBuffer'");
+      }
+
+      return this[kNapiObj].length;
+    }
+
+    get numberOfChannels() {
+      if (!(this instanceof AudioBuffer)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'AudioBuffer'");
+      }
+
+      return this[kNapiObj].numberOfChannels;
+    }
+
+    copyFromChannel(destination, channelNumber, bufferOffset = 0) {
+      if (!(this instanceof AudioBuffer)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'AudioBuffer'");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(`Failed to execute 'copyFromChannel' on 'AudioBuffer': 2 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(destination instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'copyFromChannel' on 'AudioBuffer': parameter 1 is not of type 'Float32Array'`);
+      }
+
+      // Rust implementation uses a usize which will clamp -1 to 0, and spec requires
+      // an IndexSizeError rather than a TypeError, so this check must be done here.
+      // cf. note on AnalyzerNode::fftSize
+      if (channelNumber < 0) {
+        throw new DOMException(`Failed to execute 'copyFromChannel' on 'AudioBuffer': channelNumber must equal or greater than 0`, 'IndexSizeError');
+      }
+
+      channelNumber = conversions['unsigned long'](channelNumber, {
+        context: `Failed to execute 'copyFromChannel' on 'AudioBuffer': channelNumber`,
+      });
+
+      bufferOffset = conversions['unsigned long'](bufferOffset, {
+        context: `Failed to execute 'copyFromChannel' on 'AudioBuffer': bufferOffset`,
+      });
+
+      try {
+        this[kNapiObj].copyFromChannel(destination, channelNumber, bufferOffset);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    copyToChannel(source, channelNumber, bufferOffset = 0) {
+      if (!(this instanceof AudioBuffer)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'AudioBuffer'");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(`Failed to execute 'copyToChannel' on 'AudioBuffer': 2 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(source instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'copyToChannel' on 'AudioBuffer': source is not of type 'Float32Array'`);
+      }
+
+      // Rust implementation uses a usize which will clamp -1 to 0, and spec requires
+      // an IndexSizeError rather than a TypeError, so this check must be done here.
+      // cf. note on AnalyzerNode::fftSize
+      if (channelNumber < 0) {
+        throw new DOMException(`Failed to execute 'copyToChannel' on 'AudioBuffer': channelNumber must equal or greater than 0`, 'IndexSizeError');
+      }
+
+      channelNumber = conversions['unsigned long'](channelNumber, {
+        context: `Failed to execute 'copyToChannel' on 'AudioBuffer': channelNumber`,
+      });
+
+      bufferOffset = conversions['unsigned long'](bufferOffset, {
+        context: `Failed to execute 'copyToChannel' on 'AudioBuffer': bufferOffset`,
+      });
+
+      try {
+        this[kNapiObj].copyToChannel(source, channelNumber, bufferOffset);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    getChannelData(channel) {
+      if (!(this instanceof AudioBuffer)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'AudioBuffer'");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'getChannelData' on 'AudioBuffer': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      // Rust implementation uses a usize which will clamp -1 to 0, and spec requires
+      // an IndexSizeError rather than a TypeError, so this check must be done here.
+      // cf. note on AnalyzerNode::fftSize
+      if (channel < 0) {
+        throw new DOMException(`Failed to execute 'getChannelData' on 'AudioBuffer': channel must equal or greater than 0`, 'IndexSizeError');
+      }
+
+      channel = conversions['unsigned long'](channel, {
+        context: `Failed to execute 'getChannelData' on 'AudioBuffer': channel`,
+      });
+
+      try {
+        return this[kNapiObj].getChannelData(channel);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+  }
+
+  Object.defineProperties(AudioBuffer, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
+
+  Object.defineProperties(AudioBuffer.prototype,  {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'AudioBuffer',
+    },
+
+    sampleRate: kEnumerableProperty,
+    duration: kEnumerableProperty,
+    length: kEnumerableProperty,
+    numberOfChannels: kEnumerableProperty,
+    copyFromChannel: kEnumerableProperty,
+    copyToChannel: kEnumerableProperty,
+    getChannelData: kEnumerableProperty,
+  });
+
+  return AudioBuffer;
+};
+
+

package/js/AudioBufferSourceNode.js

@@ -17,93 +17,317 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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');
+/* 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');
+const {
+  bridgeEventTarget,
+} = require('./lib/events.js');
+/* eslint-enable no-unused-vars */
 
-module.exports = (NativeAudioBufferSourceNode) => {
-
-  const EventTarget = EventTargetMixin(NativeAudioBufferSourceNode, ['ended']);
-  const AudioNode = AudioNodeMixin(EventTarget);
-  const AudioScheduledSourceNode = AudioScheduledSourceNodeMixin(AudioNode);
+const AudioScheduledSourceNode = require('./AudioScheduledSourceNode.js');
 
+module.exports = (jsExport, nativeBinding) => {
   class AudioBufferSourceNode extends AudioScheduledSourceNode {
+
+    #playbackRate = null;
+    #detune = null;
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'AudioBufferSourceNode': argument 2 is not of type 'AudioBufferSourceOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'AudioBufferSourceNode': 1 argument required, but only ${arguments.length} present`);
       }
 
-      super(context, options);
-      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
-      // bound to this, then we can safely finalize event target initialization
-      super.__initEventTarget__();
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'AudioBufferSourceNode': argument 1 is not of type BaseAudioContext`);
+      }
 
-      this.playbackRate = new AudioParam(this.playbackRate);
-      this.detune = new AudioParam(this.detune);
-    }
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
 
-    // getters
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'AudioBufferSourceNode\': argument 2 is not of type \'AudioBufferSourceOptions\'');
+      }
 
-    get buffer() {
-      return super.buffer;
-    }
+      if (options && options.buffer !== undefined) {
+        if (options.buffer !== null) {
+          if (!(options.buffer instanceof jsExport.AudioBuffer)) {
+            throw new TypeError('Failed to construct \'AudioBufferSourceNode\': Failed to read the \'buffer\' property from AudioBufferSourceOptions: The provided value cannot be converted to \'AudioBuffer\'');
+          }
 
-    get loop() {
-      return super.loop;
+          // unwrap napi audio buffer
+          parsedOptions.buffer = options.buffer[kNapiObj];
+        } else {
+          parsedOptions.buffer = null;
+        }
+      } else {
+        parsedOptions.buffer = null;
+      }
+
+      if (options && options.detune !== undefined) {
+        parsedOptions.detune = conversions['float'](options.detune, {
+          context: `Failed to construct 'AudioBufferSourceNode': Failed to read the 'detune' property from AudioBufferSourceOptions: The provided value (${options.detune}})`,
+        });
+      } else {
+        parsedOptions.detune = 0;
+      }
+
+      if (options && options.loop !== undefined) {
+        parsedOptions.loop = conversions['boolean'](options.loop, {
+          context: `Failed to construct 'AudioBufferSourceNode': Failed to read the 'loop' property from AudioBufferSourceOptions: The provided value (${options.loop}})`,
+        });
+      } else {
+        parsedOptions.loop = false;
+      }
+
+      if (options && options.loopEnd !== undefined) {
+        parsedOptions.loopEnd = conversions['double'](options.loopEnd, {
+          context: `Failed to construct 'AudioBufferSourceNode': Failed to read the 'loopEnd' property from AudioBufferSourceOptions: The provided value (${options.loopEnd}})`,
+        });
+      } else {
+        parsedOptions.loopEnd = 0;
+      }
+
+      if (options && options.loopStart !== undefined) {
+        parsedOptions.loopStart = conversions['double'](options.loopStart, {
+          context: `Failed to construct 'AudioBufferSourceNode': Failed to read the 'loopStart' property from AudioBufferSourceOptions: The provided value (${options.loopStart}})`,
+        });
+      } else {
+        parsedOptions.loopStart = 0;
+      }
+
+      if (options && options.playbackRate !== undefined) {
+        parsedOptions.playbackRate = conversions['float'](options.playbackRate, {
+          context: `Failed to construct 'AudioBufferSourceNode': Failed to read the 'playbackRate' property from AudioBufferSourceOptions: The provided value (${options.playbackRate}})`,
+        });
+      } else {
+        parsedOptions.playbackRate = 1;
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.AudioBufferSourceNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      // keep the wrapped AudioBuffer around
+      Object.defineProperty(this, kAudioBuffer, {
+        __proto__: null,
+        enumerable: false,
+        writable: true,
+        value: null,
+      });
+
+      if (options && options.buffer !== undefined) {
+        this[kAudioBuffer] = options.buffer;
+      }
+
+      // Bridge Rust native event to Node EventTarget
+      bridgeEventTarget(this);
+
+      this.#playbackRate = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].playbackRate,
+      });
+      this.#detune = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].detune,
+      });
     }
 
-    get loopStart() {
-      return super.loopStart;
+    get playbackRate() {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      return this.#playbackRate;
     }
 
-    get loopEnd() {
-      return super.loopEnd;
+    get detune() {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      return this.#detune;
     }
 
-    // setters
+    get buffer() {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      return this[kAudioBuffer];
+    }
 
     set buffer(value) {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      if (value === null) {
+        console.warn('Setting the \'buffer\' property on \'AudioBufferSourceNode\' to \'null\' is not supported yet');
+        return;
+      } else if (!(kNapiObj in value)) {
+        throw new TypeError('Failed to set the \'buffer\' property on \'AudioBufferSourceNode\': Failed to convert value to \'AudioBuffer\'');
+      }
+
       try {
-        super.buffer = value;
+        this[kNapiObj].buffer = value[kNapiObj];
       } catch (err) {
         throwSanitizedError(err);
       }
+
+      this[kAudioBuffer] = value;
+    }
+
+    get loop() {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      return this[kNapiObj].loop;
     }
 
     set loop(value) {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      value = conversions['boolean'](value, {
+        context: `Failed to set the 'loop' property on 'AudioBufferSourceNode': Value`,
+      });
+
       try {
-        super.loop = value;
+        this[kNapiObj].loop = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
+    get loopStart() {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      return this[kNapiObj].loopStart;
+    }
+
     set loopStart(value) {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      value = conversions['double'](value, {
+        context: `Failed to set the 'loopStart' property on 'AudioBufferSourceNode': Value`,
+      });
+
       try {
-        super.loopStart = value;
+        this[kNapiObj].loopStart = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
+    get loopEnd() {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      return this[kNapiObj].loopEnd;
+    }
+
     set loopEnd(value) {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      value = conversions['double'](value, {
+        context: `Failed to set the 'loopEnd' property on 'AudioBufferSourceNode': Value`,
+      });
+
+      try {
+        this[kNapiObj].loopEnd = value;
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    start(when = 0, offset = null, duration = null) {
+      if (!(this instanceof AudioBufferSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioBufferSourceNode\'');
+      }
+
+      if (when !== 0) {
+        when = conversions['double'](when, {
+          context: `Failed to execute 'start' on 'AudioBufferSourceNode': Parameter 1`,
+        });
+      }
+
+      if (offset !== null) {
+        offset = conversions['double'](offset, {
+          context: `Failed to execute 'start' on 'AudioBufferSourceNode': Parameter 2`,
+        });
+      }
+
+      if (duration !== null) {
+        duration = conversions['double'](duration, {
+          context: `Failed to execute 'start' on 'AudioBufferSourceNode': Parameter 3`,
+        });
+      }
+
       try {
-        super.loopEnd = value;
+        return this[kNapiObj].start(when, offset, duration);
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    // methods
-    
   }
 
-  return AudioBufferSourceNode;
-};
+  Object.defineProperties(AudioBufferSourceNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
 
+  Object.defineProperties(AudioBufferSourceNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'AudioBufferSourceNode',
+    },
+    playbackRate: kEnumerableProperty,
+    detune: kEnumerableProperty,
+    buffer: kEnumerableProperty,
+    loop: kEnumerableProperty,
+    loopStart: kEnumerableProperty,
+    loopEnd: kEnumerableProperty,
+    start: kEnumerableProperty,
+  });
 
-  
+  return AudioBufferSourceNode;
+};