react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/HostObjects/BiquadFilterNodeHostObject.cpp

@@ -0,0 +1,125 @@
+#include "BiquadFilterNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+std::shared_ptr<BiquadFilterNodeWrapper>
+BiquadFilterNodeHostObject::getBiquadFilterNodeWrapperFromAudioNodeWrapper() {
+  return std::static_pointer_cast<BiquadFilterNodeWrapper>(wrapper_);
+}
+
+BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
+    const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper)
+    : AudioNodeHostObject(wrapper) {
+  auto frequencyParam = wrapper->getFrequencyParam();
+  frequencyParam_ = AudioParamHostObject::createFromWrapper(frequencyParam);
+  auto detuneParam = wrapper->getDetuneParam();
+  detuneParam_ = AudioParamHostObject::createFromWrapper(detuneParam);
+  auto QParam = wrapper->getQParam();
+  QParam_ = AudioParamHostObject::createFromWrapper(QParam);
+  auto gainParam = wrapper->getGainParam();
+  gainParam_ = AudioParamHostObject::createFromWrapper(gainParam);
+}
+
+std::vector<jsi::PropNameID> BiquadFilterNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "frequency"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "detune"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "Q"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "gain"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "getFrequencyResponse"));
+  return propertyNames;
+}
+
+jsi::Value BiquadFilterNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "frequency") {
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
+
+  if (propName == "detune") {
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
+
+  if (propName == "Q") {
+    return jsi::Object::createFromHostObject(runtime, QParam_);
+  }
+
+  if (propName == "gain") {
+    return jsi::Object::createFromHostObject(runtime, gainParam_);
+  }
+
+  if (propName == "type") {
+    auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+    auto waveType = wrapper->getType();
+    return jsi::String::createFromUtf8(runtime, waveType);
+  }
+
+  if (propName == "getFrequencyResponse") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto frequencyArray = args[0].getObject(rt).asArray(rt);
+          auto magResponseOut = args[1].getObject(rt).asArray(rt);
+          auto phaseResponseOut = args[2].getObject(rt).asArray(rt);
+
+          std::vector<float> frequencyArrayVector(frequencyArray.length(rt));
+          for (size_t i = 0; i < frequencyArray.length(rt); i++) {
+            frequencyArrayVector[i] = static_cast<float>(
+                frequencyArray.getValueAtIndex(rt, i).getNumber());
+          }
+
+          std::vector<float> magResponseOutVector(magResponseOut.length(rt));
+          std::vector<float> phaseResponseOutVector(
+              phaseResponseOut.length(rt));
+
+          auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+          wrapper->getFrequencyResponse(
+              frequencyArrayVector,
+              magResponseOutVector,
+              phaseResponseOutVector);
+
+          for (size_t i = 0; i < magResponseOutVector.size(); i++) {
+            magResponseOut.setValueAtIndex(rt, i, magResponseOutVector[i]);
+          }
+
+          for (size_t i = 0; i < phaseResponseOutVector.size(); i++) {
+            phaseResponseOut.setValueAtIndex(rt, i, phaseResponseOutVector[i]);
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void BiquadFilterNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "type") {
+    std::string filterType = value.getString(runtime).utf8(runtime);
+    auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+    wrapper->setType(filterType);
+    return;
+  }
+
+  return AudioNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/BiquadFilterNodeHostObject.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "BiquadFilterNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class BiquadFilterNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit BiquadFilterNodeHostObject(
+      const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<BiquadFilterNodeHostObject> createFromWrapper(
+      const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper) {
+    return std::make_shared<BiquadFilterNodeHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamHostObject> frequencyParam_;
+  std::shared_ptr<AudioParamHostObject> detuneParam_;
+  std::shared_ptr<AudioParamHostObject> QParam_;
+  std::shared_ptr<AudioParamHostObject> gainParam_;
+
+  std::shared_ptr<BiquadFilterNodeWrapper>
+  getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+};
+} // namespace audioapi

package/common/cpp/HostObjects/Constants.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cmath>
+#include <limits>
+
+// https://webaudio.github.io/web-audio-api/
+
+namespace audioapi {
+constexpr int SAMPLE_RATE = 44100;
+constexpr int CHANNEL_COUNT = 2;
+constexpr float MOST_POSITIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::max());
+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;
+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_FILTER_FREQUENCY = 0.0;
+static float MAX_FILTER_GAIN = 40 * std::log10(MOST_POSITIVE_SINGLE_FLOAT);
+constexpr float MIN_FILTER_GAIN = -MAX_GAIN;
+} // namespace audioapi

package/common/cpp/HostObjects/GainNodeHostObject.cpp

