react-native-audio-api 0.0.1 → 0.1.0

package/common/cpp/core/BiquadFilterNode.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+#include "AudioNode.h"
+#include "AudioParam.h"
+
+namespace audioapi {
+
+class BiquadFilterNode : public AudioNode {
+ public:
+  explicit BiquadFilterNode(AudioContext *context);
+
+  std::string getType() const;
+  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;
+
+ protected:
+  bool processAudio(float *audioData, int32_t numFrames) override;
+
+ private:
+  enum class FilterType {
+    LOWPASS,
+    HIGHPASS,
+    BANDPASS,
+    LOWSHELF,
+    HIGHSHELF,
+    PEAKING,
+    NOTCH,
+    ALLPASS
+  };
+
+  static FilterType fromString(const std::string &type) {
+    std::string lowerType = type;
+    std::transform(
+        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+
+    if (lowerType == "lowpass")
+      return FilterType::LOWPASS;
+    if (lowerType == "highpass")
+      return FilterType::HIGHPASS;
+    if (lowerType == "bandpass")
+      return FilterType::BANDPASS;
+    if (lowerType == "lowshelf")
+      return FilterType::LOWSHELF;
+    if (lowerType == "highshelf")
+      return FilterType::HIGHSHELF;
+    if (lowerType == "peaking")
+      return FilterType::PEAKING;
+    if (lowerType == "notch")
+      return FilterType::NOTCH;
+    if (lowerType == "allpass")
+      return FilterType::ALLPASS;
+
+    throw std::invalid_argument("Invalid filter type: " + type);
+  }
+
+  static std::string toString(FilterType type) {
+    switch (type) {
+      case FilterType::LOWPASS:
+        return "lowpass";
+      case FilterType::HIGHPASS:
+        return "highpass";
+      case FilterType::BANDPASS:
+        return "bandpass";
+      case FilterType::LOWSHELF:
+        return "lowshelf";
+      case FilterType::HIGHSHELF:
+        return "highshelf";
+      case FilterType::PEAKING:
+        return "peaking";
+      case FilterType::NOTCH:
+        return "notch";
+      case FilterType::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,
+      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 "AudioContext.h"
+
+namespace audioapi {
+
+GainNode::GainNode(AudioContext *context) : AudioNode(context) {
+  gainParam_ = std::make_shared<AudioParam>(context, 1.0, -MAX_GAIN, MAX_GAIN);
+}
+
+std::shared_ptr<AudioParam> GainNode::getGainParam() const {
+  return gainParam_;
+}
+
+bool GainNode::processAudio(float *audioData, int32_t numFrames) {
+  if (!AudioNode::processAudio(audioData, numFrames)) {
+    return false;
+  }
+
+  auto time = context_->getCurrentTime();
+  auto deltaTime = 1.0 / context_->getSampleRate();
+
+  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

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNode.h"
+#include "AudioParam.h"
+
+namespace audioapi {
+
+class GainNode : public AudioNode {
+ public:
+  explicit GainNode(AudioContext *context);
+
+  std::shared_ptr<AudioParam> getGainParam() const;
+
+ protected:
+  bool processAudio(float *audioData, int32_t numFrames) override;
+
+ private:
+  std::shared_ptr<AudioParam> gainParam_;
+};
+
+} // namespace audioapi

package/common/cpp/core/OscillatorNode.cpp

@@ -0,0 +1,66 @@
+#include "OscillatorNode.h"
+#include "AudioContext.h"
+
+namespace audioapi {
+
+OscillatorNode::OscillatorNode(AudioContext *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);
+}
+
+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);
+}
+
+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());
+
+      float value = OscillatorNode::getWaveBufferElement(phase_, type_);
+
+      for (int j = 0; j < channelCount_; j++) {
+        audioData[i * channelCount_ + j] = value;
+      }
+
+      phase_ += phaseIncrement;
+      time += deltaTime;
+
+      if (phase_ >= 2 * M_PI) {
+        phase_ -= 2 * M_PI;
+      }
+
+      if (phase_ < 0) {
+        phase_ += 2 * M_PI;
+      }
+    }
+
+    return true;
+  }
+}
+} // namespace audioapi

