react-native-audio-api 0.4.0 → 0.4.2

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

@@ -21,17 +21,36 @@ AudioPlayer::AudioPlayer(
       ->setDataCallback(this)
       ->openStream(mStream_);
 
+  sampleRate_ = static_cast<float>(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,
+    float 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(static_cast<int>(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();
+float 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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <oboe/Oboe.h>
+#include <functional>
 #include <memory>
 
 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,
+      float sampleRate);
 
-  [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] int getBufferSizeInFrames() const;
+  [[nodiscard]] float getSampleRate() 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;
+  float sampleRate_;
 };
 
 } // namespace audioapi

package/common/cpp/HostObjects/AnalyserNodeHostObject.h

@@ -19,7 +19,8 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
         JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, frequencyBinCount),
         JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, minDecibels),
         JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, maxDecibels),
-        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, smoothingTimeConstant));
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, smoothingTimeConstant),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, window));
 
     addFunctions(
         JSI_EXPORT_FUNCTION(
@@ -36,7 +37,8 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
         JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, minDecibels),
         JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, maxDecibels),
         JSI_EXPORT_PROPERTY_SETTER(
-            AnalyserNodeHostObject, smoothingTimeConstant));
+            AnalyserNodeHostObject, smoothingTimeConstant),
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, window));
   }
 
   JSI_PROPERTY_GETTER(fftSize) {
@@ -64,6 +66,12 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
     return {analyserNode->getSmoothingTimeConstant()};
   }
 
+  JSI_PROPERTY_GETTER(window) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto windowType = analyserNode->getWindowType();
+    return jsi::String::createFromUtf8(runtime, windowType);
+  }
+
   JSI_HOST_FUNCTION(getFloatFrequencyData) {
       auto destination = args[0].getObject(runtime).asArray(runtime);
       auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
@@ -126,26 +134,31 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
 
   JSI_PROPERTY_SETTER(fftSize) {
     auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    auto fftSize = static_cast<size_t>(value.getNumber());
+    auto fftSize = static_cast<int>(value.getNumber());
     analyserNode->setFftSize(fftSize);
   }
 
   JSI_PROPERTY_SETTER(minDecibels) {
     auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    auto minDecibels = static_cast<int>(value.getNumber());
+    auto minDecibels = static_cast<float>(value.getNumber());
     analyserNode->setMinDecibels(minDecibels);
   }
 
   JSI_PROPERTY_SETTER(maxDecibels) {
     auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-      auto maxDecibels = static_cast<int>(value.getNumber());
+      auto maxDecibels = static_cast<float>(value.getNumber());
       analyserNode->setMaxDecibels(maxDecibels);
   }
 
   JSI_PROPERTY_SETTER(smoothingTimeConstant) {
     auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    auto smoothingTimeConstant = static_cast<int>(value.getNumber());
+    auto smoothingTimeConstant = static_cast<float>(value.getNumber());
     analyserNode->setSmoothingTimeConstant(smoothingTimeConstant);
   }
+
+  JSI_PROPERTY_SETTER(window) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->setWindowType(value.getString(runtime).utf8(runtime));
+  }
 };
 } // 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 {
