react-native-audio-api 0.4.8 → 0.4.10-rc.1

package/android/src/main/cpp/libs/pffft.h

@@ -0,0 +1,198 @@
+/* Copyright (c) 2013  Julien Pommier ( pommier@modartt.com )
+
+   Based on original fortran 77 code from FFTPACKv4 from NETLIB,
+   authored by Dr Paul Swarztrauber of NCAR, in 1985.
+
+   As confirmed by the NCAR fftpack software curators, the following
+   FFTPACKv5 license applies to FFTPACKv4 sources. My changes are
+   released under the same terms.
+
+   FFTPACK license:
+
+   http://www.cisl.ucar.edu/css/software/fftpack5/ftpk.html
+
+   Copyright (c) 2004 the University Corporation for Atmospheric
+   Research ("UCAR"). All rights reserved. Developed by NCAR's
+   Computational and Information Systems Laboratory, UCAR,
+   www.cisl.ucar.edu.
+
+   Redistribution and use of the Software in source and binary forms,
+   with or without modification, is permitted provided that the
+   following conditions are met:
+
+   - Neither the names of NCAR's Computational and Information Systems
+   Laboratory, the University Corporation for Atmospheric Research,
+   nor the names of its sponsors or contributors may be used to
+   endorse or promote products derived from this Software without
+   specific prior written permission.
+
+   - Redistributions of source code must retain the above copyright
+   notices, this list of conditions, and the disclaimer below.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions, and the disclaimer below in the
+   documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+   SOFTWARE.
+*/
+
+/*
+  PFFFT : a Pretty Fast FFT.
+
+  This is basically an adaptation of the single precision fftpack
+  (v4) as found on netlib taking advantage of SIMD instruction found
+  on cpus such as intel x86 (SSE1), powerpc (Altivec), and arm (NEON).
+
+  For architectures where no SIMD instruction is available, the code
+  falls back to a scalar version.
+
+  Restrictions:
+
+  - 1D transforms only, with 32-bit single precision.
+
+  - supports only transforms for inputs of length N of the form
+  N=(2^a)*(3^b)*(5^c), a >= 5, b >=0, c >= 0 (32, 48, 64, 96, 128,
+  144, 160, etc are all acceptable lengths). Performance is best for
+  128<=N<=8192.
+
+  - all (float*) pointers in the functions below are expected to
+  have an "simd-compatible" alignment, that is 16 bytes on x86 and
+  powerpc CPUs.
+
+  You can allocate such buffers with the functions
+  pffft_aligned_malloc / pffft_aligned_free (or with stuff like
+  posix_memalign..)
+
+*/
+
+#pragma once
+
+#include <stddef.h> // for size_t
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   Opaque struct holding internal stuff (precomputed twiddle factors)
+   this struct can be shared by many threads as it contains only
+   read-only data.
+*/
+typedef struct PFFFT_Setup PFFFT_Setup;
+
+/** Direction of the transform */
+typedef enum { PFFFT_FORWARD, PFFFT_BACKWARD } pffft_direction_t;
+
+/** Type of transform */
+typedef enum { PFFFT_REAL, PFFFT_COMPLEX } pffft_transform_t;
+
+/**
+  Prepare for performing transforms of size N -- the returned
+  PFFFT_Setup structure is read-only so it can safely be shared by
+  multiple concurrent threads.
+
+  Will return NULL if N is not suitable (too large / no decomposable with simple
+  integer factors..)
+*/
+PFFFT_Setup *pffft_new_setup(int N, pffft_transform_t transform);
+void pffft_destroy_setup(PFFFT_Setup *);
+/**
+  Perform a Fourier transform , The z-domain data is stored in the
+  most efficient order for transforming it back, or using it for
+  convolution. If you need to have its content sorted in the
+  "usual" way, that is as an array of interleaved complex numbers,
+  either use pffft_transform_ordered , or call pffft_zreorder after
+  the forward fft, and before the backward fft.
+
+  Transforms are not scaled: PFFFT_BACKWARD(PFFFT_FORWARD(x)) = N*x.
+  Typically you will want to scale the backward transform by 1/N.
+
+  The 'work' pointer should point to an area of N (2*N for complex
+  fft) floats, properly aligned. If 'work' is NULL, then stack will
+  be used instead (this is probably the best strategy for small
+  FFTs, say for N < 16384).
+
+  input and output may alias.
+*/
+void pffft_transform(
+    PFFFT_Setup *setup,
+    const float *input,
+    float *output,
+    float *work,
+    pffft_direction_t direction);
+
+/**
+  Similar to pffft_transform, but makes sure that the output is
+  ordered as expected (interleaved complex numbers).  This is
+  similar to calling pffft_transform and then pffft_zreorder.
+
+  input and output may alias.
+*/
+void pffft_transform_ordered(
+    PFFFT_Setup *setup,
+    const float *input,
+    float *output,
+    float *work,
+    pffft_direction_t direction);
+
+/**
+  call pffft_zreorder(.., PFFFT_FORWARD) after pffft_transform(...,
+  PFFFT_FORWARD) if you want to have the frequency components in
+  the correct "canonical" order, as interleaved complex numbers.
+
+  (for real transforms, both 0-frequency and half frequency
+  components, which are real, are assembled in the first entry as
+  F(0)+i*F(n/2+1). Note that the original fftpack did place
+  F(n/2+1) at the end of the arrays).
+
+  input and output should not alias.
+*/
+void pffft_zreorder(
+    PFFFT_Setup *setup,
+    const float *input,
+    float *output,
+    pffft_direction_t direction);
+
+/**
+  Perform a multiplication of the frequency components of dft_a and
+  dft_b and accumulate them into dft_ab. The arrays should have
+  been obtained with pffft_transform(.., PFFFT_FORWARD) and should
+  *not* have been reordered with pffft_zreorder (otherwise just
+  perform the operation yourself as the dft coefs are stored as
+  interleaved complex numbers).
+
+  the operation performed is: dft_ab += (dft_a * fdt_b)*scaling
+
+  The dft_a, dft_b and dft_ab pointers may alias.
+*/
+void pffft_zconvolve_accumulate(
+    PFFFT_Setup *setup,
+    const float *dft_a,
+    const float *dft_b,
+    float *dft_ab,
+    float scaling);
+
+/**
+  the float buffers must have the correct alignment (16-byte boundary
+  on intel and powerpc). This function may be used to obtain such
+  correctly aligned buffers.
+*/
+void *pffft_aligned_malloc(size_t nb_bytes);
+void pffft_aligned_free(void *);
+
+/** return 4 or 1 wether support SSE/Altivec instructions was enable when
+ * building pffft.c */
+int pffft_simd_size(void);
+
+#ifdef __cplusplus
+}
+#endif

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -2,6 +2,7 @@
 
 #include <jsi/jsi.h>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "AudioContext.h"
