react-native-audio-api 0.1.0 → 0.2.0

package/common/cpp/utils/FFTFrame.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+
+#include "VectorMath.h"
+
+namespace audioapi {
+
+class FFTFrame {
+ public:
+  explicit FFTFrame(int size): size_(size), log2Size_(static_cast<int>(log2(size))), realData_(new float[size]), imaginaryData_(new float[size]) {}
+  ~FFTFrame() {
+    delete[] realData_;
+    delete[] imaginaryData_;
+  }
+
+  [[nodiscard]] float *getRealData() const {
+    return realData_;
+  }
+  [[nodiscard]] float *getImaginaryData() const {
+    return imaginaryData_;
+  }
+
+  void inverse(float *data);
+
+ private:
+  int size_;
+  int log2Size_;
+  float *realData_;
+  float *imaginaryData_;
+};
+
+} // namespace audioapi

package/common/cpp/utils/Locker.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <mutex>
+
+namespace audioapi {
+
+// Small easy interface to manage locking
+class Locker {
+ public:
+  Locker(): lockPtr_(0) {}
+  explicit Locker(std::mutex& lockPtr): lockPtr_(&lockPtr) {
+    lock();
+  }
+
+  ~Locker() {
+    unlock();
+  }
+
+  explicit operator bool() const { return !!lockPtr_; }
+
+  void lock() {
+    if (lockPtr_) {
+      lockPtr_->lock();
+    }
+  }
+
+  void unlock() {
+    if (lockPtr_) {
+    lockPtr_->unlock();
+    }
+  }
+
+  static Locker tryLock(std::mutex& lock) {
+    Locker result = Locker();
+
+    if (lock.try_lock()) {
+      result.lockPtr_ = &lock;
+    }
+
+    return result;
+  }
+
+ private:
+  std::mutex* lockPtr_;
+};
+
+} // namespace audioapi

package/common/cpp/utils/VectorMath.cpp

@@ -77,7 +77,7 @@ void add(
       numberOfElementsToProcess);
 }
 