+          auto sampleRate = static_cast<float>(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/AudioBufferHostObject.h

@@ -3,6 +3,7 @@
 #include <jsi/jsi.h>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 #include <JsiHostObject.h>
 #include "AudioBuffer.h"
@@ -34,7 +35,7 @@ class AudioBufferHostObject : public JsiHostObject {
   }
 
   JSI_PROPERTY_GETTER(length) {
-    return {audioBuffer_->getLength()};
+    return {static_cast<double>(audioBuffer_->getLength())};
   }
 
   JSI_PROPERTY_GETTER(duration) {
@@ -60,9 +61,9 @@ class AudioBufferHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION(copyFromChannel) {
     auto destination = args[0].getObject(runtime).asArray(runtime);
     auto destinationLength =
-        static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+        static_cast<size_t>(destination.getProperty(runtime, "length").asNumber());
     auto channelNumber = static_cast<int>(args[1].getNumber());
-    auto startInChannel = static_cast<int>(args[2].getNumber());
+    auto startInChannel = static_cast<size_t>(args[2].getNumber());
 
     auto *destinationData = new float[destinationLength];
 
@@ -79,9 +80,9 @@ class AudioBufferHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION(copyToChannel) {
     auto source = args[0].getObject(runtime).asArray(runtime);
     auto sourceLength =
-        static_cast<int>(source.getProperty(runtime, "length").asNumber());
+        static_cast<size_t>(source.getProperty(runtime, "length").asNumber());
     auto channelNumber = static_cast<int>(args[1].getNumber());
-    auto startInChannel = static_cast<int>(args[2].getNumber());
+    auto startInChannel = static_cast<size_t>(args[2].getNumber());
 
     auto *sourceData = new float[sourceLength];
 

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

@@ -3,6 +3,7 @@
 #include <jsi/jsi.h>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 #include <JsiHostObject.h>
 #include "AudioParam.h"
@@ -79,7 +80,7 @@ class AudioParamHostObject : public JsiHostObject {
 
   JSI_HOST_FUNCTION(setValueCurveAtTime) {
     auto values = args[0].getObject(runtime).asArray(runtime);
-    auto length = static_cast<int>(values.length(runtime));
+    auto length = static_cast<size_t>(values.length(runtime));
     auto valuesData = new float[length];
     for (size_t i = 0; i < values.length(runtime); i++) {
       valuesData[i] =

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -4,6 +4,7 @@
 #include <memory>
 #include <utility>
 #include <vector>
+#include <cstddef>
 
 #include <JsiHostObject.h>
 #include <JsiPromise.h>
@@ -100,9 +101,9 @@ class BaseAudioContextHostObject : public JsiHostObject {
 
   JSI_HOST_FUNCTION(createBuffer) {
     auto numberOfChannels = static_cast<int>(args[0].getNumber());
-    auto length = static_cast<int>(args[1].getNumber());
-    auto sampleRate = static_cast<int>(args[2].getNumber());
-    auto buffer = context_->createBuffer(numberOfChannels, length, sampleRate);
+    auto length = static_cast<size_t>(args[1].getNumber());
+    auto sampleRate = static_cast<float>(args[2].getNumber());
+    auto buffer = BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
     auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
     return jsi::Object::createFromHostObject(runtime, bufferHostObject);
   }

package/common/cpp/core/AnalyserNode.cpp

@@ -16,34 +16,43 @@ AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
       minDecibels_(DEFAULT_MIN_DECIBELS),
       maxDecibels_(DEFAULT_MAX_DECIBELS),
       smoothingTimeConstant_(DEFAULT_SMOOTHING_TIME_CONSTANT),
+      windowType_(WindowType::BLACKMAN),
       vWriteIndex_(0) {
   inputBuffer_ = std::make_unique<AudioArray>(MAX_FFT_SIZE * 2);
-  fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
+  downMixBus_ = std::make_unique<AudioBus>(
+      context_->getSampleRate(), RENDER_QUANTUM_SIZE, 1);
+
+  fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+
   isInitialized_ = true;
 }
 
-size_t AnalyserNode::getFftSize() const {
+int AnalyserNode::getFftSize() const {
   return fftSize_;
 }
 
-size_t AnalyserNode::getFrequencyBinCount() const {
+int AnalyserNode::getFrequencyBinCount() const {
   return fftSize_ / 2;
 }
 
-double AnalyserNode::getMinDecibels() const {
+float AnalyserNode::getMinDecibels() const {
   return minDecibels_;
 }
 
-double AnalyserNode::getMaxDecibels() const {
+float AnalyserNode::getMaxDecibels() const {
   return maxDecibels_;
 }
 
-double AnalyserNode::getSmoothingTimeConstant() const {
+float AnalyserNode::getSmoothingTimeConstant() const {
   return smoothingTimeConstant_;
 }
 
-void AnalyserNode::setFftSize(size_t fftSize) {
+std::string AnalyserNode::getWindowType() const {
+  return AnalyserNode::toString(windowType_);
+}
+
+void AnalyserNode::setFftSize(int fftSize) {
   if (fftSize_ == fftSize) {
     return;
   }
@@ -53,35 +62,39 @@ void AnalyserNode::setFftSize(size_t fftSize) {
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
 }
 
-void AnalyserNode::setMinDecibels(double minDecibels) {
+void AnalyserNode::setMinDecibels(float minDecibels) {
   minDecibels_ = minDecibels;
 }
 
-void AnalyserNode::setMaxDecibels(double maxDecibels) {
+void AnalyserNode::setMaxDecibels(float maxDecibels) {
   maxDecibels_ = maxDecibels;
 }
 
-void AnalyserNode::setSmoothingTimeConstant(double smoothingTimeConstant) {
+void AnalyserNode::setSmoothingTimeConstant(float smoothingTimeConstant) {
   smoothingTimeConstant_ = smoothingTimeConstant;
 }
 
-void AnalyserNode::getFloatFrequencyData(float *data, size_t length) {
+void AnalyserNode::setWindowType(const std::string &type) {
+  windowType_ = AnalyserNode::fromString(type);
+}
+
+void AnalyserNode::getFloatFrequencyData(float *data, int length) {
   doFFTAnalysis();
 
-  length = std::min<size_t>(magnitudeBuffer_->getSize(), length);
+  length = std::min(static_cast<int>(magnitudeBuffer_->getSize()), length);
   VectorMath::linearToDecibels(magnitudeBuffer_->getData(), data, length);
 }
 
-void AnalyserNode::getByteFrequencyData(uint8_t *data, size_t length) {
+void AnalyserNode::getByteFrequencyData(uint8_t *data, int length) {
   doFFTAnalysis();
 
   auto magnitudeBufferData = magnitudeBuffer_->getData();
-  length = std::min<size_t>(magnitudeBuffer_->getSize(), length);
+  length = std::min(static_cast<int>(magnitudeBuffer_->getSize()), length);
 
   const auto rangeScaleFactor =
       maxDecibels_ == minDecibels_ ? 1 : 1 / (maxDecibels_ - minDecibels_);
 
-  for (size_t i = 0; i < length; i++) {
+  for (int i = 0; i < length; i++) {
     auto dbMag = magnitudeBufferData[i] == 0
         ? minDecibels_
         : AudioUtils::linearToDecibels(magnitudeBufferData[i]);
@@ -98,20 +111,20 @@ void AnalyserNode::getByteFrequencyData(uint8_t *data, size_t length) {
   }
 }
 
-void AnalyserNode::getFloatTimeDomainData(float *data, size_t length) {
+void AnalyserNode::getFloatTimeDomainData(float *data, int length) {
   auto size = std::min(fftSize_, length);
 
-  for (size_t i = 0; i < size; i++) {
+  for (int 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) {
+void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
   auto size = std::min(fftSize_, length);
 
-  for (size_t i = 0; i < size; i++) {
+  for (int i = 0; i < size; i++) {
     auto value = inputBuffer_->getData()
                      [(vWriteIndex_ + i - fftSize_ + inputBuffer_->getSize()) %
                       inputBuffer_->getSize()];
@@ -140,15 +153,11 @@ void AnalyserNode::processNode(
   // 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_;
+    auto framesToCopy =
+        static_cast<int>(inputBuffer_->getSize()) - vWriteIndex_;
     memcpy(
         inputBuffer_->getData() + vWriteIndex_,
         downMixBus_->getChannel(0)->getData(),
@@ -197,7 +206,14 @@ void AnalyserNode::doFFTAnalysis() {
     tempBuffer.copy(inputBuffer_.get(), vWriteIndex_ - fftSize_, 0, fftSize_);
   }
 
-  AnalyserNode::applyWindow(tempBuffer.getData(), fftSize_);
+  switch (windowType_) {
+    case WindowType::BLACKMAN:
+      AnalyserNode::applyBlackManWindow(tempBuffer.getData(), fftSize_);
+      break;
+    case WindowType::HANN:
+      AnalyserNode::applyHannWindow(tempBuffer.getData(), fftSize_);
+      break;
+  }
 
   // do fft analysis - get frequency domain data
   fftFrame_->doFFT(tempBuffer.getData());
@@ -211,7 +227,7 @@ void AnalyserNode::doFFTAnalysis() {
   const float magnitudeScale = 1.0f / static_cast<float>(fftSize_);
   auto magnitudeBufferData = magnitudeBuffer_->getData();
 
-  for (size_t i = 0; i < magnitudeBuffer_->getSize(); i++) {
+  for (int 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>(
@@ -220,17 +236,23 @@ void AnalyserNode::doFFTAnalysis() {
   }
 }
 
-void AnalyserNode::applyWindow(float *data, size_t length) {
+void AnalyserNode::applyBlackManWindow(float *data, int 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;
+  // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.blackman.html#scipy.signal.windows.blackman
 
   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);
+    auto window = 0.42f - 0.5f * cos(2 * PI * x) + 0.08f * cos(4 * PI * x);
+    data[i] *= window;
+  }
+}
+
+void AnalyserNode::applyHannWindow(float *data, int length) {
+  // https://www.sciencedirect.com/topics/engineering/hanning-window
+  // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.hann.html#scipy.signal.windows.hann
+  for (int i = 0; i < length; ++i) {
+    auto x = static_cast<float>(i) / static_cast<float>(length - 1);
+    auto window = 0.5f - 0.5f * cos(2 * PI * x);
     data[i] *= window;
   }
 }

package/common/cpp/core/AnalyserNode.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <memory>
+#include <cstddef>
+#include <string>
 
 #include "AudioNode.h"
 
@@ -12,32 +14,36 @@ class FFTFrame;
 
 class AnalyserNode : public AudioNode {
  public:
+  enum class WindowType { BLACKMAN, HANN };
   explicit AnalyserNode(BaseAudioContext *context);
 
-  size_t getFftSize() const;
-  size_t getFrequencyBinCount() const;
-  double getMinDecibels() const;
-  double getMaxDecibels() const;
+  int getFftSize() const;
+  int getFrequencyBinCount() const;
+  float getMinDecibels() const;
+  float getMaxDecibels() const;
+  float getSmoothingTimeConstant() const;
+  std::string getWindowType() const;
 
-  double getSmoothingTimeConstant() const;
-  void setFftSize(size_t fftSize);
-  void setMinDecibels(double minDecibels);
-  void setMaxDecibels(double maxDecibels);
-  void setSmoothingTimeConstant(double smoothingTimeConstant);
+  void setFftSize(int fftSize);
+  void setMinDecibels(float minDecibels);
+  void setMaxDecibels(float maxDecibels);
+  void setSmoothingTimeConstant(float smoothingTimeConstant);
+  void setWindowType(const std::string &type);
 
-  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);
+  void getFloatFrequencyData(float *data, int length);
+  void getByteFrequencyData(uint8_t *data, int length);
+  void getFloatTimeDomainData(float *data, int length);
+  void getByteTimeDomainData(uint8_t *data, int length);
 
  protected:
   void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
-  size_t fftSize_;
-  double minDecibels_;
-  double maxDecibels_;
-  double smoothingTimeConstant_;
+  int fftSize_;
+  float minDecibels_;
+  float maxDecibels_;
+  float smoothingTimeConstant_;
+  WindowType windowType_;
 
   std::unique_ptr<AudioArray> inputBuffer_;
   std::unique_ptr<AudioBus> downMixBus_;
@@ -47,8 +53,34 @@ class AnalyserNode : public AudioNode {
   std::unique_ptr<AudioArray> magnitudeBuffer_;
   bool shouldDoFFTAnalysis_ { true };
 
-    void doFFTAnalysis();
-    static void applyWindow(float *data, size_t length);
+  static WindowType fromString(const std::string &type) {
+    std::string lowerType = type;
+    std::transform(
+        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+    if (lowerType == "blackman") {
+      return WindowType::BLACKMAN;
+    }
+    if (lowerType == "hann") {
+      return WindowType::HANN;
+    }
+
+    throw std::invalid_argument("Unknown window type");
+  }
+
+  static std::string toString(WindowType type) {
+    switch (type) {
+      case WindowType::BLACKMAN:
+        return "blackman";
+      case WindowType::HANN:
+        return "hann";
+      default:
+        throw std::invalid_argument("Unknown window type");
+    }
+  }
+
+  void doFFTAnalysis();
+  static void applyBlackManWindow(float *data, int length);
+  static void applyHannWindow(float *data, int length);
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioArray.cpp

@@ -5,7 +5,7 @@
 
 namespace audioapi {
 
-AudioArray::AudioArray(int size) : data_(nullptr), size_(size) {
+AudioArray::AudioArray(size_t size) : data_(nullptr), size_(size) {
   resize(size);
 }
 
@@ -16,7 +16,7 @@ AudioArray::~AudioArray() {
   }
 }
 
-int AudioArray::getSize() const {
+size_t AudioArray::getSize() const {
   return size_;
 }
 
@@ -24,11 +24,11 @@ float *AudioArray::getData() const {
   return data_;
 }
 
-float &AudioArray::operator[](int index) {
+float &AudioArray::operator[](size_t index) {
   return data_[index];
 }
 
-const float &AudioArray::operator[](int index) const {
+const float &AudioArray::operator[](size_t index) const {
   return data_[index];
 }
 
@@ -42,7 +42,7 @@ void AudioArray::normalize() {
   VectorMath::multiplyByScalar(data_, 1.0f / maxAbsValue, data_, size_);
 }
 
-void AudioArray::resize(int size) {
+void AudioArray::resize(size_t size) {
   if (size == size_) {
     if (!data_) {
       data_ = new float[size];
@@ -71,7 +71,7 @@ void AudioArray::zero() {
   zero(0, size_);
 }
 
-void AudioArray::zero(int start, int length) {
+void AudioArray::zero(size_t start, size_t length) {
   memset(data_ + start, 0, length * sizeof(float));
 }
 
@@ -79,15 +79,15 @@ void AudioArray::sum(const AudioArray *source) {
   sum(source, 0, 0, size_);
 }
 
-void AudioArray::sum(const AudioArray *source, int start, int length) {
+void AudioArray::sum(const AudioArray *source, size_t start, size_t length) {
   sum(source, start, start, length);
 }
 
 void AudioArray::sum(
     const AudioArray *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   VectorMath::add(
       data_ + destinationStart,
       source->getData() + sourceStart,
@@ -99,15 +99,15 @@ void AudioArray::copy(const AudioArray *source) {
   copy(source, 0, size_);
 }
 
-void AudioArray::copy(const AudioArray *source, int start, int length) {
+void AudioArray::copy(const AudioArray *source, size_t start, size_t length) {
   copy(source, start, start, length);
 }
 
 void AudioArray::copy(
     const AudioArray *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   memcpy(
       data_ + destinationStart,
       source->getData() + sourceStart,