@@ -20,9 +21,18 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
   }
 
   JSI_HOST_FUNCTION(close) {
-    auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-    audioContext->close();
-    return jsi::Value::undefined();
+    auto promise = promiseVendor_->createPromise([this](std::shared_ptr<Promise> promise) {
+      std::thread([this, promise = std::move(promise)]() {
+          auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+          audioContext->close();
+
+          promise->resolve([](jsi::Runtime &runtime) {
+              return jsi::Value::undefined();
+          });
+      }).detach();
+    });
+
+    return promise;
   }
 };
 } // namespace audioapi

package/common/cpp/core/AnalyserNode.cpp

@@ -24,6 +24,8 @@ AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
       RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  realData_ = std::make_shared<AudioArray>(fftSize_);
+  imaginaryData_ = std::make_shared<AudioArray>(fftSize_);
 
   isInitialized_ = true;
 }
@@ -59,6 +61,8 @@ void AnalyserNode::setFftSize(int fftSize) {
 
   fftSize_ = fftSize;
   fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  realData_ = std::make_shared<AudioArray>(fftSize_);
+  imaginaryData_ = std::make_shared<AudioArray>(fftSize_);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
 }
 
@@ -211,11 +215,12 @@ void AnalyserNode::doFFTAnalysis() {
       break;
   }
 
-  // do fft analysis - get frequency domain data
-  fftFrame_->doFFT(tempBuffer.getData());
+  auto *realFFTFrameData = realData_->getData();
+  auto *imaginaryFFTFrameData = imaginaryData_->getData();
 
-  auto *realFFTFrameData = fftFrame_->getRealData();
-  auto *imaginaryFFTFrameData = fftFrame_->getImaginaryData();
+  // do fft analysis - get frequency domain data
+  fftFrame_->doFFT(
+      tempBuffer.getData(), realFFTFrameData, imaginaryFFTFrameData);
 
   // Zero out nquist component
   imaginaryFFTFrameData[0] = 0.0f;

