react-native-audio-api 0.2.0 → 0.3.0-rc2

package/android/src/main/cpp/AudioAPIInstaller/AudioAPIInstaller.cpp

@@ -5,14 +5,18 @@ namespace audioapi {
 using namespace facebook::jni;
 
 AudioAPIInstaller::AudioAPIInstaller(
-    jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis)
-    : javaPart_(make_global(jThis)) {}
+    jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
+    jsi::Runtime *rnRuntime,
+    const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
+    : javaPart_(make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      jsCallInvoker_(jsCallInvoker) {}
 
-void AudioAPIInstaller::install(jlong jsContext) {
+void AudioAPIInstaller::install() {
   auto audioAPIInstallerWrapper =
       std::make_shared<AudioAPIInstallerWrapper>(this);
   AudioAPIInstallerHostObject::createAndInstallFromWrapper(
-      audioAPIInstallerWrapper, jsContext);
+      audioAPIInstallerWrapper, rnRuntime_, jsCallInvoker_);
 }
 
 std::shared_ptr<AudioContext> AudioAPIInstaller::createAudioContext() {

package/android/src/main/cpp/AudioAPIInstaller/AudioAPIInstaller.h

@@ -1,7 +1,7 @@
 #pragma once
 
+#include <ReactCommon/CallInvokerHolder.h>
 #include <fbjni/fbjni.h>
-#include <jsi/jsi.h>
 #include <react/jni/CxxModuleWrapper.h>
 #include <react/jni/JMessageQueueThread.h>
 #include <memory>
@@ -14,7 +14,7 @@
 namespace audioapi {
 
 using namespace facebook;
-using namespace facebook::jni;
+using namespace react;
 
 class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
  public:
@@ -22,8 +22,13 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
       "Lcom/swmansion/audioapi/module/AudioAPIInstaller;";
 
   static jni::local_ref<AudioAPIInstaller::jhybriddata> initHybrid(
-      jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+      jni::alias_ref<jhybridobject> jThis,
+      jlong jsContext,
+      jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
+          jsCallInvokerHolder) {
+    auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+    auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
+    return makeCxxInstance(jThis, rnRuntime, jsCallInvoker);
   }
 
   static void registerNatives() {
@@ -34,15 +39,19 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
   }
 
   std::shared_ptr<AudioContext> createAudioContext();
-  void install(jlong jsContext);
+  void install();
 
  private:
   friend HybridBase;
 
-  global_ref<AudioAPIInstaller::javaobject> javaPart_;
+  jni::global_ref<AudioAPIInstaller::javaobject> javaPart_;
+  jsi::Runtime *rnRuntime_;
+  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
 
   explicit AudioAPIInstaller(
-      jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis);
+      jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
+      jsi::Runtime *rnRuntime,
+      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker);
 };
 
 } // namespace audioapi

package/android/src/main/cpp/AudioDecoder/AudioDecoder.cpp

@@ -0,0 +1,64 @@
+#include "AudioDecoder.h"
+
+#define MINIAUDIO_IMPLEMENTATION
+#include <android/log.h>
+#include <miniaudio.h>
+
+#include "AudioArray.h"
+#include "AudioBus.h"
+
+namespace audioapi {
+
+AudioDecoder::AudioDecoder(int sampleRate) : sampleRate_(sampleRate) {}
+
+AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
+  ma_decoder decoder;
+  ma_decoder_config config =
+      ma_decoder_config_init(ma_format_f32, 2, sampleRate_);
+  ma_result result = ma_decoder_init_file(path.c_str(), &config, &decoder);
+  if (result != MA_SUCCESS) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "Failed to initialize decoder for file: %s",
+        path.c_str());
+    return new AudioBus(1, 1, 1);
+  }
+
+  ma_uint64 totalFrameCount;
+  ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
+
+  auto *audioBus =
+      new AudioBus(sampleRate_, static_cast<int>(totalFrameCount), 2);
+  auto *buffer = new float[totalFrameCount * 2];
+
+  ma_uint64 framesDecoded;
+  ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
+  if (framesDecoded == 0) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "Failed to decode audio file: %s",
+        path.c_str());
+  }
+
+  for (int i = 0; i < decoder.outputChannels; ++i) {
+    float *channelData = audioBus->getChannel(i)->getData();
+
+    for (ma_uint64 j = 0; j < framesDecoded; ++j) {
+      channelData[j] = buffer[j * decoder.outputChannels + i];
+    }
+  }
+
+  delete[] buffer;
+  ma_decoder_uninit(&decoder);
+
+  return audioBus;
+}
+
+AudioBus *AudioDecoder::decodeWithArrayBuffer() const {
+  // TODO: implement this
+  return new AudioBus(1, 1, 1);
+}
+
+} // namespace audioapi

