react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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

@@ -7,12 +7,12 @@
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+#include <memory>
 
 namespace audioapi {
 
-AudioBufferSourceNode::AudioBufferSourceNode(
-    BaseAudioContext *context,
-    bool pitchCorrection)
+AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context, bool pitchCorrection)
     : AudioBufferBaseSourceNode(context, pitchCorrection),
       loop_(false),
       loopSkip_(false),
@@ -70,8 +70,7 @@ void AudioBufferSourceNode::setLoopEnd(double loopEnd) {
   loopEnd_ = loopEnd;
 }
 
-void AudioBufferSourceNode::setBuffer(
-    const std::shared_ptr<AudioBuffer> &buffer) {
+void AudioBufferSourceNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
   Locker locker(getBufferLock());
 
   if (!buffer) {
@@ -82,17 +81,29 @@ void AudioBufferSourceNode::setBuffer(
   }
 
   buffer_ = buffer;
-  alignedBus_ = std::make_shared<AudioBus>(*buffer_->bus_);
   channelCount_ = buffer_->getNumberOfChannels();
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+  stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
 
-  loopEnd_ = buffer_->getDuration();
+  if (pitchCorrection_) {
+    int extraTailFrames =
+        static_cast<int>((getInputLatency() + getOutputLatency()) * context_->getSampleRate());
+    size_t totalSize = buffer_->getLength() + extraTailFrames;
 
-  stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
+    alignedBus_ = std::make_shared<AudioBus>(totalSize, channelCount_, buffer_->getSampleRate());
+    alignedBus_->copy(buffer_->bus_.get(), 0, 0, buffer_->getLength());
+
+    alignedBus_->zero(buffer_->getLength(), extraTailFrames);
+  } else {
+    alignedBus_ = std::make_shared<AudioBus>(*buffer_->bus_);
+  }
+
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+  playbackRateBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+
+  loopEnd_ = buffer_->getDuration();
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
@@ -106,10 +117,8 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
     return;
   }
 
-  offset = std::min(
-      offset,
-      static_cast<double>(alignedBus_->getSize()) /
-          alignedBus_->getSampleRate());
+  offset =
+      std::min(offset, static_cast<double>(alignedBus_->getSize()) / alignedBus_->getSampleRate());
 
   if (loop_) {
     offset = std::min(offset, loopEnd_);
@@ -123,19 +132,12 @@ void AudioBufferSourceNode::disable() {
   alignedBus_.reset();
 }
 
-void AudioBufferSourceNode::clearOnLoopEndedCallback() {
-  if (onLoopEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "loopEnded", onLoopEndedCallbackId_);
-  onLoopEndedCallbackId_ = 0;
-}
-
 void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
-  onLoopEndedCallbackId_ = callbackId;
+  auto oldCallbackId = onLoopEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("loopEnded", oldCallbackId);
+  }
 }
 
 std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
@@ -163,16 +165,13 @@ std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
 }
 
 double AudioBufferSourceNode::getCurrentPosition() const {
-  return dsp::sampleFrameToTime(
-      static_cast<int>(vReadIndex_), buffer_->getSampleRate());
+  return dsp::sampleFrameToTime(static_cast<int>(vReadIndex_), buffer_->getSampleRate());
 }
 
 void AudioBufferSourceNode::sendOnLoopEndedEvent() {
-  auto onLoopEndedCallbackId =
-      onLoopEndedCallbackId_.load(std::memory_order_acquire);
+  auto onLoopEndedCallbackId = onLoopEndedCallbackId_.load(std::memory_order_acquire);
   if (onLoopEndedCallbackId != 0) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "loopEnded", onLoopEndedCallbackId_, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("loopEnded", onLoopEndedCallbackId, {});
   }
 }
 
@@ -199,10 +198,9 @@ void AudioBufferSourceNode::processWithoutInterpolation(
   // if we are moving towards loop, we do nothing because we will achieve it
   // otherwise, we wrap to the start of the loop if necessary
   if (loop_ &&
-      ((readIndex >= frameEnd && direction == 1) ||
-       (readIndex < frameStart && direction == -1))) {
+      ((readIndex >= frameEnd && direction == 1) || (readIndex < frameStart && direction == -1))) {
     readIndex = frameStart +
-        ((long long int)readIndex - (long long int)frameStart) % frameDelta;
+        (static_cast<int64_t>(readIndex) - static_cast<int64_t>(frameStart)) % frameDelta;
   }
 
   while (framesLeft > 0) {
@@ -217,8 +215,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
 
     // Direction is forward, we can normally copy the data
     if (direction == 1) {
-      processingBus->copy(
-          alignedBus_.get(), readIndex, writeIndex, framesToCopy);
+      processingBus->copy(alignedBus_.get(), readIndex, writeIndex, framesToCopy);
     } else {
       for (int i = 0; i < framesToCopy; i += 1) {
         for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
@@ -234,8 +231,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
 
     // if we are moving towards loop, we do nothing because we will achieve it
     // otherwise, we wrap to the start of the loop if necessary
-    if ((readIndex >= frameEnd && direction == 1) ||
-        (readIndex < frameStart && direction == -1)) {
+    if ((readIndex >= frameEnd && direction == 1) || (readIndex < frameStart && direction == -1)) {
       readIndex -= direction * frameDelta;
 
       if (!loop_) {
@@ -272,15 +268,13 @@ void AudioBufferSourceNode::processWithInterpolation(
 
   // Wrap to the start of the loop if necessary
   if (loop_ && (vReadIndex_ >= vFrameEnd || vReadIndex_ < vFrameStart)) {
-    vReadIndex_ =
-        vFrameStart + std::fmod(vReadIndex_ - vFrameStart, vFrameDelta);
+    vReadIndex_ = vFrameStart + std::fmod(vReadIndex_ - vFrameStart, vFrameDelta);
   }
 
   while (framesLeft > 0) {
     auto readIndex = static_cast<size_t>(vReadIndex_);
     size_t nextReadIndex = readIndex + 1;
-    auto factor =
-        static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
+    auto factor = static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
 
     if (nextReadIndex >= frameEnd) {
       nextReadIndex = loop_ ? frameStart : readIndex;
@@ -290,8 +284,7 @@ void AudioBufferSourceNode::processWithInterpolation(
       float *destination = processingBus->getChannel(i)->getData();
       const float *source = alignedBus_->getChannel(i)->getData();
 
-      destination[writeIndex] =
-          dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
+      destination[writeIndex] = dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
     }
 
     writeIndex += 1;
@@ -315,8 +308,7 @@ void AudioBufferSourceNode::processWithInterpolation(
 double AudioBufferSourceNode::getVirtualStartFrame() {
   auto loopStartFrame = loopStart_ * context_->getSampleRate();
 
-  return loop_ && loopStartFrame >= 0 && loopStart_ < loopEnd_ ? loopStartFrame
-                                                               : 0.0;
+  return loop_ && loopStartFrame >= 0 && loopStart_ < loopEnd_ ? loopStartFrame : 0.0;
 }
 
 double AudioBufferSourceNode::getVirtualEndFrame() {

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

@@ -4,9 +4,9 @@
 #include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
-#include <memory>
-#include <cstddef>
 #include <algorithm>
+#include <cstddef>
+#include <memory>
 #include <string>
 
 namespace audioapi {
@@ -31,14 +31,16 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void setLoopEnd(double loopEnd);
   void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
 
+  using AudioScheduledSourceNode::start;
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
-  void clearOnLoopEndedCallback();
   void setOnLoopEndedCallbackId(uint64_t callbackId);
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
   double getCurrentPosition() const override;
 
  private:
@@ -56,13 +58,13 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void sendOnLoopEndedEvent();
 
   void processWithoutInterpolation(
-      const std::shared_ptr<AudioBus>& processingBus,
+      const std::shared_ptr<AudioBus> &processingBus,
       size_t startOffset,
       size_t offsetLength,
       float playbackRate) override;
 
   void processWithInterpolation(
-      const std::shared_ptr<AudioBus>& processingBus,
+      const std::shared_ptr<AudioBus> &processingBus,
       size_t startOffset,
       size_t offsetLength,
       float playbackRate) override;

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

@@ -6,6 +6,14 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
+#if !RN_AUDIO_API_TEST
+#include <audioapi/core/AudioContext.h>
+#endif // RN_AUDIO_API_TEST
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+
 namespace audioapi {
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
@@ -14,9 +22,16 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
       stopTime_(-1.0),
       playbackState_(PlaybackState::UNSCHEDULED) {
   numberOfInputs_ = 0;
+  audioEventHandlerRegistry_ = context_->audioEventHandlerRegistry_;
 }
 
 void AudioScheduledSourceNode::start(double when) {
+#if !RN_AUDIO_API_TEST
+  if (auto context = dynamic_cast<AudioContext *>(context_)) {
+    context->start();
+  }
+#endif // RN_AUDIO_API_TEST
+
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;
 }
@@ -45,19 +60,12 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
-void AudioScheduledSourceNode::clearOnEndedCallback() {
-  if (onEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "ended", onEndedCallbackId_);
-  onEndedCallbackId_ = 0;
-}
-
 void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
-  onEndedCallbackId_ = callbackId;
+  auto oldCallbackId = onEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("ended", oldCallbackId);
+  }
 }
 
 void AudioScheduledSourceNode::updatePlaybackInfo(
@@ -76,14 +84,11 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   auto sampleRate = context_->getSampleRate();
 
   size_t firstFrame = context_->getCurrentSampleFrame();
-  size_t lastFrame = firstFrame + framesToProcess;
-
-  size_t startFrame =
-      std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
-  size_t stopFrame = stopTime_ == -1.0
-      ? std::numeric_limits<size_t>::max()
-      : dsp::timeToSampleFrame(stopTime_, sampleRate);
+  size_t lastFrame = firstFrame + framesToProcess - 1;
 
+  size_t startFrame = std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
+  size_t stopFrame = stopTime_ == -1.0 ? std::numeric_limits<size_t>::max()
+                                       : dsp::timeToSampleFrame(stopTime_, sampleRate);
   if (isFinished()) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;
@@ -105,7 +110,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
     nonSilentFramesToProcess =
-        std::max(std::min(lastFrame, stopFrame), startFrame) - startFrame;
+        std::max(std::min(lastFrame, stopFrame) + 1, startFrame) - startFrame;
 
     assert(startOffset <= framesToProcess);
     assert(nonSilentFramesToProcess <= framesToProcess);
@@ -124,7 +129,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 
   // stop will happen in this render quantum
   // zero remaining frames after stop frame
-  if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+  if (stopFrame <= lastFrame && stopFrame >= firstFrame) {
     playbackState_ = PlaybackState::STOP_SCHEDULED;
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
@@ -160,9 +165,9 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  if (context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "ended", onEndedCallbackId_, {});
+  auto onEndedCallbackId = onEndedCallbackId_.load(std::memory_order_acquire);
+  if (onEndedCallbackId != 0) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("ended", onEndedCallbackId, {});
   }
 }
 

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

@@ -4,19 +4,19 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cassert>
 #include <chrono>
+#include <cstddef>
 #include <functional>
 #include <iostream>
 #include <limits>
 #include <memory>
 #include <thread>
-#include <cstddef>
-#include <cassert>
 #include <utility>
 
 namespace audioapi {
 
-class AudioEventHandlerRegistry;
+class IAudioEventHandlerRegistry;
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
@@ -28,7 +28,7 @@ class AudioScheduledSourceNode : public AudioNode {
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
 
-  void start(double when);
+  virtual void start(double when);
   virtual void stop(double when);
 
   bool isUnscheduled();
@@ -37,7 +37,6 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
-  void clearOnEndedCallback();
   void setOnEndedCallbackId(uint64_t callbackId);
 
   void disable() override;
@@ -49,9 +48,10 @@ class AudioScheduledSourceNode : public AudioNode {
   PlaybackState playbackState_;
 
   std::atomic<uint64_t> onEndedCallbackId_ = 0;
+  std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
   void updatePlaybackInfo(
-      const std::shared_ptr<AudioBus>& processingBus,
+      const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess,
       size_t &startOffset,
       size_t &nonSilentFramesToProcess);

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

@@ -3,6 +3,7 @@
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 
 namespace audioapi {
 ConstantSourceNode::ConstantSourceNode(BaseAudioContext *context)
@@ -29,13 +30,11 @@ std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
     return processingBus;
   }
 
-  auto offsetBus = offsetParam_->processARateParam(
-      framesToProcess, context_->getCurrentTime());
+  auto offsetBus = offsetParam_->processARateParam(framesToProcess, context_->getCurrentTime());
 
   auto offsetChannelData = offsetBus->getChannel(0)->getData();
 
-  for (int channel = 0; channel < processingBus->getNumberOfChannels();
-       ++channel) {
+  for (int channel = 0; channel < processingBus->getNumberOfChannels(); ++channel) {
     auto outputChannelData = processingBus->getChannel(channel)->getData();
 
     std::copy(

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

@@ -18,7 +18,9 @@ class ConstantSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> offsetParam_;

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

@@ -3,16 +3,14 @@
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
 
 namespace audioapi {
 
-OscillatorNode::OscillatorNode(BaseAudioContext *context)
-    : AudioScheduledSourceNode(context) {
+OscillatorNode::OscillatorNode(BaseAudioContext *context) : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      444.0,
-      -context_->getNyquistFrequency(),
-      context_->getNyquistFrequency(),
-      context);
+      444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
       0.0,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
@@ -21,8 +19,7 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   isInitialized_ = true;
 }
@@ -44,8 +41,7 @@ void OscillatorNode::setType(const std::string &type) {
   periodicWave_ = context_->getBasicWaveForm(type_);
 }
 
-void OscillatorNode::setPeriodicWave(
-    const std::shared_ptr<PeriodicWave> &periodicWave) {
+void OscillatorNode::setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave) {
   periodicWave_ = periodicWave;
   type_ = OscillatorType::CUSTOM;
 }
@@ -65,29 +61,22 @@ std::shared_ptr<AudioBus> OscillatorNode::processNode(
 
   auto time = context_->getCurrentTime() +
       static_cast<double>(startOffset) * 1.0 / context_->getSampleRate();
-  auto detuneParamValues =
-      detuneParam_->processARateParam(framesToProcess, time);
-  auto frequencyParamValues =
-      frequencyParam_->processARateParam(framesToProcess, time);
+  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, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
-    auto detunedFrequency =
-        frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
+    auto detuneRatio = std::pow(2.0f, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
+    auto detunedFrequency = frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
     auto phaseIncrement = detunedFrequency * periodicWave_->getScale();
 
-    float sample =
-        periodicWave_->getSample(detunedFrequency, phase_, phaseIncrement);
+    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())) *
+    phase_ -= floor(phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
         static_cast<float>(periodicWave_->getPeriodicWaveSize());
   }
 

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

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/effects/PeriodicWave.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/types/OscillatorType.h>
-#include <audioapi/core/effects/PeriodicWave.h>
 
+#include <algorithm>
 #include <cmath>
 #include <memory>
 #include <string>
@@ -24,7 +25,9 @@ class OscillatorNode : public AudioScheduledSourceNode {
   void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;
@@ -35,8 +38,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
 
   static OscillatorType fromString(const std::string &type) {
     std::string lowerType = type;
-    std::transform(
-        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
 
     if (lowerType == "sine")
       return OscillatorType::SINE;

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

@@ -1,7 +1,10 @@
 
 #include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 #include <type_traits>
 
 namespace audioapi {
@@ -14,36 +17,60 @@ RecorderAdapterNode::RecorderAdapterNode(BaseAudioContext *context) noexcept(
   isInitialized_ = false;
 }
 
-void RecorderAdapterNode::init(size_t bufferSize) {
+void RecorderAdapterNode::init(size_t bufferSize, int channelCount) {
   if (isInitialized_) {
-    throw std::runtime_error(
-        "RecorderAdapterNode should not be initialized more than once. Just create a new instance.");
+    return;
   }
+
+  channelCount_ = channelCount;
+
+  buff_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    buff_[i] = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
+  }
+
+  // This assumes that the sample rate is the same in audio context and recorder.
+  // (recorder is not enforcing any sample rate on the system*). This means that only
+  // channel mixing might be required. To do so, we create an output bus with
+  // the desired channel count and will take advantage of the AudioBus sum method.
+  //
+  // * any allocations required by the recorder (including this method) are during recording start
+  // or after, which means that audio context has already setup the system in 99% of sane cases.
+  // But if we would like to support cases when context is created on the fly during recording,
+  // we would need to add sample rate conversion as well or other weird bullshit like resampling
+  // context output and not enforcing anything on the system output/input configuration.
+  // A lot of words for a couple of lines of implementation :shrug:
+  adapterOutputBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
   isInitialized_ = true;
-  buff_ = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
+}
+
+void RecorderAdapterNode::cleanup() {
+  isInitialized_ = false;
+  buff_.clear();
+  adapterOutputBus_.reset();
 }
 
 std::shared_ptr<AudioBus> RecorderAdapterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  float *outputChannel = processingBus->getChannel(0)->getData();
-  readFrames(outputChannel, framesToProcess);
-
-  for (int i = 1; i < processingBus->getNumberOfChannels(); i++) {
-    processingBus->getChannel(i)->copy(
-        processingBus->getChannel(0), 0, framesToProcess);
+  if (!isInitialized_) {
+    processingBus->zero();
+    return processingBus;
   }
 
+  readFrames(framesToProcess);
+
+  processingBus->sum(adapterOutputBus_.get(), ChannelInterpretation::SPEAKERS);
   return processingBus;
 }
 
-void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {
-  size_t readFrames = buff_->read(output, framesToRead);
+void RecorderAdapterNode::readFrames(const size_t framesToRead) {
+  adapterOutputBus_->zero();
 
-  if (readFrames < framesToRead) {
-    // Fill the rest with silence
-    std::memset(
-        output + readFrames, 0, (framesToRead - readFrames) * sizeof(float));
+  for (size_t channel = 0; channel < channelCount_; ++channel) {
+    buff_[channel]->read(adapterOutputBus_->getChannel(channel)->getData(), framesToRead);
   }
 }