@@ -0,0 +1,41 @@
+#include "GainNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+GainNodeHostObject::GainNodeHostObject(
+    const std::shared_ptr<GainNodeWrapper> &wrapper)
+    : AudioNodeHostObject(wrapper) {
+  auto gainParamWrapper = wrapper->getGainParam();
+  gainParam_ = AudioParamHostObject::createFromWrapper(gainParamWrapper);
+}
+
+std::vector<jsi::PropNameID> GainNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "gain"));
+  return propertyNames;
+}
+
+jsi::Value GainNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "gain") {
+    return jsi::Object::createFromHostObject(runtime, gainParam_);
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void GainNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  return AudioNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/GainNodeHostObject.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "GainNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class GainNodeHostObject : public AudioNodeHostObject {
+ protected:
+  std::shared_ptr<AudioParamHostObject> gainParam_;
+
+ public:
+  explicit GainNodeHostObject(const std::shared_ptr<GainNodeWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<GainNodeHostObject> createFromWrapper(
+      const std::shared_ptr<GainNodeWrapper> &wrapper) {
+    return std::make_shared<GainNodeHostObject>(wrapper);
+  }
+};
+} // namespace audioapi

package/common/cpp/HostObjects/OscillatorNodeHostObject.cpp

@@ -0,0 +1,88 @@
+#include "OscillatorNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+std::shared_ptr<OscillatorNodeWrapper>
+OscillatorNodeHostObject::getOscillatorNodeWrapperFromAudioNodeWrapper() {
+  return std::static_pointer_cast<OscillatorNodeWrapper>(wrapper_);
+}
+
+OscillatorNodeHostObject::OscillatorNodeHostObject(
+    const std::shared_ptr<OscillatorNodeWrapper> &wrapper)
+    : AudioScheduledSourceNodeHostObject(wrapper) {
+  auto frequencyParam = wrapper->getFrequencyParam();
+  frequencyParam_ = AudioParamHostObject::createFromWrapper(frequencyParam);
+  auto detuneParam = wrapper->getDetuneParam();
+  detuneParam_ = AudioParamHostObject::createFromWrapper(detuneParam);
+}
+
+std::vector<jsi::PropNameID> OscillatorNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioScheduledSourceNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "frequency"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "detune"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "setPeriodicWave"));
+  return propertyNames;
+}
+
+jsi::Value OscillatorNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "frequency") {
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
+
+  if (propName == "detune") {
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
+
+  if (propName == "type") {
+    auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
+    auto waveType = wrapper->getType();
+    return jsi::String::createFromUtf8(runtime, waveType);
+  }
+
+  if (propName == "setPeriodicWave") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
+          auto periodicWaveHostObject =
+              args[0].getObject(rt).asHostObject<PeriodicWaveHostObject>(rt);
+
+          wrapper->setPeriodicWave(periodicWaveHostObject->wrapper_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  return AudioScheduledSourceNodeHostObject::get(runtime, propNameId);
+}
+
+void OscillatorNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "type") {
+    std::string waveType = value.getString(runtime).utf8(runtime);
+    auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
+    wrapper->setType(waveType);
+    return;
+  }
+
+  return AudioScheduledSourceNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/OscillatorNodeHostObject.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AudioParamHostObject.h"
+#include "AudioScheduledSourceNodeHostObject.h"
+#include "OscillatorNodeWrapper.h"
+#include "PeriodicWaveHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit OscillatorNodeHostObject(
+      const std::shared_ptr<OscillatorNodeWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<OscillatorNodeHostObject> createFromWrapper(
+      const std::shared_ptr<OscillatorNodeWrapper> &wrapper) {
+    return std::make_shared<OscillatorNodeHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamHostObject> frequencyParam_;
+  std::shared_ptr<AudioParamHostObject> detuneParam_;
+
+  std::shared_ptr<OscillatorNodeWrapper>
+  getOscillatorNodeWrapperFromAudioNodeWrapper();
+};
+} // namespace audioapi

package/common/cpp/HostObjects/PeriodicWaveHostObject.cpp

@@ -0,0 +1,33 @@
+#include "PeriodicWaveHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+PeriodicWaveHostObject::PeriodicWaveHostObject(
+    const std::shared_ptr<PeriodicWaveWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> PeriodicWaveHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  return propertyNames;
+}
+
+jsi::Value PeriodicWaveHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void PeriodicWaveHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+} // namespace audioapi

package/common/cpp/HostObjects/PeriodicWaveHostObject.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+
+#include "PeriodicWaveWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class PeriodicWaveHostObject : public jsi::HostObject {
+ public:
+  std::shared_ptr<PeriodicWaveWrapper> wrapper_;
+
+  explicit PeriodicWaveHostObject(
+      const std::shared_ptr<PeriodicWaveWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<PeriodicWaveHostObject> createFromWrapper(
+      const std::shared_ptr<PeriodicWaveWrapper> &wrapper) {
+    return std::make_shared<PeriodicWaveHostObject>(wrapper);
+  }
+};
+} // namespace audioapi

package/common/cpp/HostObjects/StereoPannerNodeHostObject.cpp

