react-native-audio-api 0.4.0 → 0.4.2

package/common/cpp/core/AudioNode.cpp

@@ -9,9 +9,7 @@ namespace audioapi {
 
 AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
   audioBus_ = std::make_shared<AudioBus>(
-      context->getSampleRate(),
-      context->getBufferSizeInFrames(),
-      channelCount_);
+      context->getSampleRate(), RENDER_QUANTUM_SIZE, channelCount_);
 }
 
 AudioNode::~AudioNode() {
@@ -49,6 +47,12 @@ void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
   node->onInputConnected(this);
 }
 
+void AudioNode::disconnect() {
+  for (auto &outputNode : outputNodes_) {
+    disconnectNode(outputNode);
+  }
+}
+
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
   context_->getNodeManager()->addPendingConnection(
       shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
@@ -71,16 +75,16 @@ bool AudioNode::isEnabled() const {
 void AudioNode::enable() {
   isEnabled_ = true;
 
-  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
-    it->get()->onInputEnabled();
+  for (auto &outputNode : outputNodes_) {
+    outputNode->onInputEnabled();
   }
 }
 
 void AudioNode::disable() {
   isEnabled_ = false;
 
-  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
-    it->get()->onInputDisabled();
+  for (auto &outputNode : outputNodes_) {
+    outputNode->onInputDisabled();
   }
 }
 
@@ -162,12 +166,14 @@ AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
       AudioBus *inputBus = (*it)->processAudio(processingBus, framesToProcess);
 
       if (inputBus != processingBus) {
+        // add assert
         processingBus->sum(inputBus);
       }
     } else {
       // Enforce the summing to be done using the internal bus.
-      AudioBus *inputBus = (*it)->processAudio(0, framesToProcess);
+      AudioBus *inputBus = (*it)->processAudio(nullptr, framesToProcess);
       if (inputBus) {
+        // add assert
         processingBus->sum(inputBus);
       }
     }
@@ -201,6 +207,10 @@ void AudioNode::onInputDisabled() {
 }
 
 void AudioNode::onInputConnected(AudioNode *node) {
+  if (!isInitialized_) {
+    return;
+  }
+
   inputNodes_.push_back(node);
 
   if (node->isEnabled()) {
@@ -209,6 +219,10 @@ void AudioNode::onInputConnected(AudioNode *node) {
 }
 
 void AudioNode::onInputDisconnected(AudioNode *node) {
+  if (!isInitialized_) {
+    return;
+  }
+
   auto position = std::find(inputNodes_.begin(), inputNodes_.end(), node);
 
   if (position != inputNodes_.end()) {

package/common/cpp/core/AudioNode.h

@@ -3,6 +3,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <cstddef>
 
 #include "ChannelCountMode.h"
 #include "ChannelInterpretation.h"
@@ -23,6 +24,7 @@ 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 disconnect();
   void disconnect(const std::shared_ptr<AudioNode> &node);
 
   bool isEnabled() const;
@@ -36,24 +38,22 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   BaseAudioContext *context_;
   std::shared_ptr<AudioBus> audioBus_;
 
-  int channelCount_ = CHANNEL_COUNT;
-
   int numberOfInputs_ = 1;
   int numberOfOutputs_ = 1;
-  int numberOfEnabledInputNodes_ = 0;
+  int channelCount_ = 2;
+  ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
+  ChannelInterpretation channelInterpretation_ =
+          ChannelInterpretation::SPEAKERS;
+
+    std::vector<AudioNode *> inputNodes_ = {};
+    std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
 
+  int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;
   bool isEnabled_ = true;
 
   std::size_t lastRenderedFrame_{SIZE_MAX};
 
-  ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
-  ChannelInterpretation channelInterpretation_ =
-      ChannelInterpretation::SPEAKERS;
-
-  std::vector<AudioNode *> inputNodes_ = {};
-  std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
-
  private:
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);

package/common/cpp/core/AudioNodeManager.cpp

@@ -5,8 +5,6 @@
 
 namespace audioapi {
 
-AudioNodeManager::AudioNodeManager() {}
-
 AudioNodeManager::~AudioNodeManager() {
   audioNodesToConnect_.clear();
   sourceNodes_.clear();
@@ -18,7 +16,7 @@ void AudioNodeManager::addPendingConnection(
     ConnectionType type) {
   Locker lock(getGraphLock());
 
-  audioNodesToConnect_.push_back(std::make_tuple(from, to, type));
+  audioNodesToConnect_.emplace_back(from, to, type);
 }
 
 void AudioNodeManager::addSourceNode(const std::shared_ptr<AudioNode> &node) {

package/common/cpp/core/AudioNodeManager.h

@@ -12,7 +12,7 @@ class AudioNode;
 class AudioNodeManager {
  public:
   enum class ConnectionType { CONNECT, DISCONNECT };
-  AudioNodeManager();
+  AudioNodeManager() = default;
   ~AudioNodeManager();
 
   void preProcessGraph();

package/common/cpp/core/AudioParam.cpp

@@ -181,7 +181,7 @@ void AudioParam::setTargetAtTime(
 
 void AudioParam::setValueCurveAtTime(
     const float *values,
-    int length,
+    size_t length,
     double startTime,
     double duration) {
   if (startTime <= getQueueEndTime()) {
@@ -200,9 +200,12 @@ void AudioParam::setValueCurveAtTime(
 
     if (time < endTime) {
       auto k = static_cast<int>(std::floor(
-          (length - 1) / (endTime - startTime) * (time - startTime)));
+          static_cast<double>(length - 1) / (endTime - startTime) *
+          (time - startTime)));
       auto factor = static_cast<float>(
-          k - (time - startTime) * (length - 1) / (endTime - startTime));
+          k -
+          (time - startTime) * static_cast<double>(length - 1) /
+              (endTime - startTime));
 
       return AudioUtils::linearInterpolate(values, k, k + 1, factor);
     }

package/common/cpp/core/AudioParam.h

@@ -3,6 +3,7 @@
 #include <deque>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 #include "ParamChangeEvent.h"
 #include "ParamChangeEventType.h"
@@ -27,7 +28,7 @@ class AudioParam {
   void setTargetAtTime(float target, double startTime, double timeConstant);
   void setValueCurveAtTime(
       const float *values,
-      int length,
+      size_t length,
       double startTime,
       double duration);
   void cancelScheduledValues(double cancelTime);

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -53,7 +53,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     return;
   }
 
-  int sampleRate = context_->getSampleRate();
+  auto sampleRate = context_->getSampleRate();
 
   size_t firstFrame = context_->getCurrentSampleFrame();
   size_t lastFrame = firstFrame + framesToProcess;

package/common/cpp/core/AudioScheduledSourceNode.h

@@ -8,6 +8,7 @@
 #include <limits>
 #include <memory>
 #include <thread>
+#include <cstddef>
 
 #include "AudioNode.h"
 

package/common/cpp/core/BaseAudioContext.cpp

@@ -1,9 +1,3 @@
-#ifdef ANDROID
-#include "AudioPlayer.h"
-#else
-#include "IOSAudioPlayer.h"
-#endif
-
 #include "BaseAudioContext.h"
 
 #include "AnalyserNode.h"
@@ -23,42 +17,18 @@
 namespace audioapi {
 
 BaseAudioContext::BaseAudioContext() {
-#ifdef ANDROID
-  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
-#else
-  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
-#endif
-
-  audioDecoder_ = std::make_shared<AudioDecoder>(audioPlayer_->getSampleRate());
-
-  sampleRate_ = audioPlayer_->getSampleRate();
-  bufferSizeInFrames_ = audioPlayer_->getBufferSizeInFrames();
-
   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_);
 }
 
-int BaseAudioContext::getSampleRate() const {
+float BaseAudioContext::getSampleRate() const {
   return sampleRate_;
 }
 
-int BaseAudioContext::getBufferSizeInFrames() const {
-  return bufferSizeInFrames_;
-}
-
 std::size_t BaseAudioContext::getCurrentSampleFrame() const {
   return destination_->getCurrentSampleFrame();
 }
@@ -93,8 +63,8 @@ std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource() {
 
 std::shared_ptr<AudioBuffer> BaseAudioContext::createBuffer(
     int numberOfChannels,
-    int length,
-    int sampleRate) {
+    size_t length,
+    float sampleRate) {
   return std::make_shared<AudioBuffer>(numberOfChannels, length, sampleRate);
 }
 
@@ -117,16 +87,6 @@ std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
   return std::make_shared<AudioBuffer>(audioBus);
 }
 
-std::function<void(AudioBus *, int)> BaseAudioContext::renderAudio() {
-  if (!isRunning()) {
-    return [](AudioBus *, int) {};
-  }
-
-  return [this](AudioBus *data, int frames) {
-    destination_->renderAudio(data, frames);
-  };
-}
-
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }
@@ -139,6 +99,10 @@ bool BaseAudioContext::isClosed() const {
   return state_ == ContextState::CLOSED;
 }
 
+float BaseAudioContext::getNyquistFrequency() const {
+  return sampleRate_ / 2.0f;
+}
+
 std::string BaseAudioContext::toString(ContextState state) {
   switch (state) {
     case ContextState::SUSPENDED:

package/common/cpp/core/BaseAudioContext.h

@@ -5,6 +5,7 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <cstddef>
 
 #include "ContextState.h"
 #include "OscillatorType.h"
@@ -24,21 +25,14 @@ class AudioBufferSourceNode;
 class AudioDecoder;
 class AnalyserNode;
 
-#ifdef ANDROID
-class AudioPlayer;
-#else
-class IOSAudioPlayer;
-#endif
-
 class BaseAudioContext {
  public:
   BaseAudioContext();
-  ~BaseAudioContext();
+  virtual ~BaseAudioContext() = default;
 
   std::string getState();
-  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] float getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
-  [[nodiscard]] int getBufferSizeInFrames() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
   std::shared_ptr<AudioDestinationNode> getDestination();
 
@@ -48,34 +42,29 @@ class BaseAudioContext {
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
   std::shared_ptr<AudioBufferSourceNode> createBufferSource();
   static std::shared_ptr<AudioBuffer>
-  createBuffer(int numberOfChannels, int length, int sampleRate);
+  createBuffer(int numberOfChannels, size_t length, float sampleRate);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
       float *real,
       float *imag,
       bool disableNormalization,
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
-
   std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
+
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
-  std::function<void(AudioBus *, int)> renderAudio();
   AudioNodeManager *getNodeManager();
   [[nodiscard]] bool isRunning() const;
   [[nodiscard]] bool isClosed() const;
+  [[nodiscard]] float getNyquistFrequency() const;
 
  protected:
   static std::string toString(ContextState state);
   std::shared_ptr<AudioDestinationNode> destination_;
-  std::shared_ptr<AudioDecoder> audioDecoder_;
-
-#ifdef ANDROID
-  std::shared_ptr<AudioPlayer> audioPlayer_;
-#else
-  std::shared_ptr<IOSAudioPlayer> audioPlayer_;
-#endif
+  // init in AudioContext or OfflineContext constructor
+  std::shared_ptr<AudioDecoder> audioDecoder_ {};
 
-  int sampleRate_;
-  int bufferSizeInFrames_;
+  // init in AudioContext or OfflineContext constructor
+  float sampleRate_ {};
   ContextState state_ = ContextState::RUNNING;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 

package/common/cpp/core/BiquadFilterNode.cpp

@@ -11,9 +11,9 @@ namespace audioapi {
 BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
     : AudioNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      350.0, MIN_FILTER_FREQUENCY, MAX_FILTER_FREQUENCY);
+      350.0, MIN_FILTER_FREQUENCY, context->getNyquistFrequency());
   detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
-  QParam_ = std::make_shared<AudioParam>(1.0, -MAX_FILTER_Q, MAX_FILTER_Q);
+  QParam_ = std::make_shared<AudioParam>(1.0, MIN_FILTER_Q, MAX_FILTER_Q);
   gainParam_ =
       std::make_shared<AudioParam>(0.0, MIN_FILTER_GAIN, MAX_FILTER_GAIN);
   type_ = BiquadFilterType::LOWPASS;
@@ -67,8 +67,7 @@ void BiquadFilterNode::getFrequencyResponse(
   float a2 = a2_;
 
   for (size_t i = 0; i < frequencyArraySize; i++) {
-    auto omega =
-        static_cast<float>(M_PI) * frequencyArray[i] / NYQUIST_FREQUENCY;
+    auto omega = PI * frequencyArray[i] / context_->getNyquistFrequency();
     auto z = std::complex<float>(cos(omega), sin(omega));
     auto response = ((b0 * z + b1) * z + b2) / ((z + a1) * z + a2);
     magResponseOutput[i] = static_cast<float>(abs(response));
@@ -113,7 +112,7 @@ void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
   Q = std::max(0.0f, Q);
   float g = std::pow(10.0f, 0.05f * Q);
 
-  float theta = M_PI * frequency;
+  float theta = PI * frequency;
   float alpha = std::sin(theta) / (2 * g);
   float cosW = std::cos(theta);
   float beta = (1 - cosW) / 2;
@@ -136,7 +135,7 @@ void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
   Q = std::max(0.0f, Q);
   float g = std::pow(10.0f, 0.05f * Q);
 
-  float theta = M_PI * frequency;
+  float theta = PI * frequency;
   float alpha = std::sin(theta) / (2 * g);
   float cosW = std::cos(theta);
   float beta = (1 - cosW) / 2;
@@ -159,7 +158,7 @@ void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
     return;
   }
 
-  float w0 = M_PI * frequency;
+  float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
   float k = std::cos(w0);
 
@@ -181,7 +180,7 @@ void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
     return;
   }
 
-  float w0 = M_PI * frequency;
+  float w0 = PI * frequency;
   float alpha =
       0.5f * std::sin(w0) * std::sqrt((A + 1 / A) * (1 / 1.0f - 1) + 2);
   float k = std::cos(w0);
@@ -210,7 +209,7 @@ void BiquadFilterNode::setHighshelfCoefficients(float frequency, float gain) {
     return;
   }
 
-  float w0 = M_PI * frequency;
+  float w0 = PI * frequency;
   float alpha =
       0.5f * std::sin(w0) * std::sqrt((A + 1 / A) * (1 / 1.0f - 1) + 2);
   float k = std::cos(w0);
@@ -243,7 +242,7 @@ void BiquadFilterNode::setPeakingCoefficients(
     return;
   }
 
-  float w0 = M_PI * frequency;
+  float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
   float k = std::cos(w0);
 
@@ -270,7 +269,7 @@ void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
     return;
   }
 
-  float w0 = M_PI * frequency;
+  float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
   float k = std::cos(w0);
 
@@ -291,7 +290,7 @@ void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
     return;
   }
 
-  float w0 = M_PI * frequency;
+  float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
   float k = std::cos(w0);
 
@@ -302,8 +301,8 @@ void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
 void BiquadFilterNode::applyFilter() {
   double currentTime = context_->getCurrentTime();
 
-  float normalizedFrequency =
-      frequencyParam_->getValueAtTime(currentTime) / NYQUIST_FREQUENCY;
+  float normalizedFrequency = frequencyParam_->getValueAtTime(currentTime) /
+      context_->getNyquistFrequency();
   float detuneValue = detuneParam_->getValueAtTime(currentTime);
 
   if (detuneValue != 0.0) {

package/common/cpp/core/Constants.h

@@ -6,25 +6,39 @@
 // https://webaudio.github.io/web-audio-api/
 
 namespace audioapi {
-constexpr int SAMPLE_RATE = 48000;
+// context
+constexpr int RENDER_QUANTUM_SIZE = 128;
 constexpr int CHANNEL_COUNT = 2;
 
+// general
 constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
 constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
+constexpr float PI = static_cast<float>(M_PI);
 
-constexpr float NYQUIST_FREQUENCY = SAMPLE_RATE / 2.0;
-static float MAX_DETUNE = 1200 * std::log2(MOST_POSITIVE_SINGLE_FLOAT);
-constexpr float MAX_GAIN = MOST_POSITIVE_SINGLE_FLOAT;
+// pan
 constexpr float MAX_PAN = 1.0;
-constexpr float MAX_FILTER_Q = MOST_POSITIVE_SINGLE_FLOAT;
-constexpr float MAX_FILTER_FREQUENCY = NYQUIST_FREQUENCY;
+constexpr float MIN_PAN = -1.0;
+
+// gain
+constexpr float MAX_GAIN = MOST_POSITIVE_SINGLE_FLOAT;
+constexpr float MIN_GAIN = -MAX_GAIN;
+
+// biquad filter
 constexpr float MIN_FILTER_FREQUENCY = 0.0;
 static float MAX_FILTER_GAIN = 40 * std::log10(MOST_POSITIVE_SINGLE_FLOAT);
-constexpr float MIN_FILTER_GAIN = -MAX_GAIN;
+static float MIN_FILTER_GAIN = -MAX_GAIN;
+constexpr float MAX_FILTER_Q = MOST_POSITIVE_SINGLE_FLOAT;
+constexpr float MIN_FILTER_Q = -MAX_FILTER_Q;
+
+//detune
+static float MAX_DETUNE = 1200 * std::log2(MOST_POSITIVE_SINGLE_FLOAT);
+static float MIN_DETUNE = -MAX_DETUNE;
 
-constexpr int MAX_FFT_SIZE = 32768;
-constexpr int DEFAULT_FFT_SIZE = 2048;
-constexpr double DEFAULT_MAX_DECIBELS = -30;
-constexpr double DEFAULT_MIN_DECIBELS = -100;
-const double DEFAULT_SMOOTHING_TIME_CONSTANT = 0.8;
+// analyser node
+constexpr size_t MAX_FFT_SIZE = 32768;
+constexpr size_t MIN_FFT_SIZE = 32;
+constexpr size_t DEFAULT_FFT_SIZE = 2048;
+constexpr float DEFAULT_MAX_DECIBELS = -30;
+constexpr float DEFAULT_MIN_DECIBELS = -100;
+const float DEFAULT_SMOOTHING_TIME_CONSTANT = 0.8;
 } // namespace audioapi

package/common/cpp/core/GainNode.cpp

@@ -6,7 +6,7 @@
 namespace audioapi {
 
 GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
-  gainParam_ = std::make_shared<AudioParam>(1.0, -MAX_GAIN, MAX_GAIN);
+  gainParam_ = std::make_shared<AudioParam>(1.0, MIN_GAIN, MAX_GAIN);
   isInitialized_ = true;
 }
 

package/common/cpp/core/OscillatorNode.cpp

@@ -8,7 +8,7 @@ namespace audioapi {
 OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      444.0, -NYQUIST_FREQUENCY, NYQUIST_FREQUENCY);
+      444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency());
   detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
@@ -49,8 +49,9 @@ void OscillatorNode::processNode(AudioBus *processingBus, int framesToProcess) {
     return;
   }
 
-  double deltaTime = 1.0 / context_->getSampleRate();
-  double time = context_->getCurrentTime() + startOffset * deltaTime;
+  auto deltaTime = 1.0 / context_->getSampleRate();
+  auto time =
+      context_->getCurrentTime() + static_cast<double>(startOffset) * deltaTime;
 
   for (size_t i = startOffset; i < offsetLength; i += 1) {
     auto detuneRatio =

package/common/cpp/core/PeriodicWave.cpp

@@ -27,6 +27,7 @@
  */
 
 #include "PeriodicWave.h"
+#include "Constants.h"
 
 constexpr unsigned NumberOfOctaveBands = 3;
 constexpr float CentsPerRange = 1200.0f / NumberOfOctaveBands;
@@ -34,10 +35,10 @@ constexpr float interpolate2Point = 0.3;
 constexpr float interpolate3Point = 0.16;
 
 namespace audioapi {
-PeriodicWave::PeriodicWave(int sampleRate, bool disableNormalization)
+PeriodicWave::PeriodicWave(float sampleRate, bool disableNormalization)
     : sampleRate_(sampleRate), disableNormalization_(disableNormalization) {
-  numberOfRanges_ = lround(
-      NumberOfOctaveBands * log2f(static_cast<float>(getPeriodicWaveSize())));
+  numberOfRanges_ = static_cast<int>(round(
+      NumberOfOctaveBands * log2f(static_cast<float>(getPeriodicWaveSize()))));
   auto nyquistFrequency = sampleRate_ / 2;
   lowestFundamentalFrequency_ = static_cast<float>(nyquistFrequency) /
       static_cast<float>(getMaxNumberOfPartials());
@@ -47,7 +48,7 @@ PeriodicWave::PeriodicWave(int sampleRate, bool disableNormalization)
 }
 
 PeriodicWave::PeriodicWave(
-    int sampleRate,
+    float sampleRate,
     audioapi::OscillatorType type,
     bool disableNormalization)
     : PeriodicWave(sampleRate, disableNormalization) {
@@ -55,7 +56,7 @@ PeriodicWave::PeriodicWave(
 }
 
 PeriodicWave::PeriodicWave(
-    int sampleRate,
+    float sampleRate,
     float *real,
     float *imaginary,
     int length,
@@ -147,7 +148,7 @@ void PeriodicWave::generateBasicWaveForm(OscillatorType type) {
     // Coefficient for sin()
     float b;
 
-    auto piFactor = static_cast<float>(1.0f / (i * M_PI));
+    auto piFactor = 1.0f / (PI * static_cast<float>(i));
 
     switch (type) {
       case OscillatorType::SINE:

package/common/cpp/core/PeriodicWave.h

@@ -40,11 +40,11 @@ namespace audioapi {
 class PeriodicWave {
  public:
   explicit PeriodicWave(
-      int sampleRate,
+      float sampleRate,
       OscillatorType type,
       bool disableNormalization);
   explicit PeriodicWave(
-      int sampleRate,
+      float sampleRate,
       float *real,
       float *imaginary,
       int length,
@@ -57,7 +57,7 @@ class PeriodicWave {
   getSample(float fundamentalFrequency, float phase, float phaseIncrement);
 
  private:
-  explicit PeriodicWave(int sampleRate, bool disableNormalization);
+  explicit PeriodicWave(float sampleRate, bool disableNormalization);
 
   // Partial is any frequency component of a sound.
   // Both harmonics(fundamentalFrequency * k)  and overtones are partials.
@@ -102,7 +102,7 @@ class PeriodicWave {
       const float *higherWaveData) const;
 
   // determines the time resolution of the waveform.
-  int sampleRate_;
+  float sampleRate_;
   // determines number of frequency segments (or bands) the signal is divided.
   int numberOfRanges_;
   // the lowest frequency (in hertz) where playback will include all of the

package/common/cpp/core/StereoPannerNode.cpp

@@ -11,7 +11,7 @@ namespace audioapi {
 StereoPannerNode::StereoPannerNode(BaseAudioContext *context)
     : AudioNode(context) {
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
-  panParam_ = std::make_shared<AudioParam>(0.0, -MAX_PAN, MAX_PAN);
+  panParam_ = std::make_shared<AudioParam>(0.0, MIN_PAN, MAX_PAN);
   isInitialized_ = true;
 }
 
@@ -36,10 +36,10 @@ void StereoPannerNode::processNode(
 
   for (int i = 0; i < framesToProcess; i += 1) {
     float pan = panParam_->getValueAtTime(time);
-    float x = (pan <= 0 ? pan + 1 : pan) * M_PI / 2;
+    float x = (pan <= 0 ? pan + 1 : pan) * PI / 2;
 
-    float gainL = static_cast<float>(cos(x));
-    float gainR = static_cast<float>(sin(x));
+    auto gainL = static_cast<float>(cos(x));
+    auto gainR = static_cast<float>(sin(x));
 
     float inputL = (*left)[i];
     float inputR = (*right)[i];