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

package/common/cpp/audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h

@@ -12,9 +12,8 @@ using namespace facebook;
 class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AudioScheduledSourceNodeHostObject(
-      const std::shared_ptr<AudioScheduledSourceNode> &node,
-      const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : AudioNodeHostObject(node), callInvoker_(callInvoker) {
+      const std::shared_ptr<AudioScheduledSourceNode> &node)
+      : AudioNodeHostObject(node) {
     addSetters(
       JSI_EXPORT_PROPERTY_SETTER(AudioScheduledSourceNodeHostObject, onended));
     addFunctions(
@@ -22,27 +21,11 @@ class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
         JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, stop));
   }
 
-  ~AudioScheduledSourceNodeHostObject() override {
-    // https://github.com/software-mansion/react-native-reanimated/blob/2b669b069bd70ba876d97a9e19daa509808a1b3a/packages/react-native-worklets/Common/cpp/worklets/SharedItems/Shareables.h#L39-L63
-    auto audioScheduleSourceNode =
-            std::static_pointer_cast<AudioScheduledSourceNode>(node_);
-    audioScheduleSourceNode->setOnendedCallback(nullptr);
-
-    onendedCallback_ = nullptr;
-  }
-
   JSI_PROPERTY_SETTER(onended) {
-      onendedCallback_ = std::make_unique<jsi::Function>(value.getObject(runtime).getFunction(runtime));
     auto audioScheduleSourceNode =
             std::static_pointer_cast<AudioScheduledSourceNode>(node_);
 
-    auto lambda = [this, &runtime](double stopTime) {
-        callInvoker_->invokeAsync([this, &runtime, stopTime] () {
-            onendedCallback_->call(runtime, stopTime);
-        });
-    };
-
-    audioScheduleSourceNode->setOnendedCallback(lambda);
+    audioScheduleSourceNode->setOnEndedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
   }
 
   JSI_HOST_FUNCTION(start) {
@@ -60,9 +43,5 @@ class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
     audioScheduleSourceNode->stop(time);
     return jsi::Value::undefined();
   }
-
- private:
-    std::shared_ptr<react::CallInvoker> callInvoker_;
-    std::unique_ptr<jsi::Function> onendedCallback_;
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h

@@ -71,7 +71,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION(createOscillator) {
     auto oscillator = context_->createOscillator();
     auto oscillatorHostObject =
-        std::make_shared<OscillatorNodeHostObject>(oscillator, callInvoker_);
+        std::make_shared<OscillatorNodeHostObject>(oscillator);
     return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
   }
 
@@ -99,7 +99,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
     auto pitchCorrection = args[0].asBool();
     auto bufferSource = context_->createBufferSource(pitchCorrection);
     auto bufferSourceHostObject =
-        std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource, callInvoker_);
+        std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
     return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
   }
 

package/common/cpp/audioapi/HostObjects/OscillatorNodeHostObject.h

@@ -15,9 +15,8 @@ using namespace facebook;
 class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
   explicit OscillatorNodeHostObject(
-          const std::shared_ptr<OscillatorNode> &node,
-          const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : AudioScheduledSourceNodeHostObject(node, callInvoker) {
+          const std::shared_ptr<OscillatorNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
     addGetters(
         JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
         JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, detune),

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -10,7 +10,10 @@
 #include <audioapi/core/utils/AudioNodeManager.h>
 
 namespace audioapi {
-AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
+AudioContext::AudioContext(
+    float sampleRate,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry) {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio(), sampleRate);
 #else

package/common/cpp/audioapi/core/AudioContext.h

@@ -14,7 +14,7 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  explicit AudioContext(float sampleRate);
+  explicit AudioContext(float sampleRate, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~AudioContext() override;
 
   void close();

package/common/cpp/audioapi/core/AudioNode.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/utils/AudioArray.h>
@@ -38,10 +39,15 @@ std::string AudioNode::getChannelInterpretation() const {
 }
 
 void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingConnection(
+  context_->getNodeManager()->addPendingNodeConnection(
       shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
 }
 
+void AudioNode::connect(const std::shared_ptr<AudioParam> &param) {
+  context_->getNodeManager()->addPendingParamConnection(
+      shared_from_this(), param, AudioNodeManager::ConnectionType::CONNECT);
+}
+
 void AudioNode::disconnect() {
   for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
        ++it) {
@@ -50,10 +56,15 @@ void AudioNode::disconnect() {
 }
 
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingConnection(
+  context_->getNodeManager()->addPendingNodeConnection(
       shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
 }
 
+void AudioNode::disconnect(const std::shared_ptr<AudioParam> &param) {
+  context_->getNodeManager()->addPendingParamConnection(
+      shared_from_this(), param, AudioNodeManager::ConnectionType::DISCONNECT);
+}
+
 bool AudioNode::isEnabled() const {
   return isEnabled_;
 }
@@ -221,6 +232,15 @@ void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
   }
 }
 
+void AudioNode::connectParam(const std::shared_ptr<AudioParam> &param) {
+  auto position = outputParams_.find(param);
+
+  if (position == outputParams_.end()) {
+    outputParams_.insert(param);
+    param->addInputNode(this);
+  }
+}
+
 void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
   auto position = outputNodes_.find(node);
 
@@ -230,6 +250,15 @@ void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
   }
 }
 
+void AudioNode::disconnectParam(const std::shared_ptr<AudioParam> &param) {
+  auto position = outputParams_.find(param);
+
+  if (position != outputParams_.end()) {
+    param->removeInputNode(this);
+    outputParams_.erase(param);
+  }
+}
+
 void AudioNode::onInputEnabled() {
   numberOfEnabledInputNodes_ += 1;
 

package/common/cpp/audioapi/core/AudioNode.h

@@ -15,6 +15,7 @@ namespace audioapi {
 
 class AudioBus;
 class BaseAudioContext;
+class AudioParam;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
@@ -27,8 +28,11 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   std::string getChannelCountMode() const;
   std::string getChannelInterpretation() const;
   void connect(const std::shared_ptr<AudioNode> &node);
+  void connect(const std::shared_ptr<AudioParam> &param);
   void disconnect();
   void disconnect(const std::shared_ptr<AudioNode> &node);
+  void disconnect(const std::shared_ptr<AudioParam> &param);
+  virtual std::shared_ptr<AudioBus> processAudio(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
 
   bool isEnabled() const;
   void enable();
@@ -50,6 +54,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
 
   std::unordered_set<AudioNode *> inputNodes_ = {};
   std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
+  std::unordered_set<std::shared_ptr<AudioParam>> outputParams_ = {};
 
   int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;
@@ -63,7 +68,6 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
 
-  virtual std::shared_ptr<AudioBus> processAudio(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   virtual void processNode(const std::shared_ptr<AudioBus>&, int) = 0;
 
   bool isAlreadyProcessed();
@@ -73,6 +77,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
 
   void connectNode(const std::shared_ptr<AudioNode> &node);
   void disconnectNode(const std::shared_ptr<AudioNode> &node);
+  void connectParam(const std::shared_ptr<AudioParam> &param);
+  void disconnectParam(const std::shared_ptr<AudioParam> &param);
 
   void onInputEnabled();
   void onInputDisabled();

package/common/cpp/audioapi/core/AudioParam.cpp

@@ -1,14 +1,27 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <iostream>
 
 namespace audioapi {
 
-AudioParam::AudioParam(float defaultValue, float minValue, float maxValue)
+AudioParam::AudioParam(
+    float defaultValue,
+    float minValue,
+    float maxValue,
+    BaseAudioContext *context)
     : value_(defaultValue),
       defaultValue_(defaultValue),
       minValue_(minValue),
-      maxValue_(maxValue) {
+      maxValue_(maxValue),
+      context_(context),
+      audioBus_(
+          std::make_shared<AudioBus>(
+              RENDER_QUANTUM_SIZE,
+              1,
+              context->getSampleRate())) {
   startTime_ = 0;
   endTime_ = 0;
   startValue_ = value_;
@@ -256,6 +269,44 @@ void AudioParam::cancelAndHoldAtTime(double cancelTime) {
   }
 }
 
+void AudioParam::addInputNode(AudioNode *node) {
+  auto position = inputNodes_.find(node);
+  if (position == inputNodes_.end()) {
+    inputNodes_.insert(node);
+  }
+}
+
+void AudioParam::removeInputNode(AudioNode *node) {
+  auto position = inputNodes_.find(node);
+
+  if (position != inputNodes_.end()) {
+    inputNodes_.erase(position);
+  }
+}
+
+std::shared_ptr<AudioBus> AudioParam::processARateParam(
+    int framesToProcess,
+    double time) {
+  auto processingBus = audioBus_;
+  processingBus->zero();
+  if (!inputNodes_.empty()) {
+    processInputs(processingBus, framesToProcess, true);
+    mixInputsBuses(processingBus);
+  }
+  for (size_t i = 0; i < framesToProcess; i++) {
+    auto sample = getValueAtTime(time + i / context_->getSampleRate());
+    processingBus->getChannel(0)->getData()[i] += sample;
+  }
+  // processingBus is a mono bus
+  return processingBus;
+}
+
+float AudioParam::processKRateParam(int framesToProcess, double time) {
+  auto processingBus = processARateParam(framesToProcess, time);
+  // processingBus is a mono bus
+  return processingBus->getChannel(0)->getData()[0];
+}
+
 double AudioParam::getQueueEndTime() {
   if (eventsQueue_.empty()) {
     return endTime_;
@@ -292,4 +343,35 @@ void AudioParam::updateQueue(ParamChangeEvent &event) {
   eventsQueue_.push_back(event);
 }
 
+void AudioParam::processInputs(
+    const std::shared_ptr<AudioBus> &outputBus,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
+       ++it) {
+    auto inputNode = *it;
+    assert(inputNode != nullptr);
+
+    if (!inputNode->isEnabled()) {
+      continue;
+    }
+
+    auto inputBus = inputNode->processAudio(
+        outputBus, framesToProcess, checkIsAlreadyProcessed);
+    inputBuses_.push_back(inputBus);
+  }
+}
+
+void AudioParam::mixInputsBuses(
+    const std::shared_ptr<AudioBus> &processingBus) {
+  assert(processingBus != nullptr);
+
+  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end;
+       ++it) {
+    processingBus->sum(it->get(), ChannelInterpretation::SPEAKERS);
+  }
+
+  inputBuses_.clear();
+}
+
 } // namespace audioapi

package/common/cpp/audioapi/core/AudioParam.h

@@ -2,17 +2,20 @@
 
 #include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/AudioNode.h>
 
 #include <deque>
 #include <memory>
 #include <vector>
+#include <unordered_set>
 #include <cstddef>
 
 namespace audioapi {
 
 class AudioParam {
  public:
-  explicit AudioParam(float defaultValue, float minValue, float maxValue);
+  explicit AudioParam(float defaultValue, float minValue, float maxValue, BaseAudioContext *context);
 
   [[nodiscard]] float getValue() const;
   float getValueAtTime(double time);
@@ -33,23 +36,33 @@ class AudioParam {
       double duration);
   void cancelScheduledValues(double cancelTime);
   void cancelAndHoldAtTime(double cancelTime);
+  void addInputNode(AudioNode* node);
+  void removeInputNode(AudioNode* node);
+  std::shared_ptr<AudioBus> processARateParam(int framesToProcess, double time);
+  float processKRateParam(int framesToProcess, double time);
 
  private:
   float value_;
   float defaultValue_;
   float minValue_;
   float maxValue_;
+  BaseAudioContext *context_;
   std::deque<ParamChangeEvent> eventsQueue_;
+  std::unordered_set<AudioNode *> inputNodes_;
+  std::shared_ptr<AudioBus> audioBus_;
 
   double startTime_;
   double endTime_;
   float startValue_;
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
+  std::vector<std::shared_ptr<AudioBus>> inputBuses_ = {};
 
   double getQueueEndTime();
   float getQueueEndValue();
   void updateQueue(ParamChangeEvent &event);
+  void processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
+  void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -9,15 +9,20 @@
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
 
 namespace audioapi {
 
-BaseAudioContext::BaseAudioContext() {
+BaseAudioContext::BaseAudioContext(
+    const std::shared_ptr<AudioEventHandlerRegistry>
+        &audioEventHandlerRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
+
+  audioEventHandlerRegistry_ = audioEventHandlerRegistry;
 }
 
 std::string BaseAudioContext::getState() {

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -26,10 +26,11 @@ class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioDecoder;
 class AnalyserNode;
+class AudioEventHandlerRegistry;
 
 class BaseAudioContext {
  public:
-  BaseAudioContext();
+  explicit BaseAudioContext(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -77,6 +78,11 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedSquareWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
+
+ protected:
+    friend class AudioScheduledSourceNode;
+
+    std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -21,8 +21,9 @@ namespace audioapi {
 OfflineAudioContext::OfflineAudioContext(
     int numberOfChannels,
     size_t length,
-    float sampleRate)
-    : BaseAudioContext(),
+    float sampleRate,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {

package/common/cpp/audioapi/core/OfflineAudioContext.h

@@ -14,7 +14,7 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate);
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~OfflineAudioContext() override;
 
   void resume();

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