react-native-audio-api 0.6.0-rc.4 → 0.6.0

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -5,6 +5,7 @@
 #include <audioapi/dsp/Windows.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
 
 namespace audioapi {
 AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
@@ -13,9 +14,9 @@ AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
       minDecibels_(-100),
       maxDecibels_(-30),
       smoothingTimeConstant_(0.8),
-      windowType_(WindowType::BLACKMAN),
-      vWriteIndex_(0) {
-  inputBuffer_ = std::make_unique<AudioArray>(MAX_FFT_SIZE * 2);
+      windowType_(WindowType::BLACKMAN) {
+  inputBuffer_ = std::make_unique<CircularAudioArray>(MAX_FFT_SIZE * 2);
+  tempBuffer_ = std::make_unique<AudioArray>(fftSize_);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
   downMixBus_ = std::make_unique<AudioBus>(
       RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
@@ -61,6 +62,7 @@ void AnalyserNode::setFftSize(int fftSize) {
   fft_ = std::make_unique<dsp::FFT>(fftSize_);
   complexData_ = std::vector<std::complex<float>>(fftSize_);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
+  tempBuffer_ = std::make_unique<AudioArray>(fftSize_);
   setWindowData(windowType_, fftSize_);
 }
 
@@ -116,21 +118,17 @@ void AnalyserNode::getByteFrequencyData(uint8_t *data, int length) {
 
 void AnalyserNode::getFloatTimeDomainData(float *data, int length) {
   auto size = std::min(fftSize_, length);
-
-  for (int i = 0; i < size; i++) {
-    data[i] = inputBuffer_->getData()
-                  [(vWriteIndex_ + i - fftSize_ + inputBuffer_->getSize()) %
-                   inputBuffer_->getSize()];
-  }
+  inputBuffer_->pop_back(data, size, std::max(0, fftSize_ - size), true);
 }
 
 void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
   auto size = std::min(fftSize_, length);
 
+  inputBuffer_->pop_back(
+      tempBuffer_->getData(), fftSize_, std::max(0, fftSize_ - size), true);
+
   for (int i = 0; i < size; i++) {
-    auto value = inputBuffer_->getData()
-                     [(vWriteIndex_ + i - fftSize_ + inputBuffer_->getSize()) %
-                      inputBuffer_->getSize()];
+    auto value = tempBuffer_->getData()[i];
 
     float scaledValue = 128 * (value + 1);
 
@@ -153,29 +151,9 @@ void AnalyserNode::processNode(
 
   // Down mix the input bus to mono
   downMixBus_->copy(processingBus.get());
-
-  auto framesToCopy = 0;
-
-  if (vWriteIndex_ + framesToProcess > inputBuffer_->getSize()) {
-    framesToCopy = static_cast<int>(inputBuffer_->getSize()) - vWriteIndex_;
-    memcpy(
-        inputBuffer_->getData() + vWriteIndex_,
-        downMixBus_->getChannel(0)->getData(),
-        framesToCopy * sizeof(float));
-
-    vWriteIndex_ = 0;
-    framesToProcess -= framesToCopy;
-  }
-
-  memcpy(
-      inputBuffer_->getData() + vWriteIndex_,
-      downMixBus_->getChannel(0)->getData() + framesToCopy,
-      framesToProcess * sizeof(float));
-
-  vWriteIndex_ += framesToProcess;
-  if (vWriteIndex_ >= inputBuffer_->getSize()) {
-    vWriteIndex_ = 0;
-  }
+  // Copy the down mixed bus to the input buffer (circular buffer)
+  inputBuffer_->push_back(
+      downMixBus_->getChannel(0)->getData(), framesToProcess, true);
 
   shouldDoFFTAnalysis_ = true;
 }
@@ -187,33 +165,18 @@ void AnalyserNode::doFFTAnalysis() {
 
   shouldDoFFTAnalysis_ = false;
 
-  // We need to copy the fftSize elements from input buffer to a temporary
-  // buffer to apply the window.
-  AudioArray tempBuffer(this->fftSize_);
-
-  // We want to copy last fftSize_ elements added to the input buffer(fftSize_
-  // elements before vWriteIndex_). However inputBuffer_ works like a circular
-  // buffer so we have two cases to consider.
-  if (vWriteIndex_ < fftSize_) {
-    tempBuffer.copy(
-        inputBuffer_.get(),
-        vWriteIndex_ - fftSize_ + inputBuffer_->getSize(),
-        0,
-        fftSize_ - vWriteIndex_);
-    tempBuffer.copy(
-        inputBuffer_.get(), 0, fftSize_ - vWriteIndex_, vWriteIndex_);
-  } else {
-    tempBuffer.copy(inputBuffer_.get(), vWriteIndex_ - fftSize_, 0, fftSize_);
-  }
+  // We want to copy last fftSize_ elements added to the input buffer to apply
+  // the window.
+  inputBuffer_->pop_back(tempBuffer_->getData(), fftSize_, 0, true);
 
   dsp::multiply(
-      tempBuffer.getData(),
+      tempBuffer_->getData(),
       windowData_->getData(),
-      tempBuffer.getData(),
+      tempBuffer_->getData(),
       fftSize_);
 
   // do fft analysis - get frequency domain data
-  fft_->doFFT(tempBuffer.getData(), complexData_);
+  fft_->doFFT(tempBuffer_->getData(), complexData_);
 
   // Zero out nquist component
   complexData_[0] = std::complex<float>(complexData_[0].real(), 0);

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -13,6 +13,7 @@ namespace audioapi {
 
 class AudioBus;
 class AudioArray;
+class CircularAudioArray;
 
 class AnalyserNode : public AudioNode {
  public:
@@ -49,9 +50,9 @@ class AnalyserNode : public AudioNode {
   WindowType windowType_;
   std::shared_ptr<AudioArray> windowData_;
 
-  std::unique_ptr<AudioArray> inputBuffer_;
+  std::unique_ptr<CircularAudioArray> inputBuffer_;
   std::unique_ptr<AudioBus> downMixBus_;
-  int vWriteIndex_;
+  std::unique_ptr<AudioArray> tempBuffer_;
 
   std::unique_ptr<dsp::FFT> fft_;
   std::vector<std::complex<float>> complexData_;

package/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp

@@ -10,16 +10,20 @@ namespace audioapi {
 
 BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
     : AudioNode(context) {
-  frequencyParam_ =
-      std::make_shared<AudioParam>(350.0, 0.0f, context->getNyquistFrequency());
+  frequencyParam_ = std::make_shared<AudioParam>(
+      350.0, 0.0f, context->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
       0.0,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT);
+      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+      context);
   QParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   gainParam_ = std::make_shared<AudioParam>(
-      0.0, MOST_NEGATIVE_SINGLE_FLOAT, 40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT);
+      0.0,
+      MOST_NEGATIVE_SINGLE_FLOAT,
+      40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT,
+      context);
   type_ = BiquadFilterType::LOWPASS;
   isInitialized_ = true;
 }
@@ -304,48 +308,46 @@ void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
 void BiquadFilterNode::applyFilter() {
   double currentTime = context_->getCurrentTime();
 
-  float normalizedFrequency = frequencyParam_->getValueAtTime(currentTime) /
-      context_->getNyquistFrequency();
-  float detuneValue = detuneParam_->getValueAtTime(currentTime);
+  float frequencyParamValue =
+      frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  float normalizedFrequency =
+      frequencyParamValue / context_->getNyquistFrequency();
+
+  float detuneValue =
+      detuneParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
 
   if (detuneValue != 0.0) {
     normalizedFrequency *= std::pow(2.0f, detuneValue / 1200.0f);
   }
 
+  auto qparamValue =
+      QParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  auto gainParamValue =
+      gainParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
   switch (type_) {
     case BiquadFilterType::LOWPASS:
-      setLowpassCoefficients(
-          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      setLowpassCoefficients(normalizedFrequency, qparamValue);
       break;
     case BiquadFilterType::HIGHPASS:
-      setHighpassCoefficients(
-          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      setHighpassCoefficients(normalizedFrequency, qparamValue);
       break;
     case BiquadFilterType::BANDPASS:
-      setBandpassCoefficients(
-          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      setBandpassCoefficients(normalizedFrequency, qparamValue);
       break;
     case BiquadFilterType::LOWSHELF:
-      setLowshelfCoefficients(
-          normalizedFrequency, gainParam_->getValueAtTime(currentTime));
+      setLowshelfCoefficients(normalizedFrequency, gainParamValue);
       break;
     case BiquadFilterType::HIGHSHELF:
-      setHighshelfCoefficients(
-          normalizedFrequency, gainParam_->getValueAtTime(currentTime));
+      setHighshelfCoefficients(normalizedFrequency, gainParamValue);
       break;
     case BiquadFilterType::PEAKING:
-      setPeakingCoefficients(
-          normalizedFrequency,
-          QParam_->getValueAtTime(currentTime),
-          gainParam_->getValueAtTime(currentTime));
+      setPeakingCoefficients(normalizedFrequency, qparamValue, gainParamValue);
       break;
     case BiquadFilterType::NOTCH:
-      setNotchCoefficients(
-          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      setNotchCoefficients(normalizedFrequency, qparamValue);
       break;
     case BiquadFilterType::ALLPASS:
-      setAllpassCoefficients(
-          normalizedFrequency, QParam_->getValueAtTime(currentTime));
+      setAllpassCoefficients(normalizedFrequency, qparamValue);
       break;
     default:
       break;

package/common/cpp/audioapi/core/effects/GainNode.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/GainNode.h>
+#include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
@@ -7,7 +8,7 @@ namespace audioapi {
 
 GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
   gainParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   isInitialized_ = true;
 }
 
@@ -19,14 +20,13 @@ void GainNode::processNode(
     const std::shared_ptr<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;
+  auto gainParamValues = gainParam_->processARateParam(framesToProcess, time);
+  for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
+    dsp::multiply(
+        processingBus->getChannel(i)->getData(),
+        gainParamValues->getChannel(0)->getData(),
+        processingBus->getChannel(i)->getData(),
+        framesToProcess);
   }
 }
 

package/common/cpp/audioapi/core/effects/StereoPannerNode.cpp

@@ -11,7 +11,7 @@ namespace audioapi {
 StereoPannerNode::StereoPannerNode(BaseAudioContext *context)
     : AudioNode(context) {
   channelCountMode_ = ChannelCountMode::EXPLICIT;
-  panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f);
+  panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context);
   isInitialized_ = true;
 }
 
@@ -27,9 +27,12 @@ void StereoPannerNode::processNode(
 
   AudioArray *left = processingBus->getChannelByType(AudioBus::ChannelLeft);
   AudioArray *right = processingBus->getChannelByType(AudioBus::ChannelRight);
+  auto panParamValues = panParam_->processARateParam(framesToProcess, time)
+                            ->getChannel(0)
+                            ->getData();
 
   for (int i = 0; i < framesToProcess; i += 1) {
-    auto pan = panParam_->getValueAtTime(time);
+    auto pan = panParamValues[i];
 
     auto x = (pan <= 0 ? pan + 1 : pan);
 

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -0,0 +1,56 @@
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+
+namespace audioapi {
+
+AudioRecorder::AudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  circularBuffer_ =
+      std::make_shared<CircularAudioArray>(std::max(2 * bufferLength, 2048));
+  isRunning_.store(false);
+}
+
+void AudioRecorder::setOnAudioReadyCallbackId(uint64_t callbackId) {
+  onAudioReadyCallbackId_ = callbackId;
+}
+
+void AudioRecorder::invokeOnAudioReadyCallback(
+    const std::shared_ptr<AudioBus> &bus,
+    int numFrames,
+    double when) {
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject =
+      std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> body = {};
+  body.insert({"buffer", audioBufferHostObject});
+  body.insert({"numFrames", numFrames});
+  body.insert({"when", when});
+
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+      "audioReady", onAudioReadyCallbackId_, body);
+}
+
+void AudioRecorder::sendRemainingData() {
+  auto bus = std::make_shared<AudioBus>(
+      circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
+  auto *outputChannel = bus->getChannel(0)->getData();
+  auto availableFrames =
+      static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
+
+  circularBuffer_->pop_front(
+      outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+
+  invokeOnAudioReadyCallback(bus, availableFrames, 0);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,28 +1,26 @@
 #pragma once
 
 #include <memory>
-#include <functional>
 
 namespace audioapi {
 class AudioBus;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
   explicit AudioRecorder(
     float sampleRate,
     int bufferLength,
-    const std::function<void(void)> &onError,
-    const std::function<void(void)> &onStatusChange,
-    const std::function<void(std::shared_ptr<AudioBus>, int, double)> &onAudioReady
-  )
-    : sampleRate_(sampleRate),
-      bufferLength_(bufferLength),
-      onError_(onError),
-      onStatusChange_(onStatusChange),
-      onAudioReady_(onAudioReady) {}
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
+  );
 
   virtual ~AudioRecorder() = default;
 
+  void setOnAudioReadyCallbackId(uint64_t callbackId);
+  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames, double when);
+  void sendRemainingData();
+
   virtual void start() = 0;
   virtual void stop() = 0;
 
@@ -30,9 +28,11 @@ class AudioRecorder {
   float sampleRate_;
   int bufferLength_;
 
-  std::function<void(void)> onError_;
-  std::function<void(void)> onStatusChange_;
-  std::function<void(std::shared_ptr<AudioBus>, int, double)> onAudioReady_;
+  std::atomic<bool> isRunning_;
+  std::shared_ptr<CircularAudioArray> circularBuffer_;
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  uint64_t onAudioReadyCallbackId_ = 0;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -22,9 +22,9 @@ AudioBufferSourceNode::AudioBufferSourceNode(
   alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
 
   detuneParam_ = std::make_shared<AudioParam>(
-      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   playbackRateParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
 
   playbackRateBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
@@ -173,7 +173,7 @@ void AudioBufferSourceNode::processWithoutPitchCorrection(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  auto computedPlaybackRate = getComputedPlaybackRateValue();
+  auto computedPlaybackRate = getComputedPlaybackRateValue(framesToProcess);
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
 
   if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
@@ -197,10 +197,12 @@ void AudioBufferSourceNode::processWithPitchCorrection(
   size_t offsetLength = 0;
 
   auto time = context_->getCurrentTime();
-  auto playbackRate =
-      std::clamp(playbackRateParam_->getValueAtTime(time), 0.0f, 3.0f);
-  auto detune =
-      std::clamp(detuneParam_->getValueAtTime(time) / 100.0f, -12.0f, 12.0f);
+  auto playbackRate = std::clamp(
+      playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
+  auto detune = std::clamp(
+      detuneParam_->processKRateParam(framesToProcess, time) / 100.0f,
+      -12.0f,
+      12.0f);
 
   playbackRateBus_->zero();
 
@@ -349,13 +351,15 @@ void AudioBufferSourceNode::processWithInterpolation(
   }
 }
 
-float AudioBufferSourceNode::getComputedPlaybackRateValue() {
+float AudioBufferSourceNode::getComputedPlaybackRateValue(int framesToProcess) {
   auto time = context_->getCurrentTime();
 
   auto sampleRateFactor =
       alignedBus_->getSampleRate() / context_->getSampleRate();
-  auto playbackRate = playbackRateParam_->getValueAtTime(time);
-  auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+  auto playbackRate =
+      playbackRateParam_->processKRateParam(framesToProcess, time);
+  auto detune = std::pow(
+      2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
 
   return playbackRate * sampleRateFactor * detune;
 }

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h

@@ -81,7 +81,7 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
       size_t offsetLength,
       float playbackRate);
 
-  float getComputedPlaybackRateValue();
+  float getComputedPlaybackRateValue(int framesToProcess);
 
   double getVirtualStartFrame();
   double getVirtualEndFrame();

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -2,6 +2,7 @@
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
@@ -44,9 +45,8 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
-void AudioScheduledSourceNode::setOnendedCallback(
-    const std::function<void(double)> &onendedCallback) {
-  onendedCallback_ = onendedCallback;
+void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
+  onEndedCallbackId_ = callbackId;
 }
 
 void AudioScheduledSourceNode::updatePlaybackInfo(
@@ -144,9 +144,10 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  if (onendedCallback_) {
-    onendedCallback_(getStopTime());
-  }
+  std::unordered_map<std::string, EventValue> body = {{"value", getStopTime()}};
+
+  context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+      "ended", onEndedCallbackId_, body);
 }
 
 void AudioScheduledSourceNode::handleStopScheduled() {

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -16,6 +16,8 @@
 
 namespace audioapi {
 
+class AudioEventHandlerRegistry;
+
 class AudioScheduledSourceNode : public AudioNode {
  public:
   // UNSCHEDULED: The node is not scheduled to play.
@@ -35,7 +37,7 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
-  void setOnendedCallback(const std::function<void(double)> &onendedCallback);
+  void setOnEndedCallbackId(uint64_t callbackId);
 
   virtual double getStopTime() const = 0;
   void disable() override;
@@ -43,8 +45,6 @@ class AudioScheduledSourceNode : public AudioNode {
  protected:
   PlaybackState playbackState_;
 
-  std::function<void(double)> onendedCallback_;
-
   void updatePlaybackInfo(
       const std::shared_ptr<AudioBus>& processingBus,
       int framesToProcess,
@@ -56,6 +56,8 @@ class AudioScheduledSourceNode : public AudioNode {
  private:
   double startTime_;
   double stopTime_;
+
+  uint64_t onEndedCallbackId_ = 0;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/OscillatorNode.cpp

@@ -9,11 +9,15 @@ namespace audioapi {
 OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency());
+      444.0,
+      -context_->getNyquistFrequency(),
+      context_->getNyquistFrequency(),
+      context);
   detuneParam_ = std::make_shared<AudioParam>(
       0.0,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT);
+      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+      context);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
@@ -56,15 +60,18 @@ void OscillatorNode::processNode(
     return;
   }
 
-  auto deltaTime = 1.0 / context_->getSampleRate();
-  auto time =
-      context_->getCurrentTime() + static_cast<double>(startOffset) * deltaTime;
+  auto time = context_->getCurrentTime() +
+      static_cast<double>(startOffset) * 1.0 / context_->getSampleRate();
+  auto detuneParamValues =
+      detuneParam_->processARateParam(framesToProcess, time);
+  auto frequencyParamValues =
+      frequencyParam_->processARateParam(framesToProcess, time);
 
   for (size_t i = startOffset; i < offsetLength; i += 1) {
-    auto detuneRatio =
-        std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+    auto detuneRatio = std::pow(
+        2.0f, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
     auto detunedFrequency =
-        round(frequencyParam_->getValueAtTime(time) * detuneRatio);
+        frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
     auto phaseIncrement = detunedFrequency * periodicWave_->getScale();
 
     float sample =
@@ -79,8 +86,6 @@ void OscillatorNode::processNode(
         floor(
             phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
         static_cast<float>(periodicWave_->getPeriodicWaveSize());
-
-    time += deltaTime;
   }
 
   handleStopScheduled();

package/common/cpp/audioapi/core/utils/AudioNodeManager.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Locker.h>
@@ -9,7 +10,7 @@ AudioNodeManager::~AudioNodeManager() {
   cleanup();
 }
 
-void AudioNodeManager::addPendingConnection(
+void AudioNodeManager::addPendingNodeConnection(
     const std::shared_ptr<AudioNode> &from,
     const std::shared_ptr<AudioNode> &to,
     ConnectionType type) {
@@ -18,6 +19,15 @@ void AudioNodeManager::addPendingConnection(
   audioNodesToConnect_.emplace_back(from, to, type);
 }
 
+void AudioNodeManager::addPendingParamConnection(
+    const std::shared_ptr<AudioNode> &from,
+    const std::shared_ptr<AudioParam> &to,
+    ConnectionType type) {
+  Locker lock(getGraphLock());
+
+  audioParamToConnect_.emplace_back(from, to, type);
+}
+
 void AudioNodeManager::preProcessGraph() {
   if (auto locker = Locker::tryLock(getGraphLock())) {
     settlePendingConnections();
@@ -41,6 +51,11 @@ void AudioNodeManager::addSourceNode(
   sourceNodes_.insert(node);
 }
 
+void AudioNodeManager::addAudioParam(const std::shared_ptr<AudioParam> &param) {
+  Locker lock(getGraphLock());
+  audioParams_.insert(param);
+}
+
 void AudioNodeManager::settlePendingConnections() {
   for (auto it = audioNodesToConnect_.begin(), end = audioNodesToConnect_.end();
        it != end;
@@ -60,6 +75,25 @@ void AudioNodeManager::settlePendingConnections() {
   }
 
   audioNodesToConnect_.clear();
+
+  for (auto it = audioParamToConnect_.begin(), end = audioParamToConnect_.end();
+       it != end;
+       ++it) {
+    std::shared_ptr<AudioNode> from = std::get<0>(*it);
+    std::shared_ptr<AudioParam> to = std::get<1>(*it);
+    ConnectionType type = std::get<2>(*it);
+
+    assert(from != nullptr);
+    assert(to != nullptr);
+
+    if (type == ConnectionType::CONNECT) {
+      from->connectParam(to);
+    } else {
+      from->disconnectParam(to);
+    }
+  }
+
+  audioParamToConnect_.clear();
 }
 
 void AudioNodeManager::cleanupNode(const std::shared_ptr<AudioNode> &node) {