react-native-audio-api 0.0.1 → 0.1.0

package/common/cpp/core/AudioNode.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "Constants.h"
+
+// channelCount always equal to 2
+
+namespace audioapi {
+
+class AudioContext;
+
+class AudioNode : public std::enable_shared_from_this<AudioNode> {
+ public:
+  explicit AudioNode(AudioContext *context);
+  virtual ~AudioNode();
+  int getNumberOfInputs() const;
+  int getNumberOfOutputs() const;
+  int getChannelCount() const;
+  std::string getChannelCountMode() const;
+  std::string getChannelInterpretation() const;
+  void connect(const std::shared_ptr<AudioNode> &node);
+  void disconnect(const std::shared_ptr<AudioNode> &node);
+
+  // Change public to protected
+  virtual bool processAudio(float *audioData, int32_t numFrames);
+
+ protected:
+  enum class ChannelCountMode { MAX, CLAMPED_MAX, EXPLICIT };
+
+  static std::string toString(ChannelCountMode mode) {
+    switch (mode) {
+      case ChannelCountMode::MAX:
+        return "max";
+      case ChannelCountMode::CLAMPED_MAX:
+        return "clamped-max";
+      case ChannelCountMode::EXPLICIT:
+        return "explicit";
+      default:
+        throw std::invalid_argument("Unknown channel count mode");
+    }
+  }
+
+  enum class ChannelInterpretation { SPEAKERS, DISCRETE };
+
+  static std::string toString(ChannelInterpretation interpretation) {
+    switch (interpretation) {
+      case ChannelInterpretation::SPEAKERS:
+        return "speakers";
+      case ChannelInterpretation::DISCRETE:
+        return "discrete";
+      default:
+        throw std::invalid_argument("Unknown channel interpretation");
+    }
+  }
+
+ protected:
+  AudioContext *context_;
+  int numberOfInputs_ = 1;
+  int numberOfOutputs_ = 1;
+  int channelCount_ = CHANNEL_COUNT;
+  ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
+  ChannelInterpretation channelInterpretation_ =
+      ChannelInterpretation::SPEAKERS;
+
+  std::vector<std::shared_ptr<AudioNode>> inputNodes_ = {};
+  std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
+
+ private:
+  void cleanup();
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioParam.cpp

@@ -0,0 +1,136 @@
+#include "AudioParam.h"
+#include "AudioContext.h"
+
+namespace audioapi {
+
+AudioParam::AudioParam(
+    AudioContext *context,
+    float defaultValue,
+    float minValue,
+    float maxValue)
+    : value_(defaultValue),
+      defaultValue_(defaultValue),
+      minValue_(minValue),
+      maxValue_(maxValue),
+      context_(context),
+      changesQueue_() {
+  startTime_ = 0;
+  endTime_ = 0;
+  startValue_ = 0;
+  endValue_ = 0;
+  calculateValue_ = [this](double, double, float, float, double) {
+    return value_;
+  };
+}
+
+float AudioParam::getValue() const {
+  return value_;
+}
+
+float AudioParam::getDefaultValue() const {
+  return defaultValue_;
+}
+
+float AudioParam::getMinValue() const {
+  return minValue_;
+}
+
+float AudioParam::getMaxValue() const {
+  return maxValue_;
+}
+
+void AudioParam::setValue(float value) {
+  checkValue(value);
+  value_ = value;
+}
+
+float AudioParam::getValueAtTime(double time) {
+  if (!changesQueue_.empty()) {
+    if (endTime_ < time) {
+      auto change = *changesQueue_.begin();
+      startTime_ = change.getStartTime();
+      endTime_ = change.getEndTime();
+      startValue_ = change.getStartValue();
+      endValue_ = change.getEndValue();
+      calculateValue_ = change.getCalculateValue();
+      changesQueue_.erase(changesQueue_.begin());
+    }
+  }
+
+  if (startTime_ <= time) {
+    value_ =
+        calculateValue_(startTime_, endTime_, startValue_, endValue_, time);
+  }
+
+  return value_;
+}
+
+void AudioParam::setValueAtTime(float value, double time) {
+  checkValue(value);
+  auto calculateValue = [](double, double, float, float endValue, double) {
+    return endValue;
+  };
+
+  auto paramChange = ParamChange(time, time, value, value, calculateValue);
+  changesQueue_.insert(paramChange);
+}
+
+void AudioParam::linearRampToValueAtTime(float value, double time) {
+  checkValue(value);
+  auto calculateValue = [](double startTime,
+                           double endTime,
+                           float startValue,
+                           float endValue,
+                           double time) {
+    return time >= endTime ? endValue
+                           : startValue +
+            (endValue - startValue) * (time - startTime) /
+                (endTime - startTime);
+  };
+
+  auto paramChange =
+      ParamChange(getStartTime(), time, getStartValue(), value, calculateValue);
+  changesQueue_.emplace(paramChange);
+}
+
+void AudioParam::exponentialRampToValueAtTime(float value, double time) {
+  checkValue(value);
+  auto calculateValue = [](double startTime,
+                           double endTime,
+                           float startValue,
+                           float endValue,
+                           double time) {
+    return time >= endTime ? endValue
+                           : startValue *
+            pow(endValue / startValue,
+                (time - startTime) / (endTime - startTime));
+  };
+
+  auto paramChange =
+      ParamChange(getStartTime(), time, getStartValue(), value, calculateValue);
+  changesQueue_.emplace(paramChange);
+}
+
+void AudioParam::checkValue(float value) const {
+  if (value < minValue_ || value > maxValue_) {
+    throw std::invalid_argument("Value out of range");
+  }
+}
+
+double AudioParam::getStartTime() {
+  if (changesQueue_.empty()) {
+    return context_->getCurrentTime();
+  }
+
+  return changesQueue_.rbegin()->getEndTime();
+}
+
+float AudioParam::getStartValue() {
+  if (changesQueue_.empty()) {
+    return this->value_;
+  }
+
+  return changesQueue_.rbegin()->getEndValue();
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioParam.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <memory>
+#include <set>
+#include <vector>
+
+#include "ParamChange.h"
+
+namespace audioapi {
+
+class AudioContext;
+
+class AudioParam {
+ public:
+  explicit AudioParam(
+      AudioContext *context,
+      float defaultValue,
+      float minValue,
+      float maxValue);
+
+  float getValue() const;
+  float getValueAtTime(double time);
+  void setValue(float value);
+  float getDefaultValue() const;
+  float getMinValue() const;
+  float getMaxValue() const;
+  void setValueAtTime(float value, double startTime);
+  void linearRampToValueAtTime(float value, double endTime);
+  void exponentialRampToValueAtTime(float value, double endTime);
+
+ private:
+  float value_;
+  float defaultValue_;
+  float minValue_;
+  float maxValue_;
+  AudioContext *context_;
+  std::set<ParamChange> changesQueue_;
+
+  double startTime_;
+  double endTime_;
+  float startValue_;
+  float endValue_;
+  std::function<float(double, double, float, float, double)> calculateValue_;
+
+  void checkValue(float value) const;
+  double getStartTime();
+  float getStartValue();
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -0,0 +1,39 @@
+#include "AudioScheduledSourceNode.h"
+#include "AudioContext.h"
+
+namespace audioapi {
+
+AudioScheduledSourceNode::AudioScheduledSourceNode(AudioContext *context)
+    : AudioNode(context), isPlaying_(false) {
+  numberOfInputs_ = 0;
+}
+
+void AudioScheduledSourceNode::start(double time) {
+  waitAndExecute(time, [this](double time) { startPlayback(); });
+}
+
+void AudioScheduledSourceNode::stop(double time) {
+  waitAndExecute(time, [this](double time) { stopPlayback(); });
+}
+
+void AudioScheduledSourceNode::startPlayback() {
+  isPlaying_ = true;
+}
+
+void AudioScheduledSourceNode::stopPlayback() {
+  isPlaying_ = false;
+}
+
+void AudioScheduledSourceNode::waitAndExecute(
+    double time,
+    const std::function<void(double)> &fun) {
+  std::thread([this, time, fun]() {
+    while (context_->getCurrentTime() < time) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+
+    fun(time);
+  }).detach();
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioScheduledSourceNode.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <atomic>
+#include <chrono>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <thread>
+
+#include "AudioNode.h"
+
+namespace audioapi {
+
+class AudioScheduledSourceNode : public AudioNode {
+ public:
+  explicit AudioScheduledSourceNode(AudioContext *context);
+
+  void start(double time);
+  void stop(double time);
+
+ protected:
+  std::atomic<bool> isPlaying_;
+
+ private:
+  void startPlayback();
+  void stopPlayback();
+  void waitAndExecute(double time, const std::function<void(double)> &fun);
+};
+
+} // namespace audioapi

package/common/cpp/core/BiquadFilterNode.cpp

@@ -0,0 +1,364 @@
+#include "BiquadFilterNode.h"
+#include "AudioContext.h"
+
+// https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html - math
+// formulas for filters
+// https://github.com/LabSound/LabSound/blob/main/src/internal/src/Biquad.cpp -
+// implementation of filters on which I based mine
+
+namespace audioapi {
+
+BiquadFilterNode::BiquadFilterNode(AudioContext *context) : AudioNode(context) {
+  frequencyParam_ = std::make_shared<AudioParam>(
+      context, 350.0, MIN_FILTER_FREQUENCY, MAX_FILTER_FREQUENCY);
+  detuneParam_ =
+      std::make_shared<AudioParam>(context, 0.0, -MAX_DETUNE, MAX_DETUNE);
+  QParam_ =
+      std::make_shared<AudioParam>(context, 1.0, -MAX_FILTER_Q, MAX_FILTER_Q);
+  gainParam_ = std::make_shared<AudioParam>(
+      context, 0.0, MIN_FILTER_GAIN, MAX_FILTER_GAIN);
+  type_ = FilterType::LOWPASS;
+}
+
+std::string BiquadFilterNode::getType() const {
+  return BiquadFilterNode::toString(type_);
+}
+
+void BiquadFilterNode::setType(const std::string &type) {
+  type_ = BiquadFilterNode::fromString(type);
+}
+
+std::shared_ptr<AudioParam> BiquadFilterNode::getFrequencyParam() const {
+  return frequencyParam_;
+}
+
+std::shared_ptr<AudioParam> BiquadFilterNode::getDetuneParam() const {
+  return detuneParam_;
+}
+
+std::shared_ptr<AudioParam> BiquadFilterNode::getQParam() const {
+  return QParam_;
+}
+
+std::shared_ptr<AudioParam> BiquadFilterNode::getGainParam() const {
+  return gainParam_;
+}
+
+float BiquadFilterNode::clamp(float value, float min, float max) {
+  return std::min(std::max(value, min), max);
+}
+
+void BiquadFilterNode::resetCoefficients() {
+  x1_ = 0.0;
+  x2_ = 0.0;
+  y1_ = 0.0;
+  y2_ = 0.0;
+}
+
+void BiquadFilterNode::setNormalizedCoefficients(
+    float b0,
+    float b1,
+    float b2,
+    float a0,
+    float a1,
+    float a2) {
+  auto a0Inversed = 1.0f / a0;
+  b0_ = b0 * a0Inversed;
+  b1_ = b1 * a0Inversed;
+  b2_ = b2 * a0Inversed;
+  a1_ = a1 * a0Inversed;
+  a2_ = a2 * a0Inversed;
+}
+
+void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  if (frequency == 1.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+  if (frequency <= 0.0) {
+    setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  Q = std::max(0.0f, Q);
+  float g = std::pow(10.0f, 0.05f * Q);
+  float d = std::sqrt((4 - std::sqrt(16 - 16 / (g * g))) / 2);
+
+  float theta = M_PI * frequency;
+  float sn = 0.5f * d * std::sin(theta);
+  float beta = 0.5f * (1 - sn) / (1 + sn);
+  float gamma = (0.5f + beta) * std::cos(theta);
+  float alpha = 0.25f * (0.5f + beta - gamma);
+
+  setNormalizedCoefficients(
+      2 * alpha, 4 * alpha, 2 * alpha, 1.0f, -2 * gamma, 2 * beta);
+}
+
+void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  if (frequency == 1.0) {
+    setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+  if (frequency <= 0.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  Q = std::max(0.0f, Q);
+  float g = std::pow(10.0f, 0.05f * Q);
+  float d = std::sqrt((4 - std::sqrt(16 - 16 / (g * g))) / 2);
+
+  float theta = M_PI * frequency;
+  float sn = 0.5f * d * std::sin(theta);
+  float beta = 0.5f * (1 - sn) / (1 + sn);
+  float gamma = (0.5f + beta) * std::cos(theta);
+  float alpha = 0.25f * (0.5f + beta - gamma);
+
+  setNormalizedCoefficients(
+      2 * alpha, -4 * alpha, 2 * alpha, 1.0f, -2 * gamma, 2 * beta);
+}
+
+void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  Q = std::max(0.0f, Q);
+
+  if (frequency <= 0.0 || frequency >= 1.0) {
+    setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  if (Q <= 0.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  float w0 = M_PI * frequency;
+  float alpha = std::sin(w0) / (2 * Q);
+  float k = std::cos(w0);
+
+  setNormalizedCoefficients(
+      alpha, 0.0f, -alpha, 1.0f + alpha, -2 * k, 1.0f - alpha);
+}
+
+void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  float A = std::pow(10.0f, gain / 40.0f);
+
+  if (frequency == 1.0) {
+    setNormalizedCoefficients(A * A, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  if (frequency <= 0.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  float w0 = M_PI * frequency;
+  float alpha =
+      0.5f * std::sin(w0) * std::sqrt((A + 1 / A) * (1 / 1.0f - 1) + 2);
+  float k = std::cos(w0);
+  float k2 = 2.0f * std::sqrt(A) * alpha;
+
+  setNormalizedCoefficients(
+      A * (A + 1 - (A - 1) * k + k2),
+      2.0f * A * (A - 1 - (A + 1) * k),
+      A * (A + 1 - (A - 1) * k - k2),
+      A + 1 + (A - 1) * k + k2,
+      -2.0f * (A - 1 + (A + 1) * k),
+      A + 1 + (A - 1) * k - k2);
+}
+
+void BiquadFilterNode::setHighshelfCoefficients(float frequency, float gain) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  float A = std::pow(10.0f, gain / 40.0f);
+
+  if (frequency == 1.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  if (frequency <= 0.0) {
+    setNormalizedCoefficients(A * A, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  float w0 = M_PI * frequency;
+  float alpha =
+      0.5f * std::sin(w0) * std::sqrt((A + 1 / A) * (1 / 1.0f - 1) + 2);
+  float k = std::cos(w0);
+  float k2 = 2.0f * std::sqrt(A) * alpha;
+
+  setNormalizedCoefficients(
+      A * (A + 1 + (A - 1) * k + k2),
+      -2.0f * A * (A - 1 + (A + 1) * k),
+      A * (A + 1 + (A - 1) * k - k2),
+      A + 1 - (A - 1) * k + k2,
+      2.0f * (A - 1 - (A + 1) * k),
+      A + 1 - (A - 1) * k - k2);
+}
+
+void BiquadFilterNode::setPeakingCoefficients(
+    float frequency,
+    float Q,
+    float gain) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  Q = std::max(0.0f, Q);
+  float A = std::pow(10.0f, gain / 40.0f);
+
+  if (frequency <= 0.0 || frequency >= 1.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  if (Q <= 0.0) {
+    setNormalizedCoefficients(A * A, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  float w0 = M_PI * frequency;
+  float alpha = std::sin(w0) / (2 * Q);
+  float k = std::cos(w0);
+
+  setNormalizedCoefficients(
+      1 + alpha * A,
+      -2 * k,
+      1 - alpha * A,
+      1 + alpha / A,
+      -2 * k,
+      1 - alpha / A);
+}
+
+void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  Q = std::max(0.0f, Q);
+
+  if (frequency <= 0.0 || frequency >= 1.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  if (Q <= 0.0) {
+    setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  float w0 = M_PI * frequency;
+  float alpha = std::sin(w0) / (2 * Q);
+  float k = std::cos(w0);
+
+  setNormalizedCoefficients(1.0f, -2 * k, 1.0f, 1 + alpha, -2 * k, 1 - alpha);
+}
+
+void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
+  frequency = clamp(frequency, 0.0, 1.0);
+  Q = std::max(0.0f, Q);
+
+  if (frequency <= 0.0 || frequency >= 1.0) {
+    setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  if (Q <= 0.0) {
+    setNormalizedCoefficients(-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+    return;
+  }
+
+  float w0 = M_PI * frequency;
+  float alpha = std::sin(w0) / (2 * Q);
+  float k = std::cos(w0);
+
+  setNormalizedCoefficients(
+      1 - alpha, -2 * k, 1 + alpha, 1 + alpha, -2 * k, 1 - alpha);
+}
+
+void BiquadFilterNode::applyFilter() {
+  double currentTime = context_->getCurrentTime();
+
+  float normalizedFrequency =
+      frequencyParam_->getValueAtTime(currentTime) / NYQUIST_FREQUENCY;
+  float detuneValue = detuneParam_->getValueAtTime(currentTime);
+
+  if (detuneValue != 0.0) {
+    normalizedFrequency *= std::pow(2.0f, detuneValue / 1200.0f);
+  }
+
+  switch (type_) {
+    case FilterType::LOWPASS:
+      setLowpassCoefficients(
+          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      break;
+    case FilterType::HIGHPASS:
+      setHighpassCoefficients(
+          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      break;
+    case FilterType::BANDPASS:
+      setBandpassCoefficients(
+          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      break;
+    case FilterType::LOWSHELF:
+      setLowshelfCoefficients(
+          normalizedFrequency, gainParam_->getValueAtTime(currentTime));
+      break;
+    case FilterType::HIGHSHELF:
+      setHighshelfCoefficients(
+          normalizedFrequency, gainParam_->getValueAtTime(currentTime));
+      break;
+    case FilterType::PEAKING:
+      setPeakingCoefficients(
+          normalizedFrequency,
+          QParam_->getValueAtTime(currentTime),
+          gainParam_->getValueAtTime(currentTime));
+      break;
+    case FilterType::NOTCH:
+      setNotchCoefficients(
+          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      break;
+    case FilterType::ALLPASS:
+      setAllpassCoefficients(
+          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      break;
+    default:
+      break;
+  }
+}
+
+bool BiquadFilterNode::processAudio(float *audioData, int32_t numFrames) {
+  if (!AudioNode::processAudio(audioData, numFrames)) {
+    return false;
+  }
+
+  resetCoefficients();
+  applyFilter();
+
+  float x1 = x1_;
+  float x2 = x2_;
+  float y1 = y1_;
+  float y2 = y2_;
+
+  float b0 = b0_;
+  float b1 = b1_;
+  float b2 = b2_;
+  float a1 = a1_;
+  float a2 = a2_;
+
+  for (int i = 0; i < numFrames; i++) {
+    auto input = audioData[i * channelCount_];
+    auto output =
+        static_cast<float>(b0 * input + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2);
+
+    for (int j = 0; j < channelCount_; j++) {
+      audioData[i * channelCount_ + j] = output;
+    }
+
+    x2 = x1;
+    x1 = input;
+    y2 = y1;
+    y1 = output;
+  }
+
+  return true;
+}
+} // namespace audioapi