react-native-audio-api 0.3.2 → 0.4.1

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/android/src/main/cpp/core/AudioPlayer.cpp

@@ -21,17 +21,36 @@ AudioPlayer::AudioPlayer(
       ->setDataCallback(this)
       ->openStream(mStream_);
 
+  sampleRate_ = mStream_->getSampleRate();
   mBus_ = std::make_shared<AudioBus>(
-      getSampleRate(), getBufferSizeInFrames(), CHANNEL_COUNT);
+      sampleRate_, RENDER_QUANTUM_SIZE, CHANNEL_COUNT);
   isInitialized_ = true;
 }
 
-int AudioPlayer::getSampleRate() const {
-  return mStream_->getSampleRate();
+AudioPlayer::AudioPlayer(
+    const std::function<void(AudioBus *, int)> &renderAudio,
+    int sampleRate)
+    : renderAudio_(renderAudio) {
+  AudioStreamBuilder builder;
+
+  builder.setSharingMode(SharingMode::Exclusive)
+      ->setFormat(AudioFormat::Float)
+      ->setFormatConversionAllowed(true)
+      ->setPerformanceMode(PerformanceMode::LowLatency)
+      ->setChannelCount(CHANNEL_COUNT)
+      ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
+      ->setDataCallback(this)
+      ->setSampleRate(sampleRate)
+      ->openStream(mStream_);
+
+  sampleRate_ = sampleRate;
+  mBus_ = std::make_shared<AudioBus>(
+      sampleRate_, RENDER_QUANTUM_SIZE, CHANNEL_COUNT);
+  isInitialized_ = true;
 }
 
-int AudioPlayer::getBufferSizeInFrames() const {
-  return mStream_->getBufferSizeInFrames();
+int AudioPlayer::getSampleRate() const {
+  return sampleRate_;
 }
 
 void AudioPlayer::start() {
@@ -59,14 +78,22 @@ DataCallbackResult AudioPlayer::onAudioReady(
   }
 
   auto buffer = static_cast<float *>(audioData);
-  renderAudio_(mBus_.get(), numFrames);
+  int processedFrames = 0;
 
-  // TODO: optimize this with SIMD?
-  for (int32_t i = 0; i < numFrames; i += 1) {
-    for (int channel = 0; channel < CHANNEL_COUNT; channel += 1) {
-      buffer[i * CHANNEL_COUNT + channel] =
-          mBus_->getChannel(channel)->getData()[i];
+  while (processedFrames < numFrames) {
+    int framesToProcess =
+        std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
+    renderAudio_(mBus_.get(), framesToProcess);
+
+    // TODO: optimize this with SIMD?
+    for (int i = 0; i < framesToProcess; i++) {
+      for (int channel = 0; channel < CHANNEL_COUNT; channel += 1) {
+        buffer[(processedFrames + i) * CHANNEL_COUNT + channel] =
+            mBus_->getChannel(channel)->getData()[i];
+      }
     }
+
+    processedFrames += framesToProcess;
   }
 
   return DataCallbackResult::Continue;

package/android/src/main/cpp/core/AudioPlayer.h

@@ -2,6 +2,7 @@
 
 #include <oboe/Oboe.h>
 #include <memory>
+#include <functional>
 
 namespace audioapi {
 
@@ -13,9 +14,11 @@ class AudioBus;
 class AudioPlayer : public AudioStreamDataCallback {
  public:
   explicit AudioPlayer(const std::function<void(AudioBus *, int)> &renderAudio);
+  AudioPlayer(
+      const std::function<void(AudioBus *, int)> &renderAudio,
+      int sampleRate);
 
   [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] int getBufferSizeInFrames() const;
   void start();
   void stop();
 
@@ -29,6 +32,7 @@ class AudioPlayer : public AudioStreamDataCallback {
   std::shared_ptr<AudioStream> mStream_;
   std::shared_ptr<AudioBus> mBus_;
   bool isInitialized_ = false;
+  int sampleRate_;
 };
 
 } // namespace audioapi

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/AudioAPIInstallerHostObject.h

@@ -35,10 +35,18 @@ class AudioAPIInstallerHostObject
   }
 
   JSI_HOST_FUNCTION(createAudioContext) {
-    auto audioContext = std::make_shared<AudioContext>();
-    auto audioContextHostObject =
+      std::shared_ptr<AudioContext> audioContext;
+      if (args[0].isUndefined()) {
+          audioContext = std::make_shared<AudioContext>();
+      } else {
+          int sampleRate = static_cast<int>(args[0].getNumber());
+          audioContext = std::make_shared<AudioContext>(sampleRate);
+      }
+
+      auto audioContextHostObject =
         std::make_shared<AudioContextHostObject>(audioContext, promiseVendor_);
-    return jsi::Object::createFromHostObject(runtime, audioContextHostObject);
+
+      return jsi::Object::createFromHostObject(runtime, audioContextHostObject);
   }
 
  private:

package/common/cpp/HostObjects/AudioNodeHostObject.h

@@ -54,6 +54,11 @@ class AudioNodeHostObject : public JsiHostObject {
   }
 
   JSI_HOST_FUNCTION(disconnect) {
+      if(args[0].isUndefined()) {
+          node_->disconnect();
+          return jsi::Value::undefined();
+      }
+
     auto node =
         args[0].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
     node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);

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