react-native-audio-api 0.3.2 → 0.4.0

package/README.md

@@ -17,11 +17,25 @@ allowing developers to generate and modify audio in exact same way it is possibl
    yarn add react-native-audio-api
    ```
 
+## Usage with expo
+
+`react-native-audio-api` contains native custom code and isn't part of the Expo Go application. In order to be available in expo managed builds, you have to use Expo development build. Simplest way on starting local expo dev builds, is to use:
+
+  ```bash
+    # Build native iOS project
+    npx expo run:ios
+    # Build native Android project
+    npx expo run:android
+  ```
+
+To learn more about expo development builds, please check out [Development Builds Documentation](https://docs.expo.dev/develop/development-builds/introduction/).
+
 ## Documentation
 
-`react-native-audio-api` tries to strictly follow the Web Audi API specification, which can be found at [https://www.w3.org/TR/webaudio/](https://www.w3.org/TR/webaudio/).
-<br />
-[MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API) is useful resource to get familiar with audio processing basics.
+Check out our dedicated documentation page for info about this library, API reference and more:
+[https://software-mansion-labs.github.io/react-native-audio-api/](https://software-mansion-labs.github.io/react-native-audio-api/)
+
+You can also check out [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API) for fully detailed description of the audio api.
 
 ## Coverage
 
@@ -29,14 +43,6 @@ Our current coverage of Web Audio API specification can be found here: [Web Audi
 
 ## Examples
 
-<div align="center">
-
-<a href="https://www.youtube.com/watch?v=npALr9IIDkI" target="_blank" rel="noopener noreferrer">
-  <img src="./docs/assets/rnaa-example-01-thumbnail.png" width="640" />
-</a>
-
-</div>
-
 The source code for the example application is under the [`/apps/common-app`](./apps/common-app/) directory. If you want to play with the API but don't feel like trying it on a real app, you can run the example project. Check [Example README](./apps/fabric-example/README.md) for installation instructions.
 
 ## Your feedback

package/common/cpp/HostObjects/AnalyserNodeHostObject.h

@@ -0,0 +1,151 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AnalyserNode.h"
+#include "AudioNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AnalyserNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, frequencyBinCount),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, minDecibels),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, maxDecibels),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, smoothingTimeConstant));
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getFloatFrequencyData),
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getByteFrequencyData),
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getFloatTimeDomainData),
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getByteTimeDomainData));
+
+    addSetters(
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, fftSize),
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, minDecibels),
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, maxDecibels),
+        JSI_EXPORT_PROPERTY_SETTER(
+            AnalyserNodeHostObject, smoothingTimeConstant));
+  }
+
+  JSI_PROPERTY_GETTER(fftSize) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {static_cast<int>(analyserNode->getFftSize())};
+  }
+
+  JSI_PROPERTY_GETTER(frequencyBinCount) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {static_cast<int>(analyserNode->getFrequencyBinCount())};
+  }
+
+  JSI_PROPERTY_GETTER(minDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {analyserNode->getMinDecibels()};
+  }
+
+  JSI_PROPERTY_GETTER(maxDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {analyserNode->getMaxDecibels()};
+  }
+
+  JSI_PROPERTY_GETTER(smoothingTimeConstant) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {analyserNode->getSmoothingTimeConstant()};
+  }
+
+  JSI_HOST_FUNCTION(getFloatFrequencyData) {
+      auto destination = args[0].getObject(runtime).asArray(runtime);
+      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+      auto data = new float[length];
+
+      auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+        analyserNode->getFloatFrequencyData(data, length);
+
+      for (int i = 0; i < length; i++) {
+          destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
+      }
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getByteFrequencyData) {
+      auto destination = args[0].getObject(runtime).asArray(runtime);
+      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+      auto data = new uint8_t[length];
+
+        auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+        analyserNode->getByteFrequencyData(data, length);
+
+        for (int i = 0; i < length; i++) {
+            destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
+        }
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getFloatTimeDomainData) {
+      auto destination = args[0].getObject(runtime).asArray(runtime);
+      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+      auto data = new float[length];
+
+      auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+      analyserNode->getFloatTimeDomainData(data, length);
+
+    for (int i = 0; i < length; i++) {
+        destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
+    }
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getByteTimeDomainData) {
+      auto destination = args[0].getObject(runtime).asArray(runtime);
+      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+      auto data = new uint8_t[length];
+
+      auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+      analyserNode->getByteTimeDomainData(data, length);
+
+      for (int i = 0; i < length; i++) {
+          destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
+      }
+
+      return jsi::Value::undefined();
+  }
+
+  JSI_PROPERTY_SETTER(fftSize) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto fftSize = static_cast<size_t>(value.getNumber());
+    analyserNode->setFftSize(fftSize);
+  }
+
+  JSI_PROPERTY_SETTER(minDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto minDecibels = static_cast<int>(value.getNumber());
+    analyserNode->setMinDecibels(minDecibels);
+  }
+
+  JSI_PROPERTY_SETTER(maxDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+      auto maxDecibels = static_cast<int>(value.getNumber());
+      analyserNode->setMaxDecibels(maxDecibels);
+  }
+
+  JSI_PROPERTY_SETTER(smoothingTimeConstant) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto smoothingTimeConstant = static_cast<int>(value.getNumber());
+    analyserNode->setSmoothingTimeConstant(smoothingTimeConstant);
+  }
+};
+} // namespace audioapi

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -17,6 +17,7 @@
 #include "OscillatorNodeHostObject.h"
 #include "PeriodicWaveHostObject.h"
 #include "StereoPannerNodeHostObject.h"
+#include "AnalyserNodeHostObject.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -41,6 +42,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource));
   }
 
@@ -131,6 +133,12 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return jsi::Object::createFromHostObject(runtime, periodicWaveHostObject);
   }
 
+  JSI_HOST_FUNCTION(createAnalyser) {
+    auto analyser = context_->createAnalyser();
+    auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
+    return jsi::Object::createFromHostObject(runtime, analyserHostObject);
+  }
+
   JSI_HOST_FUNCTION(decodeAudioDataSource) {
     auto sourcePath = args[0].getString(runtime).utf8(runtime);
 

package/common/cpp/core/AnalyserNode.cpp

@@ -0,0 +1,237 @@
+#include "AnalyserNode.h"
+
+#include <complex>
+
+#include "AudioArray.h"
+#include "AudioBus.h"
+#include "AudioUtils.h"
+#include "BaseAudioContext.h"
+#include "FFTFrame.h"
+#include "VectorMath.h"
+
+namespace audioapi {
+AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
+    : AudioNode(context),
+      fftSize_(DEFAULT_FFT_SIZE),
+      minDecibels_(DEFAULT_MIN_DECIBELS),
+      maxDecibels_(DEFAULT_MAX_DECIBELS),
+      smoothingTimeConstant_(DEFAULT_SMOOTHING_TIME_CONSTANT),
+      vWriteIndex_(0) {
+  inputBuffer_ = std::make_unique<AudioArray>(MAX_FFT_SIZE * 2);
+  fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
+  isInitialized_ = true;
+}
+
+size_t AnalyserNode::getFftSize() const {
+  return fftSize_;
+}
+
+size_t AnalyserNode::getFrequencyBinCount() const {
+  return fftSize_ / 2;
+}
+
+double AnalyserNode::getMinDecibels() const {
+  return minDecibels_;
+}
+
+double AnalyserNode::getMaxDecibels() const {
+  return maxDecibels_;
+}
+
+double AnalyserNode::getSmoothingTimeConstant() const {
+  return smoothingTimeConstant_;
+}
+
+void AnalyserNode::setFftSize(size_t fftSize) {
+  if (fftSize_ == fftSize) {
+    return;
+  }
+
+  fftSize_ = fftSize;
+  fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
+}
+
+void AnalyserNode::setMinDecibels(double minDecibels) {
+  minDecibels_ = minDecibels;
+}
+
+void AnalyserNode::setMaxDecibels(double maxDecibels) {
+  maxDecibels_ = maxDecibels;
+}
+
+void AnalyserNode::setSmoothingTimeConstant(double smoothingTimeConstant) {
+  smoothingTimeConstant_ = smoothingTimeConstant;
+}
+
+void AnalyserNode::getFloatFrequencyData(float *data, size_t length) {
+  doFFTAnalysis();
+
+  length = std::min<size_t>(magnitudeBuffer_->getSize(), length);
+  VectorMath::linearToDecibels(magnitudeBuffer_->getData(), data, length);
+}
+
+void AnalyserNode::getByteFrequencyData(uint8_t *data, size_t length) {
+  doFFTAnalysis();
+
+  auto magnitudeBufferData = magnitudeBuffer_->getData();
+  length = std::min<size_t>(magnitudeBuffer_->getSize(), length);
+
+  const auto rangeScaleFactor =
+      maxDecibels_ == minDecibels_ ? 1 : 1 / (maxDecibels_ - minDecibels_);
+
+  for (size_t i = 0; i < length; i++) {
+    auto dbMag = magnitudeBufferData[i] == 0
+        ? minDecibels_
+        : AudioUtils::linearToDecibels(magnitudeBufferData[i]);
+    auto scaledValue = UINT8_MAX * (dbMag - minDecibels_) * rangeScaleFactor;
+
+    if (scaledValue < 0) {
+      scaledValue = 0;
+    }
+    if (scaledValue > UINT8_MAX) {
+      scaledValue = UINT8_MAX;
+    }
+
+    data[i] = static_cast<uint8_t>(scaledValue);
+  }
+}
+
+void AnalyserNode::getFloatTimeDomainData(float *data, size_t length) {
+  auto size = std::min(fftSize_, length);
+
+  for (size_t i = 0; i < size; i++) {
+    data[i] = inputBuffer_->getData()
+                  [(vWriteIndex_ + i - fftSize_ + inputBuffer_->getSize()) %
+                   inputBuffer_->getSize()];
+  }
+}
+
+void AnalyserNode::getByteTimeDomainData(uint8_t *data, size_t length) {
+  auto size = std::min(fftSize_, length);
+
+  for (size_t i = 0; i < size; i++) {
+    auto value = inputBuffer_->getData()
+                     [(vWriteIndex_ + i - fftSize_ + inputBuffer_->getSize()) %
+                      inputBuffer_->getSize()];
+
+    float scaledValue = 128 * (value + 1);
+
+    if (scaledValue < 0) {
+      scaledValue = 0;
+    }
+    if (scaledValue > UINT8_MAX) {
+      scaledValue = UINT8_MAX;
+    }
+
+    data[i] = static_cast<uint8_t>(scaledValue);
+  }
+}
+
+void AnalyserNode::processNode(
+    audioapi::AudioBus *processingBus,
+    int framesToProcess) {
+  if (!isInitialized_) {
+    processingBus->zero();
+    return;
+  }
+
+  // Analyser should behave like a sniffer node, it should not modify the
+  // processingBus but instead copy the data to its own input buffer.
+
+  if (downMixBus_ == nullptr) {
+    downMixBus_ = std::make_unique<AudioBus>(
+        context_->getSampleRate(), processingBus->getSize(), 1);
+  }
+
+  downMixBus_->copy(processingBus);
+
+  if (vWriteIndex_ + framesToProcess > inputBuffer_->getSize()) {
+    auto framesToCopy = inputBuffer_->getSize() - vWriteIndex_;
+    memcpy(
+        inputBuffer_->getData() + vWriteIndex_,
+        downMixBus_->getChannel(0)->getData(),
+        framesToCopy * sizeof(float));
+
+    vWriteIndex_ = 0;
+    framesToProcess -= framesToCopy;
+  }
+
+  memcpy(
+      inputBuffer_->getData() + vWriteIndex_,
+      downMixBus_->getChannel(0)->getData(),
+      framesToProcess * sizeof(float));
+
+  vWriteIndex_ += framesToProcess;
+  if (vWriteIndex_ >= inputBuffer_->getSize()) {
+    vWriteIndex_ = 0;
+  }
+
+  shouldDoFFTAnalysis_ = true;
+}
+
+void AnalyserNode::doFFTAnalysis() {
+  if (!shouldDoFFTAnalysis_) {
+    return;
+  }
+
+  shouldDoFFTAnalysis_ = false;
+
+  // We need to copy the fftSize elements from input buffer to a temporary
+  // buffer to apply the window.
+  AudioArray tempBuffer(this->fftSize_);
+
+  // We want to copy last fftSize_ elements added to the input buffer(fftSize_
+  // elements before vWriteIndex_). However inputBuffer_ works like a circular
+  // buffer so we have two cases to consider.
+  if (vWriteIndex_ < fftSize_) {
+    tempBuffer.copy(
+        inputBuffer_.get(),
+        vWriteIndex_ - fftSize_ + inputBuffer_->getSize(),
+        0,
+        fftSize_ - vWriteIndex_);
+    tempBuffer.copy(
+        inputBuffer_.get(), 0, fftSize_ - vWriteIndex_, vWriteIndex_);
+  } else {
+    tempBuffer.copy(inputBuffer_.get(), vWriteIndex_ - fftSize_, 0, fftSize_);
+  }
+
+  AnalyserNode::applyWindow(tempBuffer.getData(), fftSize_);
+
+  // do fft analysis - get frequency domain data
+  fftFrame_->doFFT(tempBuffer.getData());
+
+  auto *realFFTFrameData = fftFrame_->getRealData();
+  auto *imaginaryFFTFrameData = fftFrame_->getImaginaryData();
+
+  // Zero out nquist component
+  imaginaryFFTFrameData[0] = 0.0f;
+
+  const float magnitudeScale = 1.0f / static_cast<float>(fftSize_);
+  auto magnitudeBufferData = magnitudeBuffer_->getData();
+
+  for (size_t i = 0; i < magnitudeBuffer_->getSize(); i++) {
+    std::complex<float> c(realFFTFrameData[i], imaginaryFFTFrameData[i]);
+    auto scalarMagnitude = std::abs(c) * magnitudeScale;
+    magnitudeBufferData[i] = static_cast<float>(
+        smoothingTimeConstant_ * magnitudeBufferData[i] +
+        (1 - smoothingTimeConstant_) * scalarMagnitude);
+  }
+}
+
+void AnalyserNode::applyWindow(float *data, size_t length) {
+  // https://www.sciencedirect.com/topics/engineering/blackman-window
+  auto alpha = 0.16f;
+  auto a0 = 0.5f * (1 - alpha);
+  auto a1 = 0.5f;
+  auto a2 = 0.5f * alpha;
+
+  for (int i = 0; i < length; ++i) {
+    auto x = static_cast<float>(i) / static_cast<float>(length);
+    auto window = a0 - a1 * cos(2 * static_cast<float>(M_PI) * x) +
+        a2 * cos(4 * static_cast<float>(M_PI) * x);
+    data[i] *= window;
+  }
+}
+} // namespace audioapi

package/common/cpp/core/AnalyserNode.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNode.h"
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+class FFTFrame;
+
+class AnalyserNode : public AudioNode {
+ public:
+  explicit AnalyserNode(BaseAudioContext *context);
+
+  size_t getFftSize() const;
+  size_t getFrequencyBinCount() const;
+  double getMinDecibels() const;
+  double getMaxDecibels() const;
+
+  double getSmoothingTimeConstant() const;
+  void setFftSize(size_t fftSize);
+  void setMinDecibels(double minDecibels);
+  void setMaxDecibels(double maxDecibels);
+  void setSmoothingTimeConstant(double smoothingTimeConstant);
+
+  void getFloatFrequencyData(float *data, size_t length);
+  void getByteFrequencyData(uint8_t *data, size_t length);
+  void getFloatTimeDomainData(float *data, size_t length);
+  void getByteTimeDomainData(uint8_t *data, size_t length);
+
+ protected:
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
+
+ private:
+  size_t fftSize_;
+  double minDecibels_;
+  double maxDecibels_;
+  double smoothingTimeConstant_;
+
+  std::unique_ptr<AudioArray> inputBuffer_;
+  std::unique_ptr<AudioBus> downMixBus_;
+  int vWriteIndex_;
+
+  std::unique_ptr<FFTFrame> fftFrame_;
+  std::unique_ptr<AudioArray> magnitudeBuffer_;
+  bool shouldDoFFTAnalysis_ { true };
+
+    void doFFTAnalysis();
+    static void applyWindow(float *data, size_t length);
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioNode.cpp

@@ -126,7 +126,7 @@ AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
   // - 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 != nullptr && inputNodes_.size() < 2 && outputNodes_.size() < 2;
 
   if (isAlreadyProcessed) {
     // If it was already processed in the rendering quantum, return it.
@@ -144,8 +144,9 @@ 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, if processing node is the source node,
+    // it will fill processing bus with the audio data, otherwise it will return
+    // silence.
     processNode(processingBus, framesToProcess);
     return processingBus;
   }
@@ -214,7 +215,7 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
     inputNodes_.erase(position);
   }
 
-  if (inputNodes_.size() > 0) {
+  if (!inputNodes_.empty()) {
     return;
   }
 
@@ -222,7 +223,7 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
     node->onInputDisabled();
   }
 
-  for (auto outputNode : outputNodes_) {
+  for (const auto &outputNode : outputNodes_) {
     disconnectNode(outputNode);
   }
 }

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -85,8 +85,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     startOffset = std::max(startFrame, firstFrame) - firstFrame > 0
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
-    nonSilentFramesToProcess =
-        std::min(lastFrame, stopFrame) - startFrame;
+    nonSilentFramesToProcess = std::min(lastFrame, stopFrame) - startFrame;
     processingBus->zero(0, startOffset);
     return;
   }

package/common/cpp/core/BaseAudioContext.cpp

@@ -6,6 +6,7 @@
 
 #include "BaseAudioContext.h"
 
+#include "AnalyserNode.h"
 #include "AudioArray.h"
 #include "AudioBuffer.h"
 #include "AudioBufferSourceNode.h"
@@ -106,6 +107,10 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
       sampleRate_, real, imag, length, disableNormalization);
 }
 
+std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
+  return std::make_shared<AnalyserNode>(this);
+}
+
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
     const std::string &path) {
   auto audioBus = audioDecoder_->decodeWithFilePath(path);

package/common/cpp/core/BaseAudioContext.h

@@ -22,6 +22,7 @@ class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioDecoder;
+class AnalyserNode;
 
 #ifdef ANDROID
 class AudioPlayer;
@@ -53,6 +54,7 @@ class BaseAudioContext {
       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);

package/common/cpp/core/Constants.h

@@ -6,10 +6,12 @@
 // https://webaudio.github.io/web-audio-api/
 
 namespace audioapi {
-constexpr int SAMPLE_RATE = 44100;
+constexpr int SAMPLE_RATE = 48000;
 constexpr int CHANNEL_COUNT = 2;
+
 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 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;
@@ -19,4 +21,10 @@ constexpr float MAX_FILTER_FREQUENCY = NYQUIST_FREQUENCY;
 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;
+
+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;
 } // namespace audioapi

package/common/cpp/core/PeriodicWave.cpp

@@ -226,7 +226,7 @@ void PeriodicWave::createBandLimitedTables(
           0.0f);
     }
 
-    // Zero out the nquist and DC components.
+    // Zero out the DC and nquist components.
     realFFTFrameData[0] = 0.0f;
     imaginaryFFTFrameData[0] = 0.0f;
 
@@ -234,7 +234,7 @@ void PeriodicWave::createBandLimitedTables(
 
     // Perform the inverse FFT to get the time domain representation of the
     // band-limited waveform.
-    fftFrame.inverse(bandLimitedTables_[rangeIndex]);
+    fftFrame.doInverseFFT(bandLimitedTables_[rangeIndex]);
 
     if (!disableNormalization_ && rangeIndex == 0) {
       float maxValue =

package/common/cpp/utils/AudioUtils.cpp

@@ -23,4 +23,11 @@ float linearInterpolate(
       factor * (source[secondIndex] - source[firstIndex]);
 }
 
+float linearToDecibels(float value) {
+  return 20 * log10f(value);
+}
+
+float decibelsToLinear(float value) {
+  return powf(10, value / 20);
+}
 } // namespace audioapi::AudioUtils

package/common/cpp/utils/AudioUtils.h

@@ -1,12 +1,16 @@
 #pragma once
 
 #include <cstddef>
+#include <cstdint>
+#include <cmath>
 
 namespace audioapi::AudioUtils {
-size_t timeToSampleFrame(double time, int sampleRate);
 
+size_t timeToSampleFrame(double time, int sampleRate);
 double sampleFrameToTime(int sampleFrame, int sampleRate);
 
 float linearInterpolate(const float *source, size_t firstIndex, size_t secondIndex, float factor);
 
+float linearToDecibels(float value);
+float decibelsToLinear(float value);
 } // namespace audioapi::AudioUtils