package/android/src/main/cpp/AudioDecoder/AudioDecoder.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+
+class AudioDecoder {
+ public:
+  explicit AudioDecoder(int sampleRate);
+
+  [[nodiscard]] AudioBus *decodeWithFilePath(const std::string &path) const;
+  // TODO: implement this
+  [[nodiscard]] AudioBus *decodeWithArrayBuffer() const;
+
+ private:
+  int sampleRate_;
+};
+
+} // namespace audioapi

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

@@ -1,13 +1,14 @@
 
-#include "AudioBus.h"
-#include "Constants.h"
-#include "AudioArray.h"
 #include "AudioPlayer.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 #include "AudioContext.h"
+#include "Constants.h"
 
 namespace audioapi {
 
-AudioPlayer::AudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio)
+AudioPlayer::AudioPlayer(
+    const std::function<void(AudioBus *, int)> &renderAudio)
     : renderAudio_(renderAudio) {
   AudioStreamBuilder builder;
 
@@ -20,7 +21,9 @@ AudioPlayer::AudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio)
       ->setDataCallback(this)
       ->openStream(mStream_);
 
-  mBus_ = std::make_shared<AudioBus>(getSampleRate(), getBufferSizeInFrames(), CHANNEL_COUNT);
+  mBus_ = std::make_shared<AudioBus>(
+      getSampleRate(), getBufferSizeInFrames(), CHANNEL_COUNT);
+  isInitialized_ = true;
 }
 
 int AudioPlayer::getSampleRate() const {
@@ -38,6 +41,8 @@ void AudioPlayer::start() {
 }
 
 void AudioPlayer::stop() {
+  isInitialized_ = false;
+
   if (mStream_) {
     mStream_->requestStop();
     mStream_->close();
@@ -49,14 +54,18 @@ DataCallbackResult AudioPlayer::onAudioReady(
     AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
-  auto buffer = static_cast<float *>(audioData);
+  if (!isInitialized_) {
+    return DataCallbackResult::Continue;
+  }
 
+  auto buffer = static_cast<float *>(audioData);
   renderAudio_(mBus_.get(), numFrames);
 
   // 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];
+      buffer[i * CHANNEL_COUNT + channel] =
+          mBus_->getChannel(channel)->getData()[i];
     }
   }
 

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

@@ -12,10 +12,10 @@ class AudioBus;
 
 class AudioPlayer : public AudioStreamDataCallback {
  public:
-  explicit AudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio);
+  explicit AudioPlayer(const std::function<void(AudioBus *, int)> &renderAudio);
 
-  int getSampleRate() const;
-  int getBufferSizeInFrames() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] int getBufferSizeInFrames() const;
   void start();
   void stop();
 
@@ -25,9 +25,10 @@ class AudioPlayer : public AudioStreamDataCallback {
       int32_t numFrames) override;
 
  private:
-  std::function<void(AudioBus*, int)> renderAudio_;
+  std::function<void(AudioBus *, int)> renderAudio_;
   std::shared_ptr<AudioStream> mStream_;
   std::shared_ptr<AudioBus> mBus_;
+  bool isInitialized_ = false;
 };
 
 } // namespace audioapi

package/android/src/main/java/com/swmansion/audioapi/module/AudioAPIInstaller.kt

