react-native-audio-api 0.1.0 → 0.2.0

package/common/cpp/core/BiquadFilterNode.h

@@ -2,110 +2,106 @@
 
 #include <algorithm>
 #include <cmath>
+#include <complex>
 #include <memory>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #include "AudioNode.h"
 #include "AudioParam.h"
+#include "BiquadFilterType.h"
 
 namespace audioapi {
 
+class AudioBus;
+
 class BiquadFilterNode : public AudioNode {
  public:
-  explicit BiquadFilterNode(AudioContext *context);
+  explicit BiquadFilterNode(BaseAudioContext *context);
 
-  std::string getType() const;
+  [[nodiscard]] std::string getType();
   void setType(const std::string &type);
-  std::shared_ptr<AudioParam> getFrequencyParam() const;
-  std::shared_ptr<AudioParam> getDetuneParam() const;
-  std::shared_ptr<AudioParam> getQParam() const;
-  std::shared_ptr<AudioParam> getGainParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getFrequencyParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getQParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
+  void getFrequencyResponse(
+      const std::vector<float> &frequencyArray,
+      std::vector<float> &magResponseOutput,
+      std::vector<float> &phaseResponseOutput);
 
  protected:
-  bool processAudio(float *audioData, int32_t numFrames) override;
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
-  enum class FilterType {
-    LOWPASS,
-    HIGHPASS,
-    BANDPASS,
-    LOWSHELF,
-    HIGHSHELF,
-    PEAKING,
-    NOTCH,
-    ALLPASS
-  };
-
-  static FilterType fromString(const std::string &type) {
+  std::shared_ptr<AudioParam> frequencyParam_;
+  std::shared_ptr<AudioParam> detuneParam_;
+  std::shared_ptr<AudioParam> QParam_;
+  std::shared_ptr<AudioParam> gainParam_;
+  audioapi::BiquadFilterType type_;
+
+  // delayed samples
+  float x1_ = 0;
+  float x2_ = 0;
+  float y1_ = 0;
+  float y2_ = 0;
+
+  // coefficients
+  float b0_ = 1.0;
+  float b1_ = 0;
+  float b2_ = 0;
+  float a1_ = 1.0;
+  float a2_ = 0;
+
+  static BiquadFilterType fromString(const std::string &type) {
     std::string lowerType = type;
     std::transform(
         lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
 
     if (lowerType == "lowpass")
-      return FilterType::LOWPASS;
+      return BiquadFilterType::LOWPASS;
     if (lowerType == "highpass")
-      return FilterType::HIGHPASS;
+      return BiquadFilterType::HIGHPASS;
     if (lowerType == "bandpass")
-      return FilterType::BANDPASS;
+      return BiquadFilterType::BANDPASS;
     if (lowerType == "lowshelf")
-      return FilterType::LOWSHELF;
+      return BiquadFilterType::LOWSHELF;
     if (lowerType == "highshelf")
-      return FilterType::HIGHSHELF;
+      return BiquadFilterType::HIGHSHELF;
     if (lowerType == "peaking")
-      return FilterType::PEAKING;
+      return BiquadFilterType::PEAKING;
     if (lowerType == "notch")
-      return FilterType::NOTCH;
+      return BiquadFilterType::NOTCH;
     if (lowerType == "allpass")
-      return FilterType::ALLPASS;
+      return BiquadFilterType::ALLPASS;
 
     throw std::invalid_argument("Invalid filter type: " + type);
   }
 
-  static std::string toString(FilterType type) {
+  static std::string toString(BiquadFilterType type) {
     switch (type) {
-      case FilterType::LOWPASS:
+      case BiquadFilterType::LOWPASS:
         return "lowpass";
-      case FilterType::HIGHPASS:
+      case BiquadFilterType::HIGHPASS:
         return "highpass";
-      case FilterType::BANDPASS:
+      case BiquadFilterType::BANDPASS:
         return "bandpass";
-      case FilterType::LOWSHELF:
+      case BiquadFilterType::LOWSHELF:
         return "lowshelf";
-      case FilterType::HIGHSHELF:
+      case BiquadFilterType::HIGHSHELF:
         return "highshelf";
-      case FilterType::PEAKING:
+      case BiquadFilterType::PEAKING:
         return "peaking";
-      case FilterType::NOTCH:
+      case BiquadFilterType::NOTCH:
         return "notch";
-      case FilterType::ALLPASS:
+      case BiquadFilterType::ALLPASS:
         return "allpass";
       default:
         throw std::invalid_argument("Unknown filter type");
     }
   }
 
- private:
-  std::shared_ptr<AudioParam> frequencyParam_;
-  std::shared_ptr<AudioParam> detuneParam_;
-  std::shared_ptr<AudioParam> QParam_;
-  std::shared_ptr<AudioParam> gainParam_;
-  FilterType type_;
-
-  // delayed samples
-  float x1_ = 0;
-  float x2_ = 0;
-  float y1_ = 0;
-  float y2_ = 0;
-
-  // coefficients
-  float b0_ = 1.0;
-  float b1_ = 0;
-  float b2_ = 0;
-  float a1_ = 1.0;
-  float a2_ = 0;
-
-  static float clamp(float value, float min, float max);
   void resetCoefficients();
   void setNormalizedCoefficients(
       float b0,

package/common/cpp/core/GainNode.cpp

@@ -1,30 +1,30 @@
 #include "GainNode.h"
-#include "AudioContext.h"
+#include "AudioBus.h"
+#include "AudioArray.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
-GainNode::GainNode(AudioContext *context) : AudioNode(context) {
+GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
   gainParam_ = std::make_shared<AudioParam>(context, 1.0, -MAX_GAIN, MAX_GAIN);
+  isInitialized_ = true;
 }
 
 std::shared_ptr<AudioParam> GainNode::getGainParam() const {
   return gainParam_;
 }
 
-bool GainNode::processAudio(float *audioData, int32_t numFrames) {
-  if (!AudioNode::processAudio(audioData, numFrames)) {
-    return false;
-  }
+void GainNode::processNode(AudioBus *processingBus, int framesToProcess) {
+  double time = context_->getCurrentTime();
+  double deltaTime = 1.0 / context_->getSampleRate();
 
-  auto time = context_->getCurrentTime();
-  auto deltaTime = 1.0 / context_->getSampleRate();
+  for (int i = 0; i < framesToProcess; i += 1) {
+    for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
+      (*processingBus->getChannel(j))[i] *= gainParam_->getValueAtTime(time);
+    }
 
-  for (int i = 0; i < numFrames * channelCount_; i++) {
-    audioData[i] *= gainParam_->getValueAtTime(time);
     time += deltaTime;
   }
-
-  return true;
 }
 
 } // namespace audioapi

package/common/cpp/core/GainNode.h

@@ -7,14 +7,16 @@
 
 namespace audioapi {
 
+class AudioBus;
+
 class GainNode : public AudioNode {
  public:
-  explicit GainNode(AudioContext *context);
+  explicit GainNode(BaseAudioContext *context);
 
-  std::shared_ptr<AudioParam> getGainParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 
  protected:
-  bool processAudio(float *audioData, int32_t numFrames) override;
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> gainParam_;

package/common/cpp/core/OscillatorNode.cpp

@@ -1,14 +1,19 @@
+#include "AudioBus.h"
+#include "AudioArray.h"
 #include "OscillatorNode.h"
-#include "AudioContext.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
-OscillatorNode::OscillatorNode(AudioContext *context)
+OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
       context, 444.0, -NYQUIST_FREQUENCY, NYQUIST_FREQUENCY);
   detuneParam_ =
       std::make_shared<AudioParam>(context, 0.0, -MAX_DETUNE, MAX_DETUNE);
+  type_ = OscillatorType::SINE;
+  periodicWave_ = context_->getBasicWaveForm(type_);
+  isInitialized_ = true;
 }
 
 std::shared_ptr<AudioParam> OscillatorNode::getFrequencyParam() const {
@@ -25,42 +30,46 @@ std::string OscillatorNode::getType() {
 
 void OscillatorNode::setType(const std::string &type) {
   type_ = OscillatorNode::fromString(type);
+  periodicWave_ = context_->getBasicWaveForm(type_);
 }
 
-bool OscillatorNode::processAudio(float *audioData, int32_t numFrames) {
-  if (!isPlaying_) {
-    return false;
-  } else {
-    auto time = context_->getCurrentTime();
-    auto deltaTime = 1.0 / context_->getSampleRate();
-
-    for (int i = 0; i < numFrames; ++i) {
-      auto detuneRatio =
-          std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
-      auto detunedFrequency =
-          round(frequencyParam_->getValueAtTime(time) * detuneRatio);
-      auto phaseIncrement = static_cast<float>(
-          2 * M_PI * detunedFrequency / context_->getSampleRate());
+void OscillatorNode::setPeriodicWave(
+    const std::shared_ptr<PeriodicWave> &periodicWave) {
+  periodicWave_ = periodicWave;
+  type_ = OscillatorType::CUSTOM;
+}
 
-      float value = OscillatorNode::getWaveBufferElement(phase_, type_);
+void OscillatorNode::processNode(AudioBus* processingBus, int framesToProcess) {
+  if (!isPlaying()) {
+    processingBus->zero();
+    return;
+  }
 
-      for (int j = 0; j < channelCount_; j++) {
-        audioData[i * channelCount_ + j] = value;
-      }
+  double time = context_->getCurrentTime();
+  double deltaTime = 1.0 / context_->getSampleRate();
 
-      phase_ += phaseIncrement;
-      time += deltaTime;
+  for (int i = 0; i < framesToProcess; i += 1) {
+    auto detuneRatio =
+      std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+    auto detunedFrequency =
+        round(frequencyParam_->getValueAtTime(time) * detuneRatio);
+    auto phaseIncrement = detunedFrequency * periodicWave_->getScale();
 
-      if (phase_ >= 2 * M_PI) {
-        phase_ -= 2 * M_PI;
-      }
+    float sample =
+        periodicWave_->getSample(detunedFrequency, phase_, phaseIncrement);
 
-      if (phase_ < 0) {
-        phase_ += 2 * M_PI;
-      }
+    for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
+      (*processingBus->getChannel(j))[i] = sample;
     }
 
-    return true;
+    phase_ += phaseIncrement;
+    phase_ -=
+        floor(
+            phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
+        static_cast<float>(periodicWave_->getPeriodicWaveSize());
+
+    time += deltaTime;
   }
 }
+
 } // namespace audioapi

package/common/cpp/core/OscillatorNode.h

@@ -5,108 +5,68 @@
 #include <string>
 
 #include "AudioParam.h"
+#include "PeriodicWave.h"
+#include "OscillatorType.h"
 #include "AudioScheduledSourceNode.h"
 
 namespace audioapi {
 
+class AudioBus;
+
 class OscillatorNode : public AudioScheduledSourceNode {
  public:
-  explicit OscillatorNode(AudioContext *context);
+  explicit OscillatorNode(BaseAudioContext *context);
 
-  std::shared_ptr<AudioParam> getFrequencyParam() const;
-  std::shared_ptr<AudioParam> getDetuneParam() const;
-  std::string getType();
+  [[nodiscard]] std::shared_ptr<AudioParam> getFrequencyParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
+  [[nodiscard]] std::string getType();
   void setType(const std::string &type);
+  void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  protected:
-  bool processAudio(float *audioData, int32_t numFrames) override;
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
-  enum class WaveType { SINE, SQUARE, SAWTOOTH, TRIANGLE, CUSTOM };
-
-  static float sineWave(double wavePhase) {
-    return static_cast<float>(std::sin(wavePhase));
-  }
-
-  static float squareWave(double wavePhase) {
-    return static_cast<float>(std::sin(wavePhase) >= 0 ? 1.0 : -1.0);
-  }
-
-  static float sawtoothWave(double wavePhase) {
-    return static_cast<float>(
-        2.0 *
-        (wavePhase / (2 * M_PI) - std::floor(wavePhase / (2 * M_PI) + 0.5)));
-  }
-
-  static float triangleWave(double wavePhase) {
-    return static_cast<float>(
-        2.0 *
-            std::abs(
-                2.0 *
-                (wavePhase / (2 * M_PI) -
-                 std::floor(wavePhase / (2 * M_PI) + 0.5))) -
-        1.0);
-  }
-
-  static float getWaveValue(double wavePhase, WaveType type) {
-    switch (type) {
-      case WaveType::SINE:
-        return sineWave(wavePhase);
-      case WaveType::SQUARE:
-        return squareWave(wavePhase);
-      case WaveType::SAWTOOTH:
-        return sawtoothWave(wavePhase);
-      case WaveType::TRIANGLE:
-        return triangleWave(wavePhase);
-      default:
-        throw std::invalid_argument("Unknown wave type");
-    }
-  }
+  std::shared_ptr<AudioParam> frequencyParam_;
+  std::shared_ptr<AudioParam> detuneParam_;
+  OscillatorType type_;
+  float phase_ = 0.0;
+  std::shared_ptr<PeriodicWave> periodicWave_;
 
-  static WaveType fromString(const std::string &type) {
+  static OscillatorType fromString(const std::string &type) {
     std::string lowerType = type;
     std::transform(
         lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
 
     if (lowerType == "sine")
-      return WaveType::SINE;
+      return OscillatorType::SINE;
     if (lowerType == "square")
-      return WaveType::SQUARE;
+      return OscillatorType::SQUARE;
     if (lowerType == "sawtooth")
-      return WaveType::SAWTOOTH;
+      return OscillatorType::SAWTOOTH;
     if (lowerType == "triangle")
-      return WaveType::TRIANGLE;
+      return OscillatorType::TRIANGLE;
     if (lowerType == "custom")
-      return WaveType::CUSTOM;
+      return OscillatorType::CUSTOM;
 
-    throw std::invalid_argument("Unknown wave type: " + type);
+    throw std::invalid_argument("Unknown oscillator type: " + type);
   }
 
-  static std::string toString(WaveType type) {
+  static std::string toString(OscillatorType type) {
     switch (type) {
-      case WaveType::SINE:
+      case OscillatorType::SINE:
         return "sine";
-      case WaveType::SQUARE:
+      case OscillatorType::SQUARE:
         return "square";
-      case WaveType::SAWTOOTH:
+      case OscillatorType::SAWTOOTH:
         return "sawtooth";
-      case WaveType::TRIANGLE:
+      case OscillatorType::TRIANGLE:
         return "triangle";
-      case WaveType::CUSTOM:
+      case OscillatorType::CUSTOM:
         return "custom";
       default:
-        throw std::invalid_argument("Unknown wave type");
+        throw std::invalid_argument("Unknown oscillator type");
     }
   }
-
-  static float getWaveBufferElement(double wavePhase, WaveType waveType) {
-    return getWaveValue(wavePhase, waveType);
-  }
-
- private:
-  std::shared_ptr<AudioParam> frequencyParam_;
-  std::shared_ptr<AudioParam> detuneParam_;
-  WaveType type_ = WaveType::SINE;
-  float phase_ = 0.0;
 };
 } // namespace audioapi

package/common/cpp/core/ParamChange.h

@@ -15,12 +15,12 @@ class ParamChange {
       std::function<float(double, double, float, float, double)>
           calculateValue);
 
-  double getEndTime() const;
-  double getStartTime() const;
-  float getEndValue() const;
-  float getStartValue() const;
-  std::function<float(double, double, float, float, double)> getCalculateValue()
-      const;
+  [[nodiscard]] double getEndTime() const;
+  [[nodiscard]] double getStartTime() const;
+  [[nodiscard]] float getEndValue() const;
+  [[nodiscard]] float getStartValue() const;
+  [[nodiscard]] std::function<float(double, double, float, float, double)>
+  getCalculateValue() const;
   bool operator<(const ParamChange &other) const;
 
  private: