react-native-audio-api 0.2.0 → 0.3.0-rc2

package/common/cpp/core/AudioDestinationNode.cpp

@@ -1,9 +1,9 @@
+#include "AudioDestinationNode.h"
 #include "AudioBus.h"
 #include "AudioNode.h"
-#include "VectorMath.h"
 #include "AudioNodeManager.h"
 #include "BaseAudioContext.h"
-#include "AudioDestinationNode.h"
+#include "VectorMath.h"
 
 namespace audioapi {
 
@@ -23,15 +23,18 @@ double AudioDestinationNode::getCurrentTime() const {
   return static_cast<double>(currentSampleFrame_) / context_->getSampleRate();
 }
 
-void AudioDestinationNode::renderAudio(AudioBus *destinationBus, int32_t numFrames) {
-  context_->getNodeManager()->preProcessGraph();
-  destinationBus->zero();
-
-  if (!numFrames) {
+void AudioDestinationNode::renderAudio(
+    AudioBus *destinationBus,
+    int32_t numFrames) {
+  if (!numFrames || !destinationBus || !isInitialized_) {
     return;
   }
 
-  AudioBus* processedBus = processAudio(destinationBus, numFrames);
+  context_->getNodeManager()->preProcessGraph();
+
+  destinationBus->zero();
+
+  AudioBus *processedBus = processAudio(destinationBus, numFrames);
 
   if (processedBus && processedBus != destinationBus) {
     destinationBus->copy(processedBus);

package/common/cpp/core/AudioDestinationNode.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <vector>
-#include <memory>
 #include <algorithm>
+#include <memory>
+#include <vector>
 
 #include "AudioNode.h"
 
@@ -15,7 +15,7 @@ class AudioDestinationNode : public AudioNode {
  public:
   explicit AudioDestinationNode(BaseAudioContext *context);
 
-  void renderAudio(AudioBus* audioData, int32_t numFrames);
+  void renderAudio(AudioBus *audioData, int32_t numFrames);
 
   std::size_t getCurrentSampleFrame() const;
   double getCurrentTime() const;
@@ -23,7 +23,7 @@ class AudioDestinationNode : public AudioNode {
  protected:
   // DestinationNode is triggered by AudioContext using renderAudio
   // processNode function is not necessary and is never called.
-  void processNode(AudioBus*, int) final { };
+  void processNode(AudioBus *, int) final{};
 
  private:
   std::size_t currentSampleFrame_;

package/common/cpp/core/AudioNode.cpp

@@ -2,13 +2,16 @@
 
 #include "AudioBus.h"
 #include "AudioNode.h"
-#include "BaseAudioContext.h"
 #include "AudioNodeManager.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
 AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
-  audioBus_ = std::make_shared<AudioBus>(context->getSampleRate(), context->getBufferSizeInFrames(), channelCount_);
+  audioBus_ = std::make_shared<AudioBus>(
+      context->getSampleRate(),
+      context->getBufferSizeInFrames(),
+      channelCount_);
 }
 
 AudioNode::~AudioNode() {
@@ -37,7 +40,8 @@ std::string AudioNode::getChannelInterpretation() const {
 }
 
 void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingConnection(shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
+  context_->getNodeManager()->addPendingConnection(
+      shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
 }
 
 void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
@@ -46,7 +50,8 @@ void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
 }
 
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingConnection(shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
+  context_->getNodeManager()->addPendingConnection(
+      shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
 }
 
 void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
@@ -103,7 +108,7 @@ std::string AudioNode::toString(ChannelInterpretation interpretation) {
   }
 }
 
-AudioBus* AudioNode::processAudio(AudioBus* outputBus, int framesToProcess) {
+AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
   if (!isInitialized_) {
     return outputBus;
   }
@@ -114,10 +119,14 @@ AudioBus* AudioNode::processAudio(AudioBus* outputBus, int framesToProcess) {
   bool isAlreadyProcessed = currentSampleFrame == lastRenderedFrame_;
 
   // Node can't use output bus if:
-  // - outputBus is not provided, which means that next node is doing a multi-node summing.
-  // - it has more than one input, which means that it has to sum all inputs using internal bus.
-  // - it has more than one output, so each output node can get the processed data without re-calculating the node.
-  bool canUseOutputBus = outputBus != 0 && inputNodes_.size() < 2 && outputNodes_.size() < 2;
+  // - outputBus is not provided, which means that next node is doing a
+  // multi-node summing.
+  // - it has more than one input, which means that it has to sum all inputs
+  // using internal bus.
+  // - it has more than one output, so each output node can get the processed
+  // data without re-calculating the node.
+  bool canUseOutputBus =
+      outputBus != 0 && inputNodes_.size() < 2 && outputNodes_.size() < 2;
 
   if (isAlreadyProcessed) {
     // If it was already processed in the rendering quantum, return it.
@@ -127,7 +136,7 @@ AudioBus* AudioNode::processAudio(AudioBus* outputBus, int framesToProcess) {
   // Update the last rendered frame before processing node and its inputs.
   lastRenderedFrame_ = currentSampleFrame;
 
-  AudioBus* processingBus = canUseOutputBus ? outputBus : audioBus_.get();
+  AudioBus *processingBus = canUseOutputBus ? outputBus : audioBus_.get();
 
   if (!canUseOutputBus) {
     // Clear the bus before summing all connected nodes.
@@ -135,8 +144,8 @@ AudioBus* AudioNode::processAudio(AudioBus* outputBus, int framesToProcess) {
   }
 
   if (inputNodes_.empty()) {
-    // If there are no connected inputs, process the node just to advance the audio params.
-    // The node will output silence anyway.
+    // If there are no connected inputs, process the node just to advance the
+    // audio params. The node will output silence anyway.
     processNode(processingBus, framesToProcess);
     return processingBus;
   }
@@ -146,17 +155,17 @@ AudioBus* AudioNode::processAudio(AudioBus* outputBus, int framesToProcess) {
       continue;
     }
 
-    // Process first connected node, it can be directly connected to the processingBus,
-    // resulting in one less summing operation.
+    // Process first connected node, it can be directly connected to the
+    // processingBus, resulting in one less summing operation.
     if (it == inputNodes_.begin()) {
-      AudioBus* inputBus = (*it)->processAudio(processingBus, framesToProcess);
+      AudioBus *inputBus = (*it)->processAudio(processingBus, framesToProcess);
 
       if (inputBus != processingBus) {
         processingBus->sum(inputBus);
       }
     } else {
       // Enforce the summing to be done using the internal bus.
-      AudioBus* inputBus = (*it)->processAudio(0, framesToProcess);
+      AudioBus *inputBus = (*it)->processAudio(0, framesToProcess);
       if (inputBus) {
         processingBus->sum(inputBus);
       }
@@ -205,7 +214,6 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
     inputNodes_.erase(position);
   }
 
-
   if (inputNodes_.size() > 0) {
     return;
   }

package/common/cpp/core/AudioNode.h

@@ -4,9 +4,9 @@
 #include <string>
 #include <vector>
 
-#include "Constants.h"
 #include "ChannelCountMode.h"
 #include "ChannelInterpretation.h"
+#include "Constants.h"
 
 namespace audioapi {
 
@@ -45,13 +45,13 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   bool isInitialized_ = false;
   bool isEnabled_ = true;
 
-  std::size_t lastRenderedFrame_ { SIZE_MAX };
+  std::size_t lastRenderedFrame_{SIZE_MAX};
 
   ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
   ChannelInterpretation channelInterpretation_ =
       ChannelInterpretation::SPEAKERS;
 
-  std::vector<AudioNode*> inputNodes_ = {};
+  std::vector<AudioNode *> inputNodes_ = {};
   std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
 
  private:
@@ -59,8 +59,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   static std::string toString(ChannelInterpretation interpretation);
 
   void cleanup();
-  AudioBus* processAudio(AudioBus* outputBus, int framesToProcess);
-  virtual void processNode(AudioBus* processingBus, int framesToProcess) = 0;
+  AudioBus *processAudio(AudioBus *outputBus, int framesToProcess);
+  virtual void processNode(AudioBus *processingBus, int framesToProcess) = 0;
 
   void connectNode(const std::shared_ptr<AudioNode> &node);
   void disconnectNode(const std::shared_ptr<AudioNode> &node);

package/common/cpp/core/AudioNodeManager.cpp

@@ -1,7 +1,7 @@
 
-#include "Locker.h"
-#include "AudioNode.h"
 #include "AudioNodeManager.h"
+#include "AudioNode.h"
+#include "Locker.h"
 
 namespace audioapi {
 
@@ -12,7 +12,10 @@ AudioNodeManager::~AudioNodeManager() {
   sourceNodes_.clear();
 }
 
-void AudioNodeManager::addPendingConnection(const std::shared_ptr<AudioNode> &from, const std::shared_ptr<AudioNode> &to, ConnectionType type) {
+void AudioNodeManager::addPendingConnection(
+    const std::shared_ptr<AudioNode> &from,
+    const std::shared_ptr<AudioNode> &to,
+    ConnectionType type) {
   Locker lock(getGraphLock());
 
   audioNodesToConnect_.push_back(std::make_tuple(from, to, type));
@@ -25,7 +28,7 @@ void AudioNodeManager::addSourceNode(const std::shared_ptr<AudioNode> &node) {
 }
 
 void AudioNodeManager::preProcessGraph() {
-    if (!Locker::tryLock(getGraphLock())) {
+  if (!Locker::tryLock(getGraphLock())) {
     return;
   }
 
@@ -33,12 +36,12 @@ void AudioNodeManager::preProcessGraph() {
   removeFinishedSourceNodes();
 }
 
-std::mutex& AudioNodeManager::getGraphLock() {
+std::mutex &AudioNodeManager::getGraphLock() {
   return graphLock_;
 }
 
 void AudioNodeManager::settlePendingConnections() {
-  for (auto& connection : audioNodesToConnect_) {
+  for (auto &connection : audioNodesToConnect_) {
     std::shared_ptr<AudioNode> from = std::get<0>(connection);
     std::shared_ptr<AudioNode> to = std::get<1>(connection);
     ConnectionType type = std::get<2>(connection);
@@ -58,7 +61,7 @@ void AudioNodeManager::removeFinishedSourceNodes() {
     auto currentNode = it->get();
     // Release the source node if use count is equal to 1 (this vector)
     if (!currentNode->isEnabled() && it->use_count() == 1) {
-      for (auto& outputNode : currentNode->outputNodes_) {
+      for (auto &outputNode : currentNode->outputNodes_) {
         currentNode->disconnectNode(outputNode);
       }
 

package/common/cpp/core/AudioNodeManager.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <memory>
 #include <mutex>
 #include <tuple>
-#include <memory>
 #include <vector>
 
 namespace audioapi {
@@ -16,17 +16,24 @@ class AudioNodeManager {
   ~AudioNodeManager();
 
   void preProcessGraph();
-  void addPendingConnection(const std::shared_ptr<AudioNode> &from, const std::shared_ptr<AudioNode> &to, ConnectionType type);
+  void addPendingConnection(
+      const std::shared_ptr<AudioNode> &from,
+      const std::shared_ptr<AudioNode> &to,
+      ConnectionType type);
 
   void addSourceNode(const std::shared_ptr<AudioNode> &node);
 
-  std::mutex& getGraphLock();
+  std::mutex &getGraphLock();
 
  private:
   std::mutex graphLock_;
 
   std::vector<std::shared_ptr<AudioNode>> sourceNodes_;
-  std::vector<std::tuple<std::shared_ptr<AudioNode>, std::shared_ptr<AudioNode>, ConnectionType>> audioNodesToConnect_;
+  std::vector<std::tuple<
+      std::shared_ptr<AudioNode>,
+      std::shared_ptr<AudioNode>,
+      ConnectionType>>
+      audioNodesToConnect_;
 
   void settlePendingConnections();
   void removeFinishedSourceNodes();

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -1,6 +1,6 @@
-#include "BaseAudioContext.h"
-#include "AudioNodeManager.h"
 #include "AudioScheduledSourceNode.h"
+#include "AudioNodeManager.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 

package/common/cpp/core/BaseAudioContext.cpp

@@ -1,40 +1,53 @@
 #ifdef ANDROID
+#include "AudioDecoder.h"
 #include "AudioPlayer.h"
 #else
+#include "IOSAudioDecoder.h"
 #include "IOSAudioPlayer.h"
 #endif
 
 #include "BaseAudioContext.h"
 
-#include "GainNode.h"
-#include "AudioBus.h"
 #include "AudioArray.h"
 #include "AudioBuffer.h"
+#include "AudioBufferSourceNode.h"
+#include "AudioBus.h"
+#include "AudioDestinationNode.h"
+#include "AudioNodeManager.h"
+#include "BiquadFilterNode.h"
 #include "ContextState.h"
+#include "GainNode.h"
 #include "OscillatorNode.h"
 #include "StereoPannerNode.h"
-#include "BiquadFilterNode.h"
-#include "AudioNodeManager.h"
-#include "AudioDestinationNode.h"
-#include "AudioBufferSourceNode.h"
 
 namespace audioapi {
 
 BaseAudioContext::BaseAudioContext() {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+  audioDecoder_ = std::make_shared<AudioDecoder>(audioPlayer_->getSampleRate());
 #else
   audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
+  audioDecoder_ =
+      std::make_shared<IOSAudioDecoder>(audioPlayer_->getSampleRate());
 #endif
 
   sampleRate_ = audioPlayer_->getSampleRate();
   bufferSizeInFrames_ = audioPlayer_->getBufferSizeInFrames();
 
-  audioPlayer_->start();
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
 }
 
+BaseAudioContext::~BaseAudioContext() {
+  if (isRunning()) {
+    return;
+  }
+
+  state_ = ContextState::CLOSED;
+  audioPlayer_->stop();
+}
+
 std::string BaseAudioContext::getState() {
   return BaseAudioContext::toString(state_);
 }
@@ -95,20 +108,42 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
       sampleRate_, real, imag, length, disableNormalization);
 }
 
+#ifdef ANDROID
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+#else
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+#endif
+
 std::function<void(AudioBus *, int)> BaseAudioContext::renderAudio() {
-  if (state_ == ContextState::CLOSED) {
+  if (!isRunning()) {
     return [](AudioBus *, int) {};
   }
 
-  return [this](AudioBus* data, int frames) {
+  return [this](AudioBus *data, int frames) {
     destination_->renderAudio(data, frames);
   };
 }
 
-AudioNodeManager* BaseAudioContext::getNodeManager() {
+AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }
 
+bool BaseAudioContext::isRunning() const {
+  return state_ == ContextState::RUNNING;
+}
+
+bool BaseAudioContext::isClosed() const {
+  return state_ == ContextState::CLOSED;
+}
+
 std::string BaseAudioContext::toString(ContextState state) {
   switch (state) {
     case ContextState::SUSPENDED:
@@ -122,7 +157,8 @@ std::string BaseAudioContext::toString(ContextState state) {
   }
 }
 
-std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType type) {
+std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(
+    OscillatorType type) {
   switch (type) {
     case OscillatorType::SINE:
       if (cachedSineWave_ == nullptr) {
@@ -149,7 +185,8 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType
       }
       return cachedTriangleWave_;
     case OscillatorType::CUSTOM:
-      throw std::invalid_argument("You can't get a custom wave form. You need to create it.");
+      throw std::invalid_argument(
+          "You can't get a custom wave form. You need to create it.");
       break;
   }
 }

package/common/cpp/core/BaseAudioContext.h

@@ -1,10 +1,10 @@
 #pragma once
 
+#include <functional>
 #include <memory>
 #include <string>
-#include <vector>
 #include <utility>
-#include <functional>
+#include <vector>
 
 #include "ContextState.h"
 #include "OscillatorType.h"
@@ -24,36 +24,43 @@ class AudioBufferSourceNode;
 
 #ifdef ANDROID
 class AudioPlayer;
+class AudioDecoder;
 #else
 class IOSAudioPlayer;
+class IOSAudioDecoder;
 #endif
 
 class BaseAudioContext {
  public:
   BaseAudioContext();
+  ~BaseAudioContext();
+
   std::string getState();
   [[nodiscard]] int getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
   [[nodiscard]] int getBufferSizeInFrames() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
-
   std::shared_ptr<AudioDestinationNode> getDestination();
+
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
   std::shared_ptr<AudioBufferSourceNode> createBufferSource();
-  static std::shared_ptr<AudioBuffer> createBuffer(int numberOfChannels, int length, int sampleRate);
+  static std::shared_ptr<AudioBuffer>
+  createBuffer(int numberOfChannels, int length, int sampleRate);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
       float *real,
       float *imag,
       bool disableNormalization,
       int length);
-  std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
 
+  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
+  std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   std::function<void(AudioBus *, int)> renderAudio();
-
-  AudioNodeManager* getNodeManager();
+  AudioNodeManager *getNodeManager();
+  [[nodiscard]] bool isRunning() const;
+  [[nodiscard]] bool isClosed() const;
 
  protected:
   static std::string toString(ContextState state);
@@ -61,8 +68,10 @@ class BaseAudioContext {
 
 #ifdef ANDROID
   std::shared_ptr<AudioPlayer> audioPlayer_;
+  std::shared_ptr<AudioDecoder> audioDecoder_;
 #else
   std::shared_ptr<IOSAudioPlayer> audioPlayer_;
+  std::shared_ptr<IOSAudioDecoder> audioDecoder_;
 #endif
 
   int sampleRate_;

package/common/cpp/core/BiquadFilterNode.cpp

@@ -1,6 +1,6 @@
-#include "AudioBus.h"
-#include "AudioArray.h"
 #include "BiquadFilterNode.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 #include "BaseAudioContext.h"
 
 // https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html - math
@@ -352,7 +352,9 @@ void BiquadFilterNode::applyFilter() {
   }
 }
 
-void BiquadFilterNode::processNode(AudioBus* processingBus, int framesToProcess) {
+void BiquadFilterNode::processNode(
+    AudioBus *processingBus,
+    int framesToProcess) {
   resetCoefficients();
   applyFilter();
 

package/common/cpp/core/GainNode.cpp

@@ -1,6 +1,6 @@
 #include "GainNode.h"
-#include "AudioBus.h"
 #include "AudioArray.h"
+#include "AudioBus.h"
 #include "BaseAudioContext.h"
 
 namespace audioapi {

package/common/cpp/core/OscillatorNode.cpp

@@ -1,6 +1,6 @@
-#include "AudioBus.h"
-#include "AudioArray.h"
 #include "OscillatorNode.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 #include "BaseAudioContext.h"
 
 namespace audioapi {
@@ -39,7 +39,7 @@ void OscillatorNode::setPeriodicWave(
   type_ = OscillatorType::CUSTOM;
 }
 
-void OscillatorNode::processNode(AudioBus* processingBus, int framesToProcess) {
+void OscillatorNode::processNode(AudioBus *processingBus, int framesToProcess) {
   if (!isPlaying()) {
     processingBus->zero();
     return;
@@ -50,7 +50,7 @@ void OscillatorNode::processNode(AudioBus* processingBus, int framesToProcess) {
 
   for (int i = 0; i < framesToProcess; i += 1) {
     auto detuneRatio =
-      std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+        std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
     auto detunedFrequency =
         round(frequencyParam_->getValueAtTime(time) * detuneRatio);
     auto phaseIncrement = detunedFrequency * periodicWave_->getScale();

package/common/cpp/core/OscillatorNode.h

@@ -5,9 +5,9 @@
 #include <string>
 
 #include "AudioParam.h"
-#include "PeriodicWave.h"
-#include "OscillatorType.h"
 #include "AudioScheduledSourceNode.h"
+#include "OscillatorType.h"
+#include "PeriodicWave.h"
 
 namespace audioapi {
 

package/common/cpp/core/StereoPannerNode.cpp

@@ -1,8 +1,8 @@
-#include "AudioBus.h"
-#include "Constants.h"
-#include "AudioArray.h"
 #include "StereoPannerNode.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 #include "BaseAudioContext.h"
+#include "Constants.h"
 
 // https://webaudio.github.io/web-audio-api/#stereopanner-algorithm
 
@@ -19,17 +19,20 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
   return panParam_;
 }
 
-void StereoPannerNode::processNode(AudioBus* processingBus, int framesToProcess) {
+void StereoPannerNode::processNode(
+    AudioBus *processingBus,
+    int framesToProcess) {
   // TODO: Currently assumed channelCount is 2
   // it should:
   //  - support mono-channel buses
-  //  - throw errors when trying to setup stereo panner with more than 2 channels
+  //  - throw errors when trying to setup stereo panner with more than 2
+  //  channels
 
   double time = context_->getCurrentTime();
   double deltaTime = 1.0 / context_->getSampleRate();
 
-  AudioArray* left = processingBus->getChannelByType(AudioBus::ChannelLeft);
-  AudioArray* right = processingBus->getChannelByType(AudioBus::ChannelRight);
+  AudioArray *left = processingBus->getChannelByType(AudioBus::ChannelLeft);
+  AudioArray *right = processingBus->getChannelByType(AudioBus::ChannelRight);
 
   for (int i = 0; i < framesToProcess; i += 1) {
     float pan = panParam_->getValueAtTime(time);

package/common/cpp/core/StereoPannerNode.h

@@ -17,7 +17,7 @@ class StereoPannerNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
 
  protected:
-  void processNode(AudioBus* processingBus, int framesToProcess) override;
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> panParam_;

package/common/cpp/utils/FFTFrame.h

@@ -38,7 +38,11 @@ namespace audioapi {
 
 class FFTFrame {
  public:
-  explicit FFTFrame(int size): size_(size), log2Size_(static_cast<int>(log2(size))), realData_(new float[size]), imaginaryData_(new float[size]) {}
+  explicit FFTFrame(int size)
+      : size_(size),
+        log2Size_(static_cast<int>(log2(size))),
+        realData_(new float[size]),
+        imaginaryData_(new float[size]) {}
   ~FFTFrame() {
     delete[] realData_;
     delete[] imaginaryData_;