react-native-audio-api 0.12.0-nightly-3254662-20260127 → 0.12.0-nightly-1a3c43b-20260128

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,12 +11,12 @@
 
 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)
+AudioNode::AudioNode(const std::shared_ptr<BaseAudioContext>& context, const AudioNodeOptions &options)
     : channelCount_(options.channelCount),
       context_(context),
       channelCountMode_(options.channelCountMode),

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_(

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

@@ -9,11 +9,11 @@
 namespace audioapi {
 
 class AudioBus;
-class DelayOptions;
+struct DelayOptions;
 
 class DelayNode : public AudioNode {
  public:
-  explicit DelayNode(std::shared_ptr<BaseAudioContext> context, const DelayOptions &options);
+  explicit DelayNode(const std::shared_ptr<BaseAudioContext> &context, const DelayOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const;
 

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

@@ -8,7 +8,7 @@
 
 namespace audioapi {
 
-GainNode::GainNode(std::shared_ptr<BaseAudioContext> context, const GainOptions &options)
+GainNode::GainNode(const std::shared_ptr<BaseAudioContext> &context, const GainOptions &options)
     : AudioNode(context, options),
       gainParam_(
           std::make_shared<AudioParam>(

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

@@ -8,11 +8,11 @@
 namespace audioapi {
 
 class AudioBus;
-class GainOptions;
+struct GainOptions;
 
 class GainNode : public AudioNode {
  public:
-  explicit GainNode(std::shared_ptr<BaseAudioContext> context, const GainOptions &options);
+  explicit GainNode(const std::shared_ptr<BaseAudioContext> &context, const GainOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 

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

@@ -36,10 +36,12 @@
 
 namespace audioapi {
 
-IIRFilterNode::IIRFilterNode(std::shared_ptr<BaseAudioContext> context, const IIRFilterOptions &options)
+IIRFilterNode::IIRFilterNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const IIRFilterOptions &options)
     : AudioNode(context, options),
-    feedforward_(std::move(options.feedforward)),
-    feedback_(std::move(options.feedback)) {
+      feedforward_(std::move(options.feedforward)),
+      feedback_(std::move(options.feedback)) {
 
   int maxChannels = MAX_CHANNEL_COUNT;
   xBuffers_.resize(maxChannels);

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

@@ -33,13 +33,13 @@
 
 namespace audioapi {
 
-class IIRFilterOptions;
+struct IIRFilterOptions;
 
 class IIRFilterNode : public AudioNode {
 
  public:
   explicit IIRFilterNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const IIRFilterOptions &options);
 
   void getFrequencyResponse(

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

@@ -10,8 +10,11 @@
 
 namespace audioapi {
 
-StereoPannerNode::StereoPannerNode(std::shared_ptr<BaseAudioContext> context, const StereoPannerOptions &options)
-    : AudioNode(context, options), panParam_(std::make_shared<AudioParam>(options.pan, -1.0f, 1.0f, context)) {
+StereoPannerNode::StereoPannerNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const StereoPannerOptions &options)
+    : AudioNode(context, options),
+      panParam_(std::make_shared<AudioParam>(options.pan, -1.0f, 1.0f, context)) {
   isInitialized_ = true;
 }
 

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

@@ -10,12 +10,12 @@
 namespace audioapi {
 
 class AudioBus;
-class StereoPannerOptions;
+struct StereoPannerOptions;
 
 class StereoPannerNode : public AudioNode {
  public:
   explicit StereoPannerNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const StereoPannerOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;

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

@@ -1,9 +1,9 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/WaveShaperNode.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
-#include <audioapi/HostObjects/utils/NodeOptions.h>
 
 #include <algorithm>
 #include <memory>
@@ -11,7 +11,9 @@
 
 namespace audioapi {
 
-WaveShaperNode::WaveShaperNode(std::shared_ptr<BaseAudioContext> context, const WaveShaperOptions &options)
+WaveShaperNode::WaveShaperNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const WaveShaperOptions &options)
     : AudioNode(context, options), oversample_(options.oversample) {
 
   waveShapers_.reserve(6);

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

@@ -16,12 +16,12 @@ namespace audioapi {
 
 class AudioBus;
 class AudioArray;
-class WaveShaperOptions;
+struct WaveShaperOptions;
 
 class WaveShaperNode : public AudioNode {
  public:
   explicit WaveShaperNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const WaveShaperOptions &options);
 
   [[nodiscard]] OverSampleType getOversample() const;

package/common/cpp/audioapi/core/sources/AudioBuffer.h

@@ -10,7 +10,7 @@
 namespace audioapi {
 
 class AudioBus;
-class AudioBufferOptions;
+struct AudioBufferOptions;
 
 class AudioBuffer {
  public:

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp

@@ -12,7 +12,7 @@
 
 namespace audioapi {
 AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
-    std::shared_ptr<BaseAudioContext> context,
+    const std::shared_ptr<BaseAudioContext> &context,
     const BaseAudioBufferSourceOptions &options)
     : AudioScheduledSourceNode(context),
       pitchCorrection_(options.pitchCorrection),
@@ -42,7 +42,7 @@ void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(uint64_t callback
   auto oldCallbackId = onPositionChangedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
   if (oldCallbackId != 0) {
-    audioEventHandlerRegistry_->unregisterHandler("positionChanged", oldCallbackId);
+    audioEventHandlerRegistry_->unregisterHandler(AudioEvent::POSITION_CHANGED, oldCallbackId);
   }
 }
 
@@ -90,7 +90,7 @@ void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
     std::unordered_map<std::string, EventValue> body = {{"value", getCurrentPosition()}};
 
     audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "positionChanged", onPositionChangedCallbackId, body);
+        AudioEvent::POSITION_CHANGED, onPositionChangedCallbackId, body);
 
     onPositionChangedTime_ = 0;
   }
@@ -157,7 +157,13 @@ void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
   }
   auto computedPlaybackRate =
       getComputedPlaybackRateValue(framesToProcess, context->getCurrentTime());
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
+  updatePlaybackInfo(
+      processingBus,
+      framesToProcess,
+      startOffset,
+      offsetLength,
+      context->getSampleRate(),
+      context->getCurrentSampleFrame());
 
   if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h

@@ -11,12 +11,12 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
-class BaseAudioBufferSourceOptions;
+struct BaseAudioBufferSourceOptions;
 
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferBaseSourceNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const BaseAudioBufferSourceOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;