@@ -1,8 +1,14 @@
 package com.swmansion.audioapi.module
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 
-class AudioAPIInstaller {
+@OptIn(FrameworkAPI::class)
+class AudioAPIInstaller(
+  reactContext: ReactApplicationContext,
+) {
   private val mHybridData: HybridData?
 
   companion object {
@@ -12,10 +18,14 @@ class AudioAPIInstaller {
   }
 
   init {
-    mHybridData = initHybrid()
+    val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
+    mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
   }
 
-  external fun initHybrid(): HybridData?
+  external fun initHybrid(
+    jsContext: Long,
+    callInvoker: CallInvokerHolderImpl,
+  ): HybridData?
 
-  external fun install(jsContext: Long)
+  external fun install()
 }

package/android/src/main/java/com/swmansion/audioapi/nativemodules/AudioAPIModule.kt

@@ -12,9 +12,8 @@ class AudioAPIModule(
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun install(): Boolean {
-    val audioAPIInstaller = AudioAPIInstaller()
-    val jsContext = reactContext.javaScriptContextHolder!!.get()
-    audioAPIInstaller.install(jsContext)
+    val audioAPIInstaller = AudioAPIInstaller(reactContext)
+    audioAPIInstaller.install()
 
     return true
   }

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.cpp

@@ -4,8 +4,13 @@ namespace audioapi {
 using namespace facebook;
 
 AudioAPIInstallerHostObject::AudioAPIInstallerHostObject(
-    const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper)
-    : wrapper_(wrapper) {}
+    const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
+    jsi::Runtime *runtime,
+    const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker)
+    : wrapper_(wrapper) {
+  promiseVendor_ =
+      std::make_shared<JsiPromise::PromiseVendor>(runtime, jsInvoker);
+}
 
 std::vector<jsi::PropNameID> AudioAPIInstallerHostObject::getPropertyNames(
     jsi::Runtime &runtime) {
@@ -32,7 +37,8 @@ jsi::Value AudioAPIInstallerHostObject::get(
             size_t count) -> jsi::Value {
           auto audioContext = wrapper_->createAudioContext();
           auto audioContextHostObject =
-              AudioContextHostObject::createFromWrapper(audioContext);
+              AudioContextHostObject::createFromWrapper(
+                  audioContext, promiseVendor_);
           return jsi::Object::createFromHostObject(
               runtime, audioContextHostObject);
         });

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
@@ -7,6 +8,7 @@
 
 #include "AudioAPIInstallerWrapper.h"
 #include "AudioContextHostObject.h"
+#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -16,17 +18,20 @@ class AudioAPIInstallerWrapper;
 class AudioAPIInstallerHostObject : public jsi::HostObject {
  public:
   explicit AudioAPIInstallerHostObject(
-      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper);
+      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &jsInvoker);
 
 #ifdef ANDROID
   static void createAndInstallFromWrapper(
       const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
-      jlong jsContext) {
-    auto runtime = reinterpret_cast<jsi::Runtime *>(jsContext);
-    auto hostObject = std::make_shared<AudioAPIInstallerHostObject>(wrapper);
-    auto object = jsi::Object::createFromHostObject(*runtime, hostObject);
-    runtime->global().setProperty(
-        *runtime, "__AudioAPIInstaller", std::move(object));
+      jsi::Runtime *rnRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsInvoker) {
+    auto hostObject = std::make_shared<AudioAPIInstallerHostObject>(
+        wrapper, rnRuntime, jsInvoker);
+    auto object = jsi::Object::createFromHostObject(*rnRuntime, hostObject);
+    rnRuntime->global().setProperty(
+        *rnRuntime, "__AudioAPIInstaller", std::move(object));
   }
 #endif
 
@@ -41,5 +46,6 @@ class AudioAPIInstallerHostObject : public jsi::HostObject {
 
  private:
   std::shared_ptr<AudioAPIInstallerWrapper> wrapper_;
+  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioBufferHostObject.cpp

@@ -128,6 +128,13 @@ jsi::Value AudioBufferHostObject::get(
         });
   }
 
+  // `decodeAudioData` is a method that returns a promise to
+  // AudioBufferHostObject It seems that async/await checks for the presence of
+  // `then` method on the object
+  if (propName == "then") {
+    return jsi::Value::undefined();
+  }
+
   throw std::runtime_error("Not yet implemented!");
 }
 

package/common/cpp/HostObjects/AudioContextHostObject.cpp

@@ -4,8 +4,9 @@ namespace audioapi {
 using namespace facebook;
 
 AudioContextHostObject::AudioContextHostObject(
-    const std::shared_ptr<AudioContextWrapper> &wrapper)
-    : BaseAudioContextHostObject(wrapper) {}
+    const std::shared_ptr<AudioContextWrapper> &wrapper,
+    std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    : BaseAudioContextHostObject(wrapper, promiseVendor) {}
 
 std::vector<jsi::PropNameID> AudioContextHostObject::getPropertyNames(
     jsi::Runtime &runtime) {

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -6,6 +6,7 @@
 
 #include "AudioContextWrapper.h"
 #include "BaseAudioContextHostObject.h"
+#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -13,7 +14,8 @@ using namespace facebook;
 class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
-      const std::shared_ptr<AudioContextWrapper> &wrapper);
+      const std::shared_ptr<AudioContextWrapper> &wrapper,
+      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
@@ -25,8 +27,9 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
   static std::shared_ptr<AudioContextHostObject> createFromWrapper(
-      const std::shared_ptr<AudioContextWrapper> &wrapper) {
-    return std::make_shared<AudioContextHostObject>(wrapper);
+      const std::shared_ptr<AudioContextWrapper> &wrapper,
+      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor) {
+    return std::make_shared<AudioContextHostObject>(wrapper, promiseVendor);
   }
 
  private:

package/common/cpp/HostObjects/BaseAudioContextHostObject.cpp

@@ -1,11 +1,14 @@
+#include <thread>
+
 #include "BaseAudioContextHostObject.h"
 
 namespace audioapi {
 using namespace facebook;
 
 BaseAudioContextHostObject::BaseAudioContextHostObject(
-    const std::shared_ptr<BaseAudioContextWrapper> &wrapper)
-    : wrapper_(wrapper) {
+    const std::shared_ptr<BaseAudioContextWrapper> &wrapper,
+    std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    : wrapper_(wrapper), promiseVendor_(promiseVendor) {
   auto destinationNodeWrapper = wrapper_->getDestination();
   destination_ =
       AudioDestinationNodeHostObject::createFromWrapper(destinationNodeWrapper);
@@ -30,6 +33,8 @@ std::vector<jsi::PropNameID> BaseAudioContextHostObject::getPropertyNames(
   propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createBuffer"));
   propertyNames.push_back(
       jsi::PropNameID::forUtf8(runtime, "createPeriodicWave"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "decodeAudioDataSource"));
   return propertyNames;
 }
 
@@ -200,6 +205,37 @@ jsi::Value BaseAudioContextHostObject::get(
         });
   }
 
+  if (propName == "decodeAudioDataSource") {
+    auto decode = [this](
+                      jsi::Runtime &runtime,
+                      const jsi::Value &,
+                      const jsi::Value *arguments,
+                      size_t count) -> jsi::Value {
+      auto sourcePath = arguments[0].getString(runtime).utf8(runtime);
+
+      auto promise = promiseVendor_->createPromise(
+          [this, &runtime, sourcePath](
+              std::shared_ptr<JsiPromise::Promise> promise) {
+            std::thread([this,
+                         &runtime,
+                         sourcePath,
+                         promise = std::move(promise)]() {
+              auto results = wrapper_->decodeAudioDataSource(sourcePath);
+              auto audioBufferHostObject =
+                  AudioBufferHostObject::createFromWrapper(results);
+
+              promise->resolve(jsi::Object::createFromHostObject(
+                  runtime, audioBufferHostObject));
+            }).detach();
+          });
+
+      return promise;
+    };
+
+    return jsi::Function::createFromHostFunction(
+        runtime, propNameId, 1, decode);
+  }
+
   throw std::runtime_error("Not yet implemented!");
 }
 

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -11,6 +11,7 @@
 #include "BaseAudioContextWrapper.h"
 #include "BiquadFilterNodeHostObject.h"
 #include "GainNodeHostObject.h"
+#include "JsiPromise.h"
 #include "OscillatorNodeHostObject.h"
 #include "PeriodicWaveHostObject.h"
 #include "StereoPannerNodeHostObject.h"
@@ -21,7 +22,8 @@ using namespace facebook;
 class BaseAudioContextHostObject : public jsi::HostObject {
  public:
   explicit BaseAudioContextHostObject(
-      const std::shared_ptr<BaseAudioContextWrapper> &wrapper);
+      const std::shared_ptr<BaseAudioContextWrapper> &wrapper,
+      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
@@ -35,5 +37,6 @@ class BaseAudioContextHostObject : public jsi::HostObject {
  protected:
   std::shared_ptr<BaseAudioContextWrapper> wrapper_;
   std::shared_ptr<AudioDestinationNodeHostObject> destination_;
+  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
 };
 } // namespace audioapi

package/common/cpp/core/AudioArray.cpp

@@ -5,14 +5,14 @@
 
 namespace audioapi {
 
-AudioArray::AudioArray(int size) : size_(size), data_(0) {
+AudioArray::AudioArray(int size) : data_(nullptr), size_(size) {
   resize(size);
 }
 
 AudioArray::~AudioArray() {
   if (data_) {
     delete[] data_;
-    data_ = 0;
+    data_ = nullptr;
   }
 }
 
@@ -20,15 +20,15 @@ int AudioArray::getSize() const {
   return size_;
 }
 
-float* AudioArray::getData() const {
+float *AudioArray::getData() const {
   return data_;
 }
 
-float& AudioArray::operator[](int index) {
+float &AudioArray::operator[](int index) {
   return data_[index];
 }
 
-const float& AudioArray::operator[](int index) const {
+const float &AudioArray::operator[](int index) const {
   return data_[index];
 }
 
@@ -75,29 +75,43 @@ void AudioArray::zero(int start, int length) {
   memset(data_ + start, 0, length * sizeof(float));
 }
 
-void AudioArray::sum(const AudioArray* source) {
+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, 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::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) {
+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, 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));
+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

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <memory>
 #include <algorithm>
+#include <memory>
 
 namespace audioapi {
 
@@ -11,28 +11,34 @@ class AudioArray {
   ~AudioArray();
 
   [[nodiscard]] int getSize() const;
-  float* getData() const;
-
+  [[nodiscard]] float *getData() const;
 
-  float& operator[](int index);
-  const float& operator[](int index) const;
+  float &operator[](int index);
+  const float &operator[](int index) const;
 
   void normalize();
   void resize(int size);
   void scale(float value);
-  float getMaxAbsValue() const;
+  [[nodiscard]] 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);
-
+  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_;