@@ -0,0 +1,41 @@
+#include "StereoPannerNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+StereoPannerNodeHostObject::StereoPannerNodeHostObject(
+    const std::shared_ptr<StereoPannerNodeWrapper> &wrapper)
+    : AudioNodeHostObject(wrapper) {
+  auto panParam = wrapper->getPanParam();
+  panParam_ = AudioParamHostObject::createFromWrapper(panParam);
+}
+
+std::vector<jsi::PropNameID> StereoPannerNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "pan"));
+  return propertyNames;
+}
+
+jsi::Value StereoPannerNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "pan") {
+    return jsi::Object::createFromHostObject(runtime, panParam_);
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void StereoPannerNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  return AudioNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/StereoPannerNodeHostObject.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "StereoPannerNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class StereoPannerNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit StereoPannerNodeHostObject(
+      const std::shared_ptr<StereoPannerNodeWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<StereoPannerNodeHostObject> createFromWrapper(
+      const std::shared_ptr<StereoPannerNodeWrapper> &wrapper) {
+    return std::make_shared<StereoPannerNodeHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamHostObject> panParam_;
+};
+} // namespace audioapi

package/common/cpp/core/AudioArray.cpp

@@ -0,0 +1,103 @@
+#include <algorithm>
+
+#include "AudioArray.h"
+#include "VectorMath.h"
+
+namespace audioapi {
+
+AudioArray::AudioArray(int size) : size_(size), data_(0) {
+  resize(size);
+}
+
+AudioArray::~AudioArray() {
+  if (data_) {
+    delete[] data_;
+    data_ = 0;
+  }
+}
+
+int AudioArray::getSize() const {
+  return size_;
+}
+
+float* AudioArray::getData() const {
+  return data_;
+}
+
+float& AudioArray::operator[](int index) {
+  return data_[index];
+}
+
+const float& AudioArray::operator[](int index) const {
+  return data_[index];
+}
+
+void AudioArray::normalize() {
+  float maxAbsValue = getMaxAbsValue();
+
+  if (maxAbsValue == 0.0f || maxAbsValue == 1.0f) {
+    return;
+  }
+
+  VectorMath::multiplyByScalar(data_, 1.0f / maxAbsValue, data_, size_);
+}
+
+void AudioArray::resize(int size) {
+  if (size == size_) {
+    if (!data_) {
+      data_ = new float[size];
+    }
+
+    zero(0, size);
+    return;
+  }
+
+  delete[] data_;
+  size_ = size;
+  data_ = new float[size_];
+
+  zero(0, size_);
+}
+
+void AudioArray::scale(float value) {
+  VectorMath::multiplyByScalar(data_, value, data_, size_);
+}
+
+float AudioArray::getMaxAbsValue() const {
+  return VectorMath::maximumMagnitude(data_, size_);
+}
+
+void AudioArray::zero() {
+  zero(0, size_);
+}
+
+void AudioArray::zero(int start, int length) {
+  memset(data_ + start, 0, length * sizeof(float));
+}
+
+void AudioArray::sum(const AudioArray* source) {
+  sum(source, 0, 0, size_);
+}
+
+void AudioArray::sum(const AudioArray* source, int start, int length) {
+  sum(source, start, start, length);
+}
+
+void AudioArray::sum(const AudioArray* source, int sourceStart, int destinationStart, int length) {
+  VectorMath::add(data_ + destinationStart, source->getData() + sourceStart, data_ + destinationStart, length);
+}
+
+void AudioArray::copy(const AudioArray* source) {
+  copy(source, 0, size_);
+}
+
+void AudioArray::copy(const AudioArray* source, int start, int length) {
+  copy(source, start, start, length);
+}
+
+void AudioArray::copy(const AudioArray* source, int sourceStart, int destinationStart, int length) {
+  memcpy(data_ + destinationStart, source->getData() + sourceStart, length * sizeof(float));
+}
+
+} // namespace audioapi
+

package/common/cpp/core/AudioArray.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+#include <algorithm>
+
+namespace audioapi {
+
+class AudioArray {
+ public:
+  explicit AudioArray(int size);
+  ~AudioArray();
+
+  [[nodiscard]] int getSize() const;
+  float* getData() const;
+
+
+  float& operator[](int index);
+  const float& operator[](int index) const;
+
+  void normalize();
+  void resize(int size);
+  void scale(float value);
+  float getMaxAbsValue() const;
+
+  void zero();
+  void zero(int start, int length);
+
+  void sum(const AudioArray* source);
+  void sum(const AudioArray* source, int start, int length);
+  void sum(const AudioArray* source, int sourceStart, int destinationStart, int length);
+
+  void copy(const AudioArray* source);
+  void copy(const AudioArray* source, int start, int length);
+  void copy(const AudioArray* source, int sourceStart, int destinationStart, int length);
+
+
+ private:
+  float *data_;
+  int size_;
+};
+
+} // namespace audioapi