package/common/cpp/core/OscillatorNode.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <cmath>
+#include <memory>
+#include <string>
+
+#include "AudioParam.h"
+#include "AudioScheduledSourceNode.h"
+
+namespace audioapi {
+
+class OscillatorNode : public AudioScheduledSourceNode {
+ public:
+  explicit OscillatorNode(AudioContext *context);
+
+  std::shared_ptr<AudioParam> getFrequencyParam() const;
+  std::shared_ptr<AudioParam> getDetuneParam() const;
+  std::string getType();
+  void setType(const std::string &type);
+
+ protected:
+  bool processAudio(float *audioData, int32_t numFrames) 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");
+    }
+  }
+
+  static WaveType fromString(const std::string &type) {
+    std::string lowerType = type;
+    std::transform(
+        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+
+    if (lowerType == "sine")
+      return WaveType::SINE;
+    if (lowerType == "square")
+      return WaveType::SQUARE;
+    if (lowerType == "sawtooth")
+      return WaveType::SAWTOOTH;
+    if (lowerType == "triangle")
+      return WaveType::TRIANGLE;
+    if (lowerType == "custom")
+      return WaveType::CUSTOM;
+
+    throw std::invalid_argument("Unknown wave type: " + type);
+  }
+
+  static std::string toString(WaveType type) {
+    switch (type) {
+      case WaveType::SINE:
+        return "sine";
+      case WaveType::SQUARE:
+        return "square";
+      case WaveType::SAWTOOTH:
+        return "sawtooth";
+      case WaveType::TRIANGLE:
+        return "triangle";
+      case WaveType::CUSTOM:
+        return "custom";
+      default:
+        throw std::invalid_argument("Unknown wave 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.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);
+
+  double getEndTime() const;
+  double getStartTime() const;
+  float getEndValue() const;
+  float getStartValue() const;
+  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

package/common/cpp/core/StereoPannerNode.cpp

@@ -0,0 +1,58 @@
+#include "StereoPannerNode.h"
+#include "AudioContext.h"
+
+// https://webaudio.github.io/web-audio-api/#stereopanner-algorithm
+
+namespace audioapi {
+
+StereoPannerNode::StereoPannerNode(AudioContext *context) : AudioNode(context) {
+  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+  panParam_ = std::make_shared<AudioParam>(context, 0.0, -MAX_PAN, MAX_PAN);
+}
+
+std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
+  return panParam_;
+}
+
+bool StereoPannerNode::processAudio(float *audioData, int32_t numFrames) {
+  // assumed channelCount = 2
+  if (!AudioNode::processAudio(audioData, numFrames)) {
+    return false;
+  }
+
+  auto time = context_->getCurrentTime();
+  auto deltaTime = 1.0 / context_->getSampleRate();
+
+  for (int i = 0; i < numFrames; i++) {
+    auto pan = panParam_->getValueAtTime(time);
+    auto x = (pan <= 0 ? pan + 1 : pan) * M_PI / 2;
+
+    auto gainL = static_cast<float>(cos(x));
+    auto gainR = static_cast<float>(sin(x));
+
+    auto inputL = audioData[i * 2];
+    auto inputR = audioData[i * 2 + 1];
+
+    if (pan <= 0) {
+      audioData[i * 2] = inputL + inputR * gainL;
+      audioData[i * 2 + 1] = inputR * gainR;
+    } else {
+      audioData[i * 2] = inputL * gainL;
+      audioData[i * 2 + 1] = inputR + inputL * gainR;
+    }
+
+    time += deltaTime;
+  }
+
+  normalize(audioData, numFrames);
+
+  return true;
+}
+
+void StereoPannerNode::normalize(float *audioData, int32_t numFrames) {
+  auto maxValue = std::max(
+      1.0f, VectorMath::maximumMagnitude(audioData, numFrames * channelCount_));
+  VectorMath::multiplyByScalar(
+      audioData, 1.0f / maxValue, audioData, numFrames * channelCount_);
+}
+} // namespace audioapi

package/common/cpp/core/StereoPannerNode.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <algorithm>
+#include <memory>
+
+#include "AudioNode.h"
+#include "AudioParam.h"
+#include "VectorMath.h"
+
+namespace audioapi {
+
+class StereoPannerNode : public AudioNode {
+ public:
+  explicit StereoPannerNode(AudioContext *context);
+  std::shared_ptr<AudioParam> getPanParam() const;
+
+ protected:
+  bool processAudio(float *audioData, int32_t numFrames) override;
+
+ private:
+  std::shared_ptr<AudioParam> panParam_;
+
+  void normalize(float *audioData, int32_t numFrames);
+};
+
+} // namespace audioapi