react-native-audio-api 0.12.0-nightly-6a44b58-20260126 → 0.12.0-nightly-1a3c43b-20260128

package/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp

@@ -1,18 +1,20 @@
 #include <audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h>
 
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <memory>
 
 namespace audioapi {
 
 AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
-    const std::shared_ptr<AudioBufferQueueSourceNode> &node)
-    : AudioBufferBaseSourceNodeHostObject(node) {
+    const std::shared_ptr<BaseAudioContext> &context,
+    const BaseAudioBufferSourceOptions &options)
+    : AudioBufferBaseSourceNodeHostObject(context->createBufferQueueSource(options)) {
   functions_->erase("start");
 
-  addSetters(
-  JSI_EXPORT_PROPERTY_SETTER(AudioBufferQueueSourceNodeHostObject, onBufferEnded));
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioBufferQueueSourceNodeHostObject, onBufferEnded));
 
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, start),
@@ -32,9 +34,10 @@ AudioBufferQueueSourceNodeHostObject::~AudioBufferQueueSourceNodeHostObject() {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioBufferQueueSourceNodeHostObject, onBufferEnded) {
-    auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
 
-    audioBufferQueueSourceNode->setOnBufferEndedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+  audioBufferQueueSourceNode->setOnBufferEndedCallbackId(
+      std::stoull(value.getString(runtime).utf8(runtime)));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, start) {

package/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h

@@ -8,12 +8,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class AudioBufferQueueSourceNode;
+struct BaseAudioBufferSourceOptions;
+class BaseAudioContext;
 
 class AudioBufferQueueSourceNodeHostObject : public AudioBufferBaseSourceNodeHostObject {
  public:
   explicit AudioBufferQueueSourceNodeHostObject(
-      const std::shared_ptr<AudioBufferQueueSourceNode> &node);
+      const std::shared_ptr<BaseAudioContext> &context,
+      const BaseAudioBufferSourceOptions &options);
 
   ~AudioBufferQueueSourceNodeHostObject() override;
 

package/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp

@@ -1,14 +1,17 @@
 #include <audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h>
 
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
 #include <memory>
 
 namespace audioapi {
 
 AudioBufferSourceNodeHostObject::AudioBufferSourceNodeHostObject(
-    const std::shared_ptr<AudioBufferSourceNode> &node)
-    : AudioBufferBaseSourceNodeHostObject(node) {
+    const std::shared_ptr<BaseAudioContext> &context,
+    const AudioBufferSourceOptions &options)
+    : AudioBufferBaseSourceNodeHostObject(context->createBufferSource(options)) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loop),
       JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopSkip),

package/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h

@@ -8,11 +8,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class AudioBufferSourceNode;
+struct AudioBufferSourceOptions;
+class BaseAudioContext;
 
 class AudioBufferSourceNodeHostObject : public AudioBufferBaseSourceNodeHostObject {
  public:
-  explicit AudioBufferSourceNodeHostObject(const std::shared_ptr<AudioBufferSourceNode> &node);
+  explicit AudioBufferSourceNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioBufferSourceOptions &options);
 
   ~AudioBufferSourceNodeHostObject() override;
 

package/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp

@@ -1,13 +1,16 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/ConstantSourceNode.h>
 #include <memory>
 
 namespace audioapi {
 
 ConstantSourceNodeHostObject::ConstantSourceNodeHostObject(
-    const std::shared_ptr<ConstantSourceNode> &node)
-    : AudioScheduledSourceNodeHostObject(node) {
+    const std::shared_ptr<BaseAudioContext> &context,
+    const ConstantSourceOptions &options)
+    : AudioScheduledSourceNodeHostObject(context->createConstantSource(options)) {
   addGetters(JSI_EXPORT_PROPERTY_GETTER(ConstantSourceNodeHostObject, offset));
 }
 

package/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h

@@ -9,11 +9,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class ConstantSourceNode;
+struct ConstantSourceOptions;
+class BaseAudioContext;
 
 class ConstantSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit ConstantSourceNodeHostObject(const std::shared_ptr<ConstantSourceNode> &node);
+  explicit ConstantSourceNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const ConstantSourceOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(offset);
 };

package/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp

@@ -2,14 +2,18 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
-#include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/HostObjects/utils/JsEnumParser.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/sources/OscillatorNode.h>
 #include <memory>
 
 namespace audioapi {
 
-OscillatorNodeHostObject::OscillatorNodeHostObject(const std::shared_ptr<OscillatorNode> &node)
-    : AudioScheduledSourceNodeHostObject(node) {
+OscillatorNodeHostObject::OscillatorNodeHostObject(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const OscillatorOptions &options)
+    : AudioScheduledSourceNodeHostObject(context->createOscillator(options)) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
       JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, detune),

package/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.h

@@ -10,11 +10,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class OscillatorNode;
+struct OscillatorOptions;
+class BaseAudioContext;
 
 class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit OscillatorNodeHostObject(const std::shared_ptr<OscillatorNode> &node);
+  explicit OscillatorNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const OscillatorOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(frequency);
   JSI_PROPERTY_GETTER_DECL(detune);

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.cpp

@@ -2,13 +2,17 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/StreamerNode.h>
 #include <memory>
 
 namespace audioapi {
 
-StreamerNodeHostObject::StreamerNodeHostObject(const std::shared_ptr<StreamerNode> &node)
-    : AudioScheduledSourceNodeHostObject(node) {
+StreamerNodeHostObject::StreamerNodeHostObject(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const StreamerOptions &options)
+    : AudioScheduledSourceNodeHostObject(context->createStreamer(options)) {
   addFunctions(JSI_EXPORT_FUNCTION(StreamerNodeHostObject, initialize));
   addGetters(JSI_EXPORT_PROPERTY_GETTER(StreamerNodeHostObject, streamPath));
 }

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h

@@ -9,11 +9,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class StreamerNode;
+struct StreamerOptions;
+class BaseAudioContext;
 
 class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit StreamerNodeHostObject(const std::shared_ptr<StreamerNode> &node);
+  explicit StreamerNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const StreamerOptions &options);
 
   [[nodiscard]] static inline size_t getSizeInBytes() {
     return SIZE;

package/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp

@@ -124,4 +124,67 @@ namespace audioapi::js_enum_parser {
     }
   }
 
+  AudioEvent audioEventFromString(const std::string &event) {
+    if (event == "playbackNotificationPlay")
+        return AudioEvent::PLAYBACK_NOTIFICATION_PLAY;
+    if (event == "playbackNotificationPause")
+        return AudioEvent::PLAYBACK_NOTIFICATION_PAUSE;
+    if (event == "playbackNotificationStop")
+        return AudioEvent::PLAYBACK_NOTIFICATION_STOP;
+    if (event == "playbackNotificationNextTrack")
+        return AudioEvent::PLAYBACK_NOTIFICATION_NEXT_TRACK;
+    if (event == "playbackNotificationPreviousTrack")
+        return AudioEvent::PLAYBACK_NOTIFICATION_PREVIOUS_TRACK;
+    if (event == "playbackNotificationSkipForward")
+        return AudioEvent::PLAYBACK_NOTIFICATION_SKIP_FORWARD;
+    if (event == "playbackNotificationSkipBackward")
+        return AudioEvent::PLAYBACK_NOTIFICATION_SKIP_BACKWARD;
+    if (event == "playbackNotificationSeekForward")
+        return AudioEvent::PLAYBACK_NOTIFICATION_SEEK_FORWARD;
+    if (event == "playbackNotificationSeekBackward")
+        return AudioEvent::PLAYBACK_NOTIFICATION_SEEK_BACKWARD;
+    if (event == "playbackNotificationSeekTo")
+        return AudioEvent::PLAYBACK_NOTIFICATION_SEEK_TO;
+    if (event == "playbackNotificationDismissed")
+        return AudioEvent::PLAYBACK_NOTIFICATION_DISMISSED;
+    if (event == "recordingNotificationResume")
+        return AudioEvent::RECORDING_NOTIFICATION_RESUME;
+    if (event == "recordingNotificationPause")
+        return AudioEvent::RECORDING_NOTIFICATION_PAUSE;
+    if (event == "routeChange")
+        return AudioEvent::ROUTE_CHANGE;
+    if (event == "interruption")
+        return AudioEvent::INTERRUPTION;
+    if (event == "volumeChange")
+        return AudioEvent::VOLUME_CHANGE;
+    if (event == "duck")
+        return AudioEvent::DUCK;
+    if (event == "ended")
+        return AudioEvent::ENDED;
+    if (event == "loopEnded")
+      return AudioEvent::LOOP_ENDED;
+    if (event == "audioReady")
+      return AudioEvent::AUDIO_READY;
+    if (event == "positionChanged")
+      return AudioEvent::POSITION_CHANGED;
+    if (event == "bufferEnded")
+      return AudioEvent::BUFFER_ENDED;
+    if (event == "recorderError")
+      return AudioEvent::RECORDER_ERROR;
+
+    throw std::invalid_argument("Unknown audio event: " + event);
+  }
+
+  std::string contextStateToString(ContextState state) {
+    switch (state) {
+      case ContextState::SUSPENDED:
+        return "suspended";
+      case ContextState::RUNNING:
+        return "running";
+      case ContextState::CLOSED:
+        return "closed";
+      default:
+        throw std::invalid_argument("Unknown context state");
+    }
+  }
 } // namespace audioapi::js_enum_parser

package/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h

@@ -1,8 +1,11 @@
 #pragma once
+
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/types/BiquadFilterType.h>
+#include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/types/OverSampleType.h>
+#include <audioapi/events/AudioEvent.h>
 #include <string>
 
 namespace audioapi::js_enum_parser {
@@ -14,4 +17,6 @@ std::string oscillatorTypeToString(OscillatorType type);
 OscillatorType oscillatorTypeFromString(const std::string &type);
 std::string filterTypeToString(BiquadFilterType type);
 BiquadFilterType filterTypeFromString(const std::string &type);
+AudioEvent audioEventFromString(const std::string &event);
+std::string contextStateToString(ContextState state);
 } // namespace audioapi::js_enum_parser

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -15,10 +15,8 @@ AudioContext::AudioContext(
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry), isInitialized_(false) {
-  sampleRate_ = sampleRate;
-  state_ = ContextState::SUSPENDED;
-}
+    : BaseAudioContext(sampleRate, audioEventHandlerRegistry, runtimeRegistry),
+    isInitialized_(false) {}
 
 AudioContext::~AudioContext() {
   if (!isClosed()) {

package/common/cpp/audioapi/core/AudioNode.cpp

@@ -11,14 +11,14 @@
 
 namespace audioapi {
 
-AudioNode::AudioNode(std::shared_ptr<BaseAudioContext> context) : context_(context) {
+AudioNode::AudioNode(const std::shared_ptr<BaseAudioContext>& context) : context_(context) {
   audioBus_ =
       std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
 }
 
-AudioNode::AudioNode(std::shared_ptr<BaseAudioContext> context, const AudioNodeOptions &options)
-    : context_(context),
-      channelCount_(options.channelCount),
+AudioNode::AudioNode(const std::shared_ptr<BaseAudioContext>& context, const AudioNodeOptions &options)
+    : channelCount_(options.channelCount),
+      context_(context),
       channelCountMode_(options.channelCountMode),
       channelInterpretation_(options.channelInterpretation) {
   audioBus_ =

package/common/cpp/audioapi/core/AudioNode.h

@@ -16,12 +16,14 @@ namespace audioapi {
 class AudioBus;
 class BaseAudioContext;
 class AudioParam;
-class AudioNodeOptions;
+struct AudioNodeOptions;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
-  explicit AudioNode(std::shared_ptr<BaseAudioContext> context);
-  explicit AudioNode(std::shared_ptr<BaseAudioContext> context, const AudioNodeOptions &options);
+  explicit AudioNode(const std::shared_ptr<BaseAudioContext> &context);
+  explicit AudioNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioNodeOptions &options);
   virtual ~AudioNode();
 
   int getNumberOfInputs() const;
@@ -57,9 +59,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   int numberOfInputs_ = 1;
   int numberOfOutputs_ = 1;
   ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
-  ChannelInterpretation channelInterpretation_ =
-
-      ChannelInterpretation::SPEAKERS;
+  ChannelInterpretation channelInterpretation_ = ChannelInterpretation::SPEAKERS;
 
   std::unordered_set<AudioNode *> inputNodes_ = {};
   std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -36,9 +36,11 @@
 namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
+    float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry)
-    : nodeManager_(std::make_shared<AudioNodeManager>()),
+    : sampleRate_(sampleRate),
+      nodeManager_(std::make_shared<AudioNodeManager>()),
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
       runtimeRegistry_(runtimeRegistry) {}
 
@@ -46,16 +48,12 @@ void BaseAudioContext::initialize() {
   destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
 }
 
-std::string BaseAudioContext::getState() {
-  if (isDriverRunning()) {
-    return BaseAudioContext::toString(state_);
+ContextState BaseAudioContext::getState() {
+  if (isDriverRunning() || state_ == ContextState::CLOSED) {
+    return state_;
   }
 
-  if (state_ == ContextState::CLOSED) {
-    return BaseAudioContext::toString(ContextState::CLOSED);
-  }
-
-  return BaseAudioContext::toString(ContextState::SUSPENDED);
+  return ContextState::SUSPENDED;
 }
 
 float BaseAudioContext::getSampleRate() const {
@@ -235,19 +233,6 @@ float BaseAudioContext::getNyquistFrequency() const {
   return sampleRate_ / 2.0f;
 }
 
-std::string BaseAudioContext::toString(ContextState state) {
-  switch (state) {
-    case ContextState::SUSPENDED:
-      return "suspended";
-    case ContextState::RUNNING:
-      return "running";
-    case ContextState::CLOSED:
-      return "closed";
-    default:
-      throw std::invalid_argument("Unknown context state");
-  }
-}
-
 std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType type) {
   switch (type) {
     case OscillatorType::SINE:

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -38,31 +38,30 @@ class WorkletSourceNode;
 class WorkletNode;
 class WorkletProcessingNode;
 class StreamerNode;
-class GainOptions;
-class StereoPannerOptions;
-class ConvolverOptions;
-class ConstantSourceOptions;
-class AnalyserOptions;
-class BiquadFilterOptions;
-class OscillatorOptions;
-class BaseAudioBufferSourceOptions;
-class AudioBufferSourceOptions;
-class StreamerOptions;
-class AudioBufferOptions;
-class DelayOptions;
-class IIRFilterOptions;
-class WaveShaperOptions;
+struct GainOptions;
+struct StereoPannerOptions;
+struct ConvolverOptions;
+struct ConstantSourceOptions;
+struct AnalyserOptions;
+struct BiquadFilterOptions;
+struct OscillatorOptions;
+struct BaseAudioBufferSourceOptions;
+struct AudioBufferSourceOptions;
+struct StreamerOptions;
+struct AudioBufferOptions;
+struct DelayOptions;
+struct IIRFilterOptions;
+struct WaveShaperOptions;
 
 class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
  public:
   explicit BaseAudioContext(
+      float sampleRate,
       const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const RuntimeRegistry &runtimeRegistry);
   virtual ~BaseAudioContext() = default;
 
-  virtual void initialize();
-
-  std::string getState();
+  ContextState getState();
   [[nodiscard]] float getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
@@ -112,13 +111,12 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   [[nodiscard]] bool isSuspended() const;
   [[nodiscard]] bool isClosed() const;
 
- protected:
-  static std::string toString(ContextState state);
+  virtual void initialize();
 
+ protected:
   std::shared_ptr<AudioDestinationNode> destination_;
-  // init in AudioContext or OfflineContext constructor
-  float sampleRate_{};
-  ContextState state_ = ContextState::RUNNING;
+  float sampleRate_;
+  ContextState state_ = ContextState::SUSPENDED;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 
  private:

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -24,14 +24,11 @@ OfflineAudioContext::OfflineAudioContext(
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry),
+    : BaseAudioContext(sampleRate, audioEventHandlerRegistry, runtimeRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
-      currentSampleFrame_(0) {
-  sampleRate_ = sampleRate;
-  resultBus_ =
-      std::make_shared<AudioBus>(static_cast<int>(length_), numberOfChannels_, sampleRate_);
-}
+      currentSampleFrame_(0),
+      resultBus_(std::make_shared<AudioBus>(length, numberOfChannels, sampleRate)) {}
 
 OfflineAudioContext::~OfflineAudioContext() {
   nodeManager_->cleanup();

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -7,6 +7,7 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+
 #include <algorithm>
 #include <memory>
 #include <string>
@@ -14,7 +15,9 @@
 
 namespace audioapi {
 
-AnalyserNode::AnalyserNode(std::shared_ptr<BaseAudioContext> context, const AnalyserOptions &options)
+AnalyserNode::AnalyserNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const AnalyserOptions &options)
     : AudioNode(context, options),
       fftSize_(options.fftSize),
       minDecibels_(options.minDecibels),
@@ -194,7 +197,7 @@ void AnalyserNode::setWindowData(AnalyserNode::WindowType type, int size) {
   }
 
   windowType_ = type;
-  if (windowData_ == nullptr|| windowData_->getSize() != size) {
+  if (windowData_ == nullptr || windowData_->getSize() != size) {
     windowData_ = std::make_shared<AudioArray>(size);
   }
 

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -15,12 +15,14 @@ namespace audioapi {
 class AudioBus;
 class AudioArray;
 class CircularAudioArray;
-class AnalyserOptions;
+struct AnalyserOptions;
 
 class AnalyserNode : public AudioNode {
  public:
   enum class WindowType { BLACKMAN, HANN };
-  explicit AnalyserNode(std::shared_ptr<BaseAudioContext> context, const AnalyserOptions &options);
+  explicit AnalyserNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AnalyserOptions &options);
 
   int getFftSize() const;
   int getFrequencyBinCount() const;

package/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp

@@ -7,7 +7,7 @@
 
 namespace audioapi {
 
-AudioDestinationNode::AudioDestinationNode(std::shared_ptr<BaseAudioContext> context)
+AudioDestinationNode::AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context)
     : AudioNode(context), currentSampleFrame_(0) {
   numberOfOutputs_ = 0;
   numberOfInputs_ = 1;

package/common/cpp/audioapi/core/destinations/AudioDestinationNode.h

@@ -14,7 +14,7 @@ class BaseAudioContext;
 
 class AudioDestinationNode : public AudioNode {
  public:
-  explicit AudioDestinationNode(std::shared_ptr<BaseAudioContext> context);
+  explicit AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context);
 
   std::size_t getCurrentSampleFrame() const;
   double getCurrentTime() const;

package/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp

@@ -39,7 +39,7 @@
 
 namespace audioapi {
 
-BiquadFilterNode::BiquadFilterNode(std::shared_ptr<BaseAudioContext> context, const BiquadFilterOptions &options) : AudioNode(context, options) {
+BiquadFilterNode::BiquadFilterNode(const std::shared_ptr<BaseAudioContext>& context, const BiquadFilterOptions &options) : AudioNode(context, options) {
   frequencyParam_ =
       std::make_shared<AudioParam>(options.frequency, 0.0f, context->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
@@ -112,11 +112,11 @@ void BiquadFilterNode::getFrequencyResponse(
 #endif
 
   // Use double precision for later calculations
-  double b0 = static_cast<double>(b0_);
-  double b1 = static_cast<double>(b1_);
-  double b2 = static_cast<double>(b2_);
-  double a1 = static_cast<double>(a1_);
-  double a2 = static_cast<double>(a2_);
+  auto b0 = static_cast<double>(b0_);
+  auto b1 = static_cast<double>(b1_);
+  auto b2 = static_cast<double>(b2_);
+  auto a1 = static_cast<double>(a1_);
+  auto a2 = static_cast<double>(a2_);
 
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (!context)

package/common/cpp/audioapi/core/effects/BiquadFilterNode.h

@@ -46,7 +46,7 @@
 namespace audioapi {
 
 class AudioBus;
-class BiquadFilterOptions;
+struct BiquadFilterOptions;
 
 class BiquadFilterNode : public AudioNode {
 #if RN_AUDIO_API_TEST
@@ -56,7 +56,7 @@ class BiquadFilterNode : public AudioNode {
 
  public:
   explicit BiquadFilterNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const BiquadFilterOptions &options);
 
   [[nodiscard]] BiquadFilterType getType();

package/common/cpp/audioapi/core/effects/ConvolverNode.cpp

@@ -12,7 +12,7 @@
 #include <vector>
 
 namespace audioapi {
-ConvolverNode::ConvolverNode(std::shared_ptr<BaseAudioContext> context, const ConvolverOptions &options)
+ConvolverNode::ConvolverNode(const std::shared_ptr<BaseAudioContext>& context, const ConvolverOptions &options)
     : AudioNode(context, options),
       gainCalibrationSampleRate_(context->getSampleRate()),
       remainingSegments_(0),

package/common/cpp/audioapi/core/effects/ConvolverNode.h

@@ -17,12 +17,12 @@ namespace audioapi {
 
 class AudioBus;
 class AudioBuffer;
-class ConvolverOptions;
+struct ConvolverOptions;
 
 class ConvolverNode : public AudioNode {
  public:
   explicit ConvolverNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const ConvolverOptions &options);
 
   [[nodiscard]] bool getNormalize_() const;

package/common/cpp/audioapi/core/effects/DelayNode.cpp

@@ -8,7 +8,7 @@
 
 namespace audioapi {
 
-DelayNode::DelayNode(std::shared_ptr<BaseAudioContext> context, const DelayOptions &options)
+DelayNode::DelayNode(const std::shared_ptr<BaseAudioContext>& context, const DelayOptions &options)
     : AudioNode(context, options),
       delayTimeParam_(std::make_shared<AudioParam>(options.delayTime, 0, options.maxDelayTime, context)),
       delayBuffer_(