-void substract(
+void subtract(
     const float *inputVector1,
     const float *inputVector2,
     float *outputVector,
@@ -115,6 +115,10 @@ float maximumMagnitude(
   return maximumValue;
 }
 
+void multiplyByScalarThenAddToOutput(const float* inputVector, float scalar, float* outputVector, size_t numberOfElementsToProcess) {
+    vDSP_vsma(inputVector, 1, &scalar, outputVector, 1, outputVector, 1, numberOfElementsToProcess);
+}
+
 #else
 
 #if defined(HAVE_X86_SSE2)
@@ -363,7 +367,7 @@ void add(
   }
 }
 
-void substract(
+void subtract(
     const float *inputVector1,
     const float *inputVector2,
     float *outputVector,
@@ -578,7 +582,7 @@ float maximumMagnitude(
   max = std::max(max, groupMaxP[3]);
 
   n = tailFrames;
-#elif defined(HAVE_ARM_NEON_INTRINSICS)
+#elif defined(c)
   size_t tailFrames = n % 4;
   const float *endP = inputVector + n - tailFrames;
 
@@ -605,5 +609,70 @@ float maximumMagnitude(
   return max;
 }
 
+void multiplyByScalarThenAddToOutput(const float* inputVector, float scalar, float* outputVector, size_t numberOfElementsToProcess) {
+    size_t n = numberOfElementsToProcess;
+
+#if HAVE_X86_SSE2
+    // If the inputVector address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
+    while (!is16ByteAligned(inputVector) && n) {
+        *outputVector += scalar * *inputVector;
+        inputVector++;
+        outputVector++;
+        n--;
+    }
+
+    // Now the inputVector is aligned, use SSE.
+    size_t tailFrames = n % 4;
+    const float* endP = outputVector + n - tailFrames;
+
+    __m128 pSource;
+    __m128 dest;
+    __m128 temp;
+    __m128 mScale = _mm_set_ps1(scalar);
+
+    bool destAligned = is16ByteAligned(outputVector);
+
+#define SSE2_MULT_ADD(loadInstr, storeInstr)       \
+    while (outputVector < endP)                    \
+    {                                              \
+        pSource = _mm_load_ps(inputVector);        \
+        temp = _mm_mul_ps(pSource, mScale);        \
+        dest = _mm_##loadInstr##_ps(outputVector); \
+        dest = _mm_add_ps(dest, temp);             \
+        _mm_##storeInstr##_ps(outputVector, dest); \
+        inputVector += 4;                          \
+        outputVector += 4;                         \
+    }
+
+    if (destAligned)
+        SSE2_MULT_ADD(load, store)
+    else
+        SSE2_MULT_ADD(loadu, storeu)
+
+    n = tailFrames;
+#elif HAVE_ARM_NEON_INTRINSICS
+    size_t tailFrames = n % 4;
+    const float* endP = outputVector + n - tailFrames;
+
+    float32x4_t k = vdupq_n_f32(scalar);
+    while (outputVector < endP) {
+        float32x4_t source = vld1q_f32(inputVector);
+        float32x4_t dest = vld1q_f32(outputVector);
+
+        dest = vmlaq_f32(dest, source, k);
+        vst1q_f32(outputVector, dest);
+
+        inputVector += 4;
+        outputVector += 4;
+    }
+    n = tailFrames;
+#endif
+    while (n--) {
+        *outputVector += *inputVector * scalar;
+        ++inputVector;
+        ++outputVector;
+    }
+}
+
 #endif
 } // namespace audioapi::VectorMath

package/common/cpp/utils/VectorMath.h

@@ -32,6 +32,12 @@
 
 namespace audioapi::VectorMath {
 
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+
 void multiplyByScalar(
     const float *inputVector,
     float scalar,
@@ -47,7 +53,7 @@ void add(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess);
-void substract(
+void subtract(
     const float *inputVector1,
     const float *inputVector2,
     float *outputVector,

package/common/cpp/utils/android/FFTFrame.cpp

@@ -0,0 +1,22 @@
+#if defined(ANDROID)
+#include "FFTFrame.h"
+#include <fftw3.h>
+
+namespace audioapi {
+void FFTFrame::inverse(float *timeDomainData) {
+    fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
+    for(int i = 0; i < size_ / 2; i++) {
+        freqDomainData[i][0] = realData_[i];
+        freqDomainData[i][1] = imaginaryData_[i];
+    }
+
+    auto plan = fftwf_plan_dft_c2r_1d(size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
+    fftwf_execute(plan);
+    fftwf_destroy_plan(plan);
+    fftwf_free(freqDomainData);
+
+    VectorMath::multiplyByScalar(
+            timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+}
+} // namespace audioapi
+#endif

package/common/cpp/utils/ios/FFTFrame.cpp

@@ -0,0 +1,24 @@
+#if defined(HAVE_ACCELERATE)
+#include "FFTFrame.h"
+#include "Accelerate/Accelerate.h"
+
+namespace audioapi {
+
+void FFTFrame::inverse(float *timeDomainData) {
+  FFTSetup fftSetup_ = vDSP_create_fftsetup(log2Size_, FFT_RADIX2);
+  DSPSplitComplex freqDomainData;
+  freqDomainData.realp = realData_;
+  freqDomainData.imagp = imaginaryData_;
+
+  vDSP_fft_zrip(fftSetup_, &freqDomainData, 1, log2Size_, FFT_INVERSE);
+  vDSP_ztoc(&freqDomainData, 1, reinterpret_cast<DSPComplex *>(timeDomainData), 2, size_ / 2);
+
+  // Scale the FFT data, beacuse of
+  // https://developer.apple.com/library/archive/documentation/Performance/Conceptual/vDSP_Programming_Guide/UsingFourierTransforms/UsingFourierTransforms.html#//apple_ref/doc/uid/TP40005147-CH3-15892
+  VectorMath::multiplyByScalar(
+      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+
+  vDSP_destroy_fftsetup(fftSetup_);
+}
+} // namespace audioapi
+#endif

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.cpp

@@ -24,12 +24,22 @@ void AudioBufferSourceNodeWrapper::setLoop(bool loop) {
 std::shared_ptr<AudioBufferWrapper> AudioBufferSourceNodeWrapper::getBuffer() {
   auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
   auto buffer = audioBufferSourceNode->getBuffer();
+
+  if (!buffer) {
+    return {nullptr};
+  }
+
   return std::make_shared<AudioBufferWrapper>(buffer);
 }
 
 void AudioBufferSourceNodeWrapper::setBuffer(
     const std::shared_ptr<AudioBufferWrapper> &buffer) {
   auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
+  if (!buffer) {
+    audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
+    return;
+  }
+
   audioBufferSourceNode->setBuffer(buffer->audioBuffer_);
 }
 } // namespace audioapi

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 
 #include "AudioBufferSourceNode.h"
 #include "AudioBufferWrapper.h"
@@ -14,8 +15,8 @@ class AudioBufferSourceNodeWrapper : public AudioScheduledSourceNodeWrapper {
       const std::shared_ptr<AudioBufferSourceNode> &audioBufferSourceNode);
 
   void setLoop(bool loop);
-  bool getLoop();
-  std::shared_ptr<AudioBufferWrapper> getBuffer();
+  [[nodiscard]] bool getLoop();
+  [[nodiscard]] std::shared_ptr<AudioBufferWrapper> getBuffer();
   void setBuffer(const std::shared_ptr<AudioBufferWrapper> &buffer);
 
  private:

package/common/cpp/wrappers/AudioBufferWrapper.h

@@ -11,11 +11,11 @@ class AudioBufferWrapper {
   explicit AudioBufferWrapper(const std::shared_ptr<AudioBuffer> &audioBuffer);
 
   std::shared_ptr<AudioBuffer> audioBuffer_;
-  int getNumberOfChannels() const;
-  int getLength() const;
-  double getDuration() const;
-  int getSampleRate() const;
-  float *getChannelData(int channel) const;
+  [[nodiscard]] int getNumberOfChannels() const;
+  [[nodiscard]] int getLength() const;
+  [[nodiscard]] double getDuration() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] float *getChannelData(int channel) const;
   void copyFromChannel(
       float *destination,
       int destinationLength,

package/common/cpp/wrappers/AudioContextWrapper.cpp

@@ -3,68 +3,15 @@
 namespace audioapi {
 
 AudioContextWrapper::AudioContextWrapper(
-    const std::shared_ptr<AudioContext> &audiocontext)
-    : audioContext_(audiocontext) {
-  auto destination = audioContext_->getDestination();
-  destination_ = std::make_shared<AudioDestinationNodeWrapper>(destination);
-}
-
-std::shared_ptr<AudioDestinationNodeWrapper>
-AudioContextWrapper::getDestination() const {
-  return destination_;
-}
-
-std::shared_ptr<OscillatorNodeWrapper> AudioContextWrapper::createOscillator()
-    const {
-  auto oscillator = audioContext_->createOscillator();
-  return std::make_shared<OscillatorNodeWrapper>(oscillator);
-}
-
-std::shared_ptr<GainNodeWrapper> AudioContextWrapper::createGain() const {
-  auto gain = audioContext_->createGain();
-  return std::make_shared<GainNodeWrapper>(gain);
-}
-
-std::shared_ptr<StereoPannerNodeWrapper>
-AudioContextWrapper::createStereoPanner() const {
-  auto panner = audioContext_->createStereoPanner();
-  return std::make_shared<StereoPannerNodeWrapper>(panner);
-}
-
-std::shared_ptr<BiquadFilterNodeWrapper>
-AudioContextWrapper::createBiquadFilter() const {
-  auto filter = audioContext_->createBiquadFilter();
-  return std::make_shared<BiquadFilterNodeWrapper>(filter);
-}
-
-std::shared_ptr<AudioBufferSourceNodeWrapper>
-AudioContextWrapper::createBufferSource() const {
-  auto bufferSource = audioContext_->createBufferSource();
-  return std::make_shared<AudioBufferSourceNodeWrapper>(bufferSource);
-}
-
-std::shared_ptr<AudioBufferWrapper> AudioContextWrapper::createBuffer(
-    int numberOfChannels,
-    int length,
-    int sampleRate) const {
-  auto buffer =
-      audioContext_->createBuffer(numberOfChannels, length, sampleRate);
-  return std::make_shared<AudioBufferWrapper>(buffer);
-}
-
-std::string AudioContextWrapper::getState() const {
-  return audioContext_->getState();
-}
-
-int AudioContextWrapper::getSampleRate() const {
-  return audioContext_->getSampleRate();
-}
+    const std::shared_ptr<AudioContext> &context)
+    : BaseAudioContextWrapper(context) {}
 
-double AudioContextWrapper::getCurrentTime() const {
-  return audioContext_->getCurrentTime();
+void AudioContextWrapper::close() {
+  getAudioContextFromBaseAudioContext()->close();
 }
 
-void AudioContextWrapper::close() const {
-  audioContext_->close();
+std::shared_ptr<AudioContext>
+AudioContextWrapper::getAudioContextFromBaseAudioContext() {
+  return std::static_pointer_cast<AudioContext>(context_);
 }
 } // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.h

@@ -1,40 +1,19 @@
 #pragma once
 
 #include <memory>
-#include <string>
-#include <utility>
 
-#include "AudioBufferSourceNodeWrapper.h"
-#include "AudioBufferWrapper.h"
 #include "AudioContext.h"
-#include "AudioDestinationNodeWrapper.h"
-#include "BiquadFilterNodeWrapper.h"
-#include "GainNodeWrapper.h"
-#include "OscillatorNodeWrapper.h"
-#include "StereoPannerNodeWrapper.h"
+#include "BaseAudioContextWrapper.h"
 
 namespace audioapi {
 
-class AudioContextWrapper {
+class AudioContextWrapper : public BaseAudioContextWrapper {
  public:
-  explicit AudioContextWrapper(
-      const std::shared_ptr<AudioContext> &audiocontext);
+  explicit AudioContextWrapper(const std::shared_ptr<AudioContext> &context);
 
-  std::shared_ptr<AudioDestinationNodeWrapper> getDestination() const;
-  std::shared_ptr<OscillatorNodeWrapper> createOscillator() const;
-  std::shared_ptr<GainNodeWrapper> createGain() const;
-  std::shared_ptr<StereoPannerNodeWrapper> createStereoPanner() const;
-  std::shared_ptr<BiquadFilterNodeWrapper> createBiquadFilter() const;
-  std::shared_ptr<AudioBufferSourceNodeWrapper> createBufferSource() const;
-  std::shared_ptr<AudioBufferWrapper>
-  createBuffer(int numberOfChannels, int length, int sampleRate) const;
-  std::string getState() const;
-  int getSampleRate() const;
-  double getCurrentTime() const;
-  void close() const;
+  void close();
 
  private:
-  std::shared_ptr<AudioDestinationNodeWrapper> destination_;
-  std::shared_ptr<AudioContext> audioContext_;
+  std::shared_ptr<AudioContext> getAudioContextFromBaseAudioContext();
 };
 } // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.h

@@ -11,11 +11,11 @@ class AudioNodeWrapper {
  public:
   explicit AudioNodeWrapper(const std::shared_ptr<AudioNode> &node);
 
-  int getNumberOfInputs() const;
-  int getNumberOfOutputs() const;
-  int getChannelCount() const;
-  std::string getChannelCountMode() const;
-  std::string getChannelInterpretation() const;
+  [[nodiscard]] int getNumberOfInputs() const;
+  [[nodiscard]] int getNumberOfOutputs() const;
+  [[nodiscard]] int getChannelCount() const;
+  [[nodiscard]] std::string getChannelCountMode() const;
+  [[nodiscard]] std::string getChannelInterpretation() const;
   void connect(const std::shared_ptr<AudioNodeWrapper> &node) const;
   void disconnect(const std::shared_ptr<AudioNodeWrapper> &node) const;
 

package/common/cpp/wrappers/AudioParamWrapper.h

@@ -10,11 +10,11 @@ class AudioParamWrapper {
  public:
   explicit AudioParamWrapper(const std::shared_ptr<AudioParam> &param);
 
-  float getValue() const;
+  [[nodiscard]] float getValue() const;
   void setValue(float value) const;
-  float getDefaultValue() const;
-  float getMinValue() const;
-  float getMaxValue() const;
+  [[nodiscard]] float getDefaultValue() const;
+  [[nodiscard]] float getMinValue() const;
+  [[nodiscard]] float getMaxValue() const;
   void setValueAtTime(float value, double startTime) const;
   void linearRampToValueAtTime(float value, double endTime) const;
   void exponentialRampToValueAtTime(float value, double endTime) const;

package/common/cpp/wrappers/BaseAudioContextWrapper.cpp

@@ -0,0 +1,76 @@
+#include "BaseAudioContextWrapper.h"
+
+namespace audioapi {
+
+BaseAudioContextWrapper::BaseAudioContextWrapper(
+    const std::shared_ptr<BaseAudioContext> &context)
+    : context_(context) {
+  auto destination = context_->getDestination();
+  destination_ = std::make_shared<AudioDestinationNodeWrapper>(destination);
+}
+
+std::shared_ptr<AudioDestinationNodeWrapper>
+BaseAudioContextWrapper::getDestination() const {
+  return destination_;
+}
+
+std::string BaseAudioContextWrapper::getState() const {
+  return context_->getState();
+}
+
+int BaseAudioContextWrapper::getSampleRate() const {
+  return context_->getSampleRate();
+}
+
+double BaseAudioContextWrapper::getCurrentTime() const {
+  return context_->getCurrentTime();
+}
+
+std::shared_ptr<OscillatorNodeWrapper>
+BaseAudioContextWrapper::createOscillator() const {
+  auto oscillator = context_->createOscillator();
+  return std::make_shared<OscillatorNodeWrapper>(oscillator);
+}
+
+std::shared_ptr<GainNodeWrapper> BaseAudioContextWrapper::createGain() const {
+  auto gain = context_->createGain();
+  return std::make_shared<GainNodeWrapper>(gain);
+}
+
+std::shared_ptr<StereoPannerNodeWrapper>
+BaseAudioContextWrapper::createStereoPanner() const {
+  auto panner = context_->createStereoPanner();
+  return std::make_shared<StereoPannerNodeWrapper>(panner);
+}
+
+std::shared_ptr<BiquadFilterNodeWrapper>
+BaseAudioContextWrapper::createBiquadFilter() const {
+  auto filter = context_->createBiquadFilter();
+  return std::make_shared<BiquadFilterNodeWrapper>(filter);
+}
+
+std::shared_ptr<AudioBufferSourceNodeWrapper>
+BaseAudioContextWrapper::createBufferSource() const {
+  auto bufferSource = context_->createBufferSource();
+  return std::make_shared<AudioBufferSourceNodeWrapper>(bufferSource);
+}
+
+std::shared_ptr<AudioBufferWrapper> BaseAudioContextWrapper::createBuffer(
+    int numberOfChannels,
+    int length,
+    int sampleRate) const {
+  auto buffer = context_->createBuffer(numberOfChannels, length, sampleRate);
+  return std::make_shared<AudioBufferWrapper>(buffer);
+}
+
+std::shared_ptr<PeriodicWaveWrapper>
+BaseAudioContextWrapper::createPeriodicWave(
+    float *real,
+    float *imag,
+    bool disableNormalization,
+    int length) {
+  auto periodicWave =
+      context_->createPeriodicWave(real, imag, disableNormalization, length);
+  return std::make_shared<PeriodicWaveWrapper>(periodicWave);
+}
+} // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "AudioBufferSourceNodeWrapper.h"
+#include "AudioBufferWrapper.h"
+#include "AudioDestinationNodeWrapper.h"
+#include "BaseAudioContext.h"
+#include "BiquadFilterNodeWrapper.h"
+#include "GainNodeWrapper.h"
+#include "OscillatorNodeWrapper.h"
+#include "PeriodicWaveWrapper.h"
+#include "StereoPannerNodeWrapper.h"
+
+namespace audioapi {
+
+class BaseAudioContextWrapper {
+ public:
+  explicit BaseAudioContextWrapper(
+      const std::shared_ptr<BaseAudioContext> &context);
+
+  [[nodiscard]] std::shared_ptr<AudioDestinationNodeWrapper> getDestination()
+      const;
+  [[nodiscard]] std::string getState() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] double getCurrentTime() const;
+  [[nodiscard]] std::shared_ptr<OscillatorNodeWrapper> createOscillator() const;
+  [[nodiscard]] std::shared_ptr<GainNodeWrapper> createGain() const;
+  [[nodiscard]] std::shared_ptr<StereoPannerNodeWrapper> createStereoPanner()
+      const;
+  [[nodiscard]] std::shared_ptr<BiquadFilterNodeWrapper> createBiquadFilter()
+      const;
+  [[nodiscard]] std::shared_ptr<AudioBufferSourceNodeWrapper>
+  createBufferSource() const;
+  [[nodiscard]] std::shared_ptr<AudioBufferWrapper>
+  createBuffer(int numberOfChannels, int length, int sampleRate) const;
+  [[nodiscard]] std::shared_ptr<PeriodicWaveWrapper> createPeriodicWave(
+      float *real,
+      float *imag,
+      bool disableNormalization,
+      int length);
+
+ protected:
+  std::shared_ptr<AudioDestinationNodeWrapper> destination_;
+  std::shared_ptr<BaseAudioContext> context_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.cpp

@@ -48,4 +48,13 @@ void BiquadFilterNodeWrapper::setType(const std::string &filterType) {
   auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
   biquadFilterNode_->setType(filterType);
 }
+
+void BiquadFilterNodeWrapper::getFrequencyResponse(
+    const std::vector<float> &frequencyArray,
+    std::vector<float> &magResponseOutput,
+    std::vector<float> &phaseResponseOutput) {
+  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
+  biquadFilterNode_->getFrequencyResponse(
+      frequencyArray, magResponseOutput, phaseResponseOutput);
+}
 } // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "AudioNodeWrapper.h"
 #include "AudioParamWrapper.h"
@@ -14,12 +15,16 @@ class BiquadFilterNodeWrapper : public AudioNodeWrapper {
   explicit BiquadFilterNodeWrapper(
       const std::shared_ptr<BiquadFilterNode> &biquadFilterNode);
 
-  std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
-  std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
-  std::shared_ptr<AudioParamWrapper> getQParam() const;
-  std::shared_ptr<AudioParamWrapper> getGainParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getQParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getGainParam() const;
   std::string getType();
   void setType(const std::string &filterType);
+  void getFrequencyResponse(
+      const std::vector<float> &frequencyArray,
+      std::vector<float> &magResponseOutput,
+      std::vector<float> &phaseResponseOutput);
 
  private:
   std::shared_ptr<AudioParamWrapper> frequencyParam_;