package/common/cpp/core/AnalyserNode.h

@@ -50,6 +50,8 @@ class AnalyserNode : public AudioNode {
   int vWriteIndex_;
 
   std::unique_ptr<FFTFrame> fftFrame_;
+  std::shared_ptr<AudioArray> realData_;
+  std::shared_ptr<AudioArray> imaginaryData_;
   std::unique_ptr<AudioArray> magnitudeBuffer_;
   bool shouldDoFFTAnalysis_ { true };
 

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -8,6 +8,7 @@
 #include "AudioUtils.h"
 #include "BaseAudioContext.h"
 #include "Constants.h"
+#include "Locker.h"
 
 namespace audioapi {
 
@@ -67,6 +68,8 @@ void AudioBufferSourceNode::setLoopEnd(double loopEnd) {
 
 void AudioBufferSourceNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer) {
+  Locker locker(getBufferLock());
+
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
     alignedBus_ = std::make_shared<AudioBus>(
@@ -109,6 +112,10 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
   vReadIndex_ = static_cast<double>(buffer_->getSampleRate() * offset);
 }
 
+std::mutex &AudioBufferSourceNode::getBufferLock() {
+  return bufferLock_;
+}
+
 void AudioBufferSourceNode::processNode(
     AudioBus *processingBus,
     int framesToProcess) {
@@ -118,6 +125,11 @@ void AudioBufferSourceNode::processNode(
     return;
   }
 
+  if (!Locker::tryLock(getBufferLock())) {
+    processingBus->zero();
+    return;
+  }
+
   size_t startOffset = 0;
   size_t offsetLength = 0;
 

package/common/cpp/core/AudioBufferSourceNode.h

@@ -30,6 +30,7 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
   void start(double when, double offset, double duration = -1);
 
  protected:
+  std::mutex &getBufferLock();
   void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
@@ -37,6 +38,7 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
   bool loop_;
   double loopStart_;
   double loopEnd_;
+  std::mutex bufferLock_;
 
   // playback rate aka pitch change params
   std::shared_ptr<AudioParam> detuneParam_;

package/common/cpp/core/PeriodicWave.cpp

@@ -199,8 +199,8 @@ void PeriodicWave::createBandLimitedTables(
   for (int rangeIndex = 0; rangeIndex < numberOfRanges_; rangeIndex++) {
     FFTFrame fftFrame(fftSize);
 
-    auto *realFFTFrameData = fftFrame.getRealData();
-    auto *imaginaryFFTFrameData = fftFrame.getImaginaryData();
+    auto *realFFTFrameData = new float[fftSize];
+    auto *imaginaryFFTFrameData = new float[fftSize];
 
     // copy real and imaginary data to the FFT frame and scale it
     VectorMath::multiplyByScalar(
@@ -235,7 +235,10 @@ void PeriodicWave::createBandLimitedTables(
 
     // Perform the inverse FFT to get the time domain representation of the
     // band-limited waveform.
-    fftFrame.doInverseFFT(bandLimitedTables_[rangeIndex]);
+    fftFrame.doInverseFFT(
+        bandLimitedTables_[rangeIndex],
+        realFFTFrameData,
+        imaginaryFFTFrameData);
 
     if (!disableNormalization_ && rangeIndex == 0) {
       float maxValue =
@@ -245,6 +248,9 @@ void PeriodicWave::createBandLimitedTables(
       }
     }
 
+    delete[] realFFTFrameData;
+    delete[] imaginaryFFTFrameData;
+
     VectorMath::multiplyByScalar(
         bandLimitedTables_[rangeIndex],
         normalizationFactor,

package/common/cpp/utils/FFTFrame.cpp

@@ -5,7 +5,8 @@
 #endif
 
 #if defined(ANDROID)
-#include <fftw3.h>
+#include <pffft.h>
+#include <complex>
 #endif
 
 namespace audioapi {
@@ -13,19 +14,11 @@ namespace audioapi {
 static std::unordered_map<size_t, FFTSetup> fftSetups_;
 
 FFTFrame::FFTFrame(int size)
-    : size_(size),
-      log2Size_(static_cast<int>(log2(size))),
-      realData_(new float[size]),
-      imaginaryData_(new float[size]) {
+    : size_(size), log2Size_(static_cast<int>(log2(size))) {
   fftSetup_ = getFFTSetupForSize(log2Size_);
-  frame_.realp = realData_;
-  frame_.imagp = imaginaryData_;
 }
 
-FFTFrame::~FFTFrame() {
-  delete[] realData_;
-  delete[] imaginaryData_;
-}
+FFTFrame::~FFTFrame() {}
 
 FFTSetup FFTFrame::getFFTSetupForSize(size_t log2FFTSize) {
   if (!fftSetups_.contains(log2FFTSize)) {
@@ -36,15 +29,22 @@ FFTSetup FFTFrame::getFFTSetupForSize(size_t log2FFTSize) {
   return fftSetups_.at(log2FFTSize);
 }
 
-void FFTFrame::doFFT(float *data) {
+void FFTFrame::doFFT(float *data, float *realData, float *imaginaryData) {
+  frame_.realp = realData;
+  frame_.imagp = imaginaryData;
   vDSP_ctoz(reinterpret_cast<DSPComplex *>(data), 2, &frame_, 1, size_ / 2);
   vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_FORWARD);
 
-  VectorMath::multiplyByScalar(realData_, 0.5f, realData_, size_ / 2);
-  VectorMath::multiplyByScalar(imaginaryData_, 0.5f, imaginaryData_, size_ / 2);
+  VectorMath::multiplyByScalar(realData, 0.5f, realData, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData, 0.5f, imaginaryData, size_ / 2);
 }
 
-void FFTFrame::doInverseFFT(float *data) {
+void FFTFrame::doInverseFFT(
+    float *data,
+    float *realData,
+    float *imaginaryData) {
+  frame_.realp = realData;
+  frame_.imagp = imaginaryData;
   vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_INVERSE);
   vDSP_ztoc(&frame_, 1, reinterpret_cast<DSPComplex *>(data), 2, size_ / 2);
 
@@ -57,42 +57,49 @@ void FFTFrame::doInverseFFT(float *data) {
 #elif defined(ANDROID)
 
 FFTFrame::FFTFrame(int size)
-    : size_(size),
-      log2Size_(static_cast<int>(log2(size))),
-      realData_(new float[size]),
-      imaginaryData_(new float[size]) {
-  frame_ = fftwf_alloc_complex(size / 2);
+    : size_(size), log2Size_(static_cast<int>(log2(size))) {
+  pffftSetup_ = pffft_new_setup(size_, PFFFT_REAL);
+  work_ = (float *)pffft_aligned_malloc(size_ * sizeof(float));
 }
 
 FFTFrame::~FFTFrame() {
-  delete[] realData_;
-  delete[] imaginaryData_;
-  fftwf_free(frame_);
+  pffft_destroy_setup(pffftSetup_);
+  pffft_aligned_free(work_);
 }
 
-void FFTFrame::doFFT(float *data) {
-  auto plan = fftwf_plan_dft_r2c_1d(size_, data, frame_, FFTW_ESTIMATE);
-  fftwf_execute(plan);
-  fftwf_destroy_plan(plan);
+void FFTFrame::doFFT(float *data, float *realData, float *imaginaryData) {
+  std::vector<std::complex<float>> out(size_);
+  pffft_transform_ordered(
+      pffftSetup_,
+      data,
+      reinterpret_cast<float *>(&out[0]),
+      work_,
+      PFFFT_FORWARD);
 
   for (int i = 0; i < size_ / 2; ++i) {
-    realData_[i] = frame_[i][0];
-    imaginaryData_[i] = frame_[i][1];
+    realData[i] = out[i].real();
+    imaginaryData[i] = out[i].imag();
   }
 
-  VectorMath::multiplyByScalar(realData_, 0.5f, realData_, size_ / 2);
-  VectorMath::multiplyByScalar(imaginaryData_, 0.5f, imaginaryData_, size_ / 2);
+  VectorMath::multiplyByScalar(realData, 0.5f, realData, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData, 0.5f, imaginaryData, size_ / 2);
 }
 
-void FFTFrame::doInverseFFT(float *data) {
+void FFTFrame::doInverseFFT(
+    float *data,
+    float *realData,
+    float *imaginaryData) {
+  std::vector<std::complex<float>> out(size_ / 2);
   for (int i = 0; i < size_ / 2; i++) {
-    frame_[i][0] = realData_[i];
-    frame_[i][1] = imaginaryData_[i];
+    out[i] = {realData[i], imaginaryData[i]};
   }
 
-  auto plan = fftwf_plan_dft_c2r_1d(size_, frame_, data, FFTW_ESTIMATE);
-  fftwf_execute(plan);
-  fftwf_destroy_plan(plan);
+  pffft_transform_ordered(
+      pffftSetup_,
+      reinterpret_cast<float *>(&out[0]),
+      data,
+      work_,
+      PFFFT_BACKWARD);
 
   VectorMath::multiplyByScalar(
       data, 1.0f / static_cast<float>(size_), data, size_);

package/common/cpp/utils/FFTFrame.h

@@ -40,7 +40,7 @@
 #endif
 
 #if defined(ANDROID)
-#include <fftw3.h>
+#include <pffft.h>
 #endif
 
 namespace audioapi {
@@ -50,22 +50,12 @@ class FFTFrame {
   explicit FFTFrame(int size);
   ~FFTFrame();
 
-  [[nodiscard]] float *getRealData() const {
-    return realData_;
-  }
-  [[nodiscard]] float *getImaginaryData() const {
-    return imaginaryData_;
-  }
-
-  void doFFT(float *data);
-
-  void doInverseFFT(float *data);
+  void doFFT(float *data, float *realData, float *imaginaryData);
+  void doInverseFFT(float *data, float *realData, float *imaginaryData);
 
  private:
   int size_;
   int log2Size_;
-  float *realData_;
-  float *imaginaryData_;
 
 #if defined(HAVE_ACCELERATE)
     FFTSetup fftSetup_;
@@ -75,7 +65,8 @@ class FFTFrame {
 #endif
 
 #if defined(ANDROID)
-    fftwf_complex *frame_;
+    PFFFT_Setup *pffftSetup_;
+    float *work_;
 #endif
 };
 

package/lib/module/core/AudioContext.js

@@ -1,12 +1,16 @@
 "use strict";
 
 import BaseAudioContext from "./BaseAudioContext.js";
+import { NotSupportedError } from "../errors/index.js";
 export default class AudioContext extends BaseAudioContext {
-  constructor(sampleRate) {
-    super(global.__AudioAPIInstaller.createAudioContext(sampleRate));
+  constructor(options) {
+    if (options && (options.sampleRate < 8000 || options.sampleRate > 96000)) {
+      throw new NotSupportedError(`The provided sampleRate is not supported: ${options.sampleRate}`);
+    }
+    super(global.__AudioAPIInstaller.createAudioContext(options?.sampleRate));
   }
-  close() {
-    this.context.close();
+  async close() {
+    await this.context.close();
   }
 }
 //# sourceMappingURL=AudioContext.js.map

package/lib/module/core/AudioContext.js.map

@@ -1 +1 @@
-{"version":3,"names":["BaseAudioContext","AudioContext","constructor","sampleRate","global","__AudioAPIInstaller","createAudioContext","close","context"],"sourceRoot":"../../../src","sources":["core/AudioContext.ts"],"mappings":";;AACA,OAAOA,gBAAgB,MAAM,uBAAoB;AAEjD,eAAe,MAAMC,YAAY,SAASD,gBAAgB,CAAC;EACzDE,WAAWA,CAACC,UAAmB,EAAE;IAC/B,KAAK,CAACC,MAAM,CAACC,mBAAmB,CAACC,kBAAkB,CAACH,UAAU,CAAC,CAAC;EAClE;EAEAI,KAAKA,CAAA,EAAS;IACX,IAAI,CAACC,OAAO,CAAmBD,KAAK,CAAC,CAAC;EACzC;AACF","ignoreList":[]}
+{"version":3,"names":["BaseAudioContext","NotSupportedError","AudioContext","constructor","options","sampleRate","global","__AudioAPIInstaller","createAudioContext","close","context"],"sourceRoot":"../../../src","sources":["core/AudioContext.ts"],"mappings":";;AACA,OAAOA,gBAAgB,MAAM,uBAAoB;AAEjD,SAASC,iBAAiB,QAAQ,oBAAW;AAE7C,eAAe,MAAMC,YAAY,SAASF,gBAAgB,CAAC;EACzDG,WAAWA,CAACC,OAA6B,EAAE;IACzC,IAAIA,OAAO,KAAKA,OAAO,CAACC,UAAU,GAAG,IAAI,IAAID,OAAO,CAACC,UAAU,GAAG,KAAK,CAAC,EAAE;MACxE,MAAM,IAAIJ,iBAAiB,CACzB,6CAA6CG,OAAO,CAACC,UAAU,EACjE,CAAC;IACH;IAEA,KAAK,CAACC,MAAM,CAACC,mBAAmB,CAACC,kBAAkB,CAACJ,OAAO,EAAEC,UAAU,CAAC,CAAC;EAC3E;EAEA,MAAMI,KAAKA,CAAA,EAAuB;IAChC,MAAO,IAAI,CAACC,OAAO,CAAmBD,KAAK,CAAC,CAAC;EAC/C;AACF","ignoreList":[]}

package/lib/module/core/AudioNode.js

@@ -16,6 +16,7 @@ export default class AudioNode {
       throw new InvalidAccessError('The AudioNodes are from different BaseAudioContexts');
     }
     this.node.connect(destination.node);
+    return destination;
   }
   disconnect(destination) {
     this.node.disconnect(destination?.node);

package/lib/module/core/AudioNode.js.map

@@ -1 +1 @@
-{"version":3,"names":["InvalidAccessError","AudioNode","constructor","context","node","numberOfInputs","numberOfOutputs","channelCount","channelCountMode","channelInterpretation","connect","destination","disconnect"],"sourceRoot":"../../../src","sources":["core/AudioNode.ts"],"mappings":";;AAGA,SAASA,kBAAkB,QAAQ,oBAAW;AAE9C,eAAe,MAAMC,SAAS,CAAC;EAS7BC,WAAWA,CAACC,OAAyB,EAAEC,IAAgB,EAAE;IACvD,IAAI,CAACD,OAAO,GAAGA,OAAO;IACtB,IAAI,CAACC,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACC,cAAc,GAAG,IAAI,CAACD,IAAI,CAACC,cAAc;IAC9C,IAAI,CAACC,eAAe,GAAG,IAAI,CAACF,IAAI,CAACE,eAAe;IAChD,IAAI,CAACC,YAAY,GAAG,IAAI,CAACH,IAAI,CAACG,YAAY;IAC1C,IAAI,CAACC,gBAAgB,GAAG,IAAI,CAACJ,IAAI,CAACI,gBAAgB;IAClD,IAAI,CAACC,qBAAqB,GAAG,IAAI,CAACL,IAAI,CAACK,qBAAqB;EAC9D;EAEOC,OAAOA,CAACC,WAAsB,EAAQ;IAC3C,IAAI,IAAI,CAACR,OAAO,KAAKQ,WAAW,CAACR,OAAO,EAAE;MACxC,MAAM,IAAIH,kBAAkB,CAC1B,qDACF,CAAC;IACH;IAEA,IAAI,CAACI,IAAI,CAACM,OAAO,CAACC,WAAW,CAACP,IAAI,CAAC;EACrC;EAEOQ,UAAUA,CAACD,WAAuB,EAAQ;IAC/C,IAAI,CAACP,IAAI,CAACQ,UAAU,CAACD,WAAW,EAAEP,IAAI,CAAC;EACzC;AACF","ignoreList":[]}
+{"version":3,"names":["InvalidAccessError","AudioNode","constructor","context","node","numberOfInputs","numberOfOutputs","channelCount","channelCountMode","channelInterpretation","connect","destination","disconnect"],"sourceRoot":"../../../src","sources":["core/AudioNode.ts"],"mappings":";;AAGA,SAASA,kBAAkB,QAAQ,oBAAW;AAE9C,eAAe,MAAMC,SAAS,CAAC;EAS7BC,WAAWA,CAACC,OAAyB,EAAEC,IAAgB,EAAE;IACvD,IAAI,CAACD,OAAO,GAAGA,OAAO;IACtB,IAAI,CAACC,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACC,cAAc,GAAG,IAAI,CAACD,IAAI,CAACC,cAAc;IAC9C,IAAI,CAACC,eAAe,GAAG,IAAI,CAACF,IAAI,CAACE,eAAe;IAChD,IAAI,CAACC,YAAY,GAAG,IAAI,CAACH,IAAI,CAACG,YAAY;IAC1C,IAAI,CAACC,gBAAgB,GAAG,IAAI,CAACJ,IAAI,CAACI,gBAAgB;IAClD,IAAI,CAACC,qBAAqB,GAAG,IAAI,CAACL,IAAI,CAACK,qBAAqB;EAC9D;EAEOC,OAAOA,CAACC,WAAsB,EAAa;IAChD,IAAI,IAAI,CAACR,OAAO,KAAKQ,WAAW,CAACR,OAAO,EAAE;MACxC,MAAM,IAAIH,kBAAkB,CAC1B,qDACF,CAAC;IACH;IAEA,IAAI,CAACI,IAAI,CAACM,OAAO,CAACC,WAAW,CAACP,IAAI,CAAC;IAEnC,OAAOO,WAAW;EACpB;EAEOC,UAAUA,CAACD,WAAuB,EAAQ;IAC/C,IAAI,CAACP,IAAI,CAACQ,UAAU,CAACD,WAAW,EAAEP,IAAI,CAAC;EACzC;AACF","ignoreList":[]}

package/lib/module/core/AudioParam.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { RangeError } from "../errors/index.js";
+import { RangeError, InvalidStateError } from "../errors/index.js";
 export default class AudioParam {
   constructor(audioParam) {
     this.audioParam = audioParam;
@@ -17,45 +17,61 @@ export default class AudioParam {
   }
   setValueAtTime(value, startTime) {
     if (startTime < 0) {
-      throw new RangeError(`Time must be a finite non-negative number: ${startTime}`);
+      throw new RangeError(`startTime must be a finite non-negative number: ${startTime}`);
     }
     this.audioParam.setValueAtTime(value, startTime);
+    return this;
   }
   linearRampToValueAtTime(value, endTime) {
     if (endTime < 0) {
-      throw new RangeError(`Time must be a finite non-negative number: ${endTime}`);
+      throw new RangeError(`endTime must be a finite non-negative number: ${endTime}`);
     }
     this.audioParam.linearRampToValueAtTime(value, endTime);
+    return this;
   }
   exponentialRampToValueAtTime(value, endTime) {
     if (endTime < 0) {
-      throw new RangeError(`Time must be a finite non-negative number: ${endTime}`);
+      throw new RangeError(`endTime must be a finite non-negative number: ${endTime}`);
     }
     this.audioParam.exponentialRampToValueAtTime(value, endTime);
+    return this;
   }
   setTargetAtTime(target, startTime, timeConstant) {
     if (startTime < 0) {
-      throw new RangeError(`Time must be a finite non-negative number: ${startTime}`);
+      throw new RangeError(`startTime must be a finite non-negative number: ${startTime}`);
+    }
+    if (timeConstant < 0) {
+      throw new RangeError(`timeConstant must be a finite non-negative number: ${startTime}`);
     }
     this.audioParam.setTargetAtTime(target, startTime, timeConstant);
+    return this;
   }
   setValueCurveAtTime(values, startTime, duration) {
     if (startTime < 0) {
-      throw new RangeError(`Time must be a finite non-negative number: ${startTime}`);
+      throw new RangeError(`startTime must be a finite non-negative number: ${startTime}`);
+    }
+    if (duration < 0) {
+      throw new RangeError(`duration must be a finite non-negative number: ${startTime}`);
+    }
+    if (values.length < 2) {
+      throw new InvalidStateError(`values must contain at least two values`);
     }
     this.audioParam.setValueCurveAtTime(values, startTime, duration);
+    return this;
   }
   cancelScheduledValues(cancelTime) {
     if (cancelTime < 0) {
-      throw new RangeError(`Time must be a finite non-negative number: ${cancelTime}`);
+      throw new RangeError(`cancelTime must be a finite non-negative number: ${cancelTime}`);
     }
     this.audioParam.cancelScheduledValues(cancelTime);
+    return this;
   }
   cancelAndHoldAtTime(cancelTime) {
     if (cancelTime < 0) {
-      throw new RangeError(`Time must be a finite non-negative number: ${cancelTime}`);
+      throw new RangeError(`cancelTime must be a finite non-negative number: ${cancelTime}`);
     }
     this.audioParam.cancelAndHoldAtTime(cancelTime);
+    return this;
   }
 }
 //# sourceMappingURL=AudioParam.js.map