react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/core/BiquadFilterNode.h

@@ -0,0 +1,124 @@
+#pragma once
+
+#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(BaseAudioContext *context);
+
+  [[nodiscard]] std::string getType();
+  void setType(const std::string &type);
+  [[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:
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
+
+ private:
+  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 BiquadFilterType::LOWPASS;
+    if (lowerType == "highpass")
+      return BiquadFilterType::HIGHPASS;
+    if (lowerType == "bandpass")
+      return BiquadFilterType::BANDPASS;
+    if (lowerType == "lowshelf")
+      return BiquadFilterType::LOWSHELF;
+    if (lowerType == "highshelf")
+      return BiquadFilterType::HIGHSHELF;
+    if (lowerType == "peaking")
+      return BiquadFilterType::PEAKING;
+    if (lowerType == "notch")
+      return BiquadFilterType::NOTCH;
+    if (lowerType == "allpass")
+      return BiquadFilterType::ALLPASS;
+
+    throw std::invalid_argument("Invalid filter type: " + type);
+  }
+
+  static std::string toString(BiquadFilterType type) {
+    switch (type) {
+      case BiquadFilterType::LOWPASS:
+        return "lowpass";
+      case BiquadFilterType::HIGHPASS:
+        return "highpass";
+      case BiquadFilterType::BANDPASS:
+        return "bandpass";
+      case BiquadFilterType::LOWSHELF:
+        return "lowshelf";
+      case BiquadFilterType::HIGHSHELF:
+        return "highshelf";
+      case BiquadFilterType::PEAKING:
+        return "peaking";
+      case BiquadFilterType::NOTCH:
+        return "notch";
+      case BiquadFilterType::ALLPASS:
+        return "allpass";
+      default:
+        throw std::invalid_argument("Unknown filter type");
+    }
+  }
+
+  void resetCoefficients();
+  void setNormalizedCoefficients(
+      float b0,
+      float b1,
+      float b2,
+      float a0,
+      float a1,
+      float a2);
+  void setLowpassCoefficients(float frequency, float Q);
+  void setHighpassCoefficients(float frequency, float Q);
+  void setBandpassCoefficients(float frequency, float Q);
+  void setLowshelfCoefficients(float frequency, float gain);
+  void setHighshelfCoefficients(float frequency, float gain);
+  void setPeakingCoefficients(float frequency, float Q, float gain);
+  void setNotchCoefficients(float frequency, float Q);
+  void setAllpassCoefficients(float frequency, float Q);
+  void applyFilter();
+};
+
+} // namespace audioapi

package/common/cpp/core/GainNode.cpp

@@ -0,0 +1,30 @@
+#include "GainNode.h"
+#include "AudioBus.h"
+#include "AudioArray.h"
+#include "BaseAudioContext.h"
+
+namespace audioapi {
+
+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_;
+}
+
+void GainNode::processNode(AudioBus *processingBus, int framesToProcess) {
+  double time = context_->getCurrentTime();
+  double 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);
+    }
+
+    time += deltaTime;
+  }
+}
+
+} // namespace audioapi

package/common/cpp/core/GainNode.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNode.h"
+#include "AudioParam.h"
+
+namespace audioapi {
+
+class AudioBus;
+
+class GainNode : public AudioNode {
+ public:
+  explicit GainNode(BaseAudioContext *context);
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
+
+ protected:
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioParam> gainParam_;
+};
+
+} // namespace audioapi

package/common/cpp/core/OscillatorNode.cpp

@@ -0,0 +1,75 @@
+#include "AudioBus.h"
+#include "AudioArray.h"
+#include "OscillatorNode.h"
+#include "BaseAudioContext.h"
+
+namespace audioapi {
+
+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 {
+  return frequencyParam_;
+}
+
+std::shared_ptr<AudioParam> OscillatorNode::getDetuneParam() const {
+  return detuneParam_;
+}
+
+std::string OscillatorNode::getType() {
+  return OscillatorNode::toString(type_);
+}
+
+void OscillatorNode::setType(const std::string &type) {
+  type_ = OscillatorNode::fromString(type);
+  periodicWave_ = context_->getBasicWaveForm(type_);
+}
+
+void OscillatorNode::setPeriodicWave(
+    const std::shared_ptr<PeriodicWave> &periodicWave) {
+  periodicWave_ = periodicWave;
+  type_ = OscillatorType::CUSTOM;
+}
+
+void OscillatorNode::processNode(AudioBus* processingBus, int framesToProcess) {
+  if (!isPlaying()) {
+    processingBus->zero();
+    return;
+  }
+
+  double time = context_->getCurrentTime();
+  double deltaTime = 1.0 / context_->getSampleRate();
+
+  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();
+
+    float sample =
+        periodicWave_->getSample(detunedFrequency, phase_, phaseIncrement);
+
+    for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
+      (*processingBus->getChannel(j))[i] = sample;
+    }
+
+    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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <memory>
+#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(BaseAudioContext *context);
+
+  [[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:
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioParam> frequencyParam_;
+  std::shared_ptr<AudioParam> detuneParam_;
+  OscillatorType type_;
+  float phase_ = 0.0;
+  std::shared_ptr<PeriodicWave> periodicWave_;
+
+  static OscillatorType fromString(const std::string &type) {
+    std::string lowerType = type;
+    std::transform(
+        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+
+    if (lowerType == "sine")
+      return OscillatorType::SINE;
+    if (lowerType == "square")
+      return OscillatorType::SQUARE;
+    if (lowerType == "sawtooth")
+      return OscillatorType::SAWTOOTH;
+    if (lowerType == "triangle")
+      return OscillatorType::TRIANGLE;
+    if (lowerType == "custom")
+      return OscillatorType::CUSTOM;
+
+    throw std::invalid_argument("Unknown oscillator type: " + type);
+  }
+
+  static std::string toString(OscillatorType type) {
+    switch (type) {
+      case OscillatorType::SINE:
+        return "sine";
+      case OscillatorType::SQUARE:
+        return "square";
+      case OscillatorType::SAWTOOTH:
+        return "sawtooth";
+      case OscillatorType::TRIANGLE:
+        return "triangle";
+      case OscillatorType::CUSTOM:
+        return "custom";
+      default:
+        throw std::invalid_argument("Unknown oscillator type");
+    }
+  }
+};
+} // namespace audioapi

package/common/cpp/core/ParamChange.cpp

@@ -0,0 +1,46 @@
+#include "ParamChange.h"
+
+#include <utility>
+
+namespace audioapi {
+
+ParamChange::ParamChange(
+    double startTime,
+    double endTime,
+    float startValue,
+    float endValue,
+    std::function<float(double, double, float, float, double)> calculateValue)
+    : startTime_(startTime),
+      endTime_(endTime),
+      startValue_(startValue),
+      endValue_(endValue),
+      calculateValue_(std::move(calculateValue)) {}
+
+double ParamChange::getEndTime() const {
+  return endTime_;
+}
+
+double ParamChange::getStartTime() const {
+  return startTime_;
+}
+
+float ParamChange::getEndValue() const {
+  return endValue_;
+}
+
+float ParamChange::getStartValue() const {
+  return startValue_;
+}
+
+std::function<float(double, double, float, float, double)>
+ParamChange::getCalculateValue() const {
+  return calculateValue_;
+}
+
+bool ParamChange::operator<(const ParamChange &other) const {
+  if (startTime_ != other.startTime_)
+    return startTime_ < other.startTime_;
+  return endTime_ < other.endTime_;
+}
+
+} // namespace audioapi

package/common/cpp/core/ParamChange.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+
+namespace audioapi {
+
+class ParamChange {
+ public:
+  explicit ParamChange(
+      double startTime,
+      double endTime,
+      float startValue,
+      float endValue,
+      std::function<float(double, double, float, float, double)>
+          calculateValue);
+
+  [[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:
+  double startTime_;
+  double endTime_;
+  float startValue_;
+  float endValue_;
+  std::function<float(double, double, float, float, double)> calculateValue_;
+};
+
+} // namespace audioapi