react-native-audio-api 0.11.0-nightly-568a154-20251222 → 0.11.0-nightly-94b7f30-20251224

package/common/cpp/audioapi/core/AudioParam.cpp

@@ -12,7 +12,7 @@ AudioParam::AudioParam(
     float defaultValue,
     float minValue,
     float maxValue,
-    BaseAudioContext *context)
+    std::shared_ptr<BaseAudioContext> context)
     : context_(context),
       value_(defaultValue),
       defaultValue_(defaultValue),
@@ -20,13 +20,13 @@ AudioParam::AudioParam(
       maxValue_(maxValue),
       eventsQueue_(),
       eventScheduler_(32),
+      startTime_(0),
+      endTime_(0),
+      startValue_(defaultValue),
+      endValue_(defaultValue),
       audioBus_(std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())) {
   inputBuses_.reserve(4);
   inputNodes_.reserve(4);
-  startTime_ = 0;
-  endTime_ = 0;
-  startValue_ = value_;
-  endValue_ = value_;
   // Default calculation function just returns the static value
   calculateValue_ = [this](double, double, float, float, double) {
     return value_;
@@ -258,7 +258,10 @@ std::shared_ptr<AudioBus> AudioParam::processARateParam(int framesToProcess, dou
   processScheduledEvents();
   auto processingBus = calculateInputs(audioBus_, framesToProcess);
 
-  float sampleRate = context_->getSampleRate();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return processingBus;
+  float sampleRate = context->getSampleRate();
   float *busData = processingBus->getChannel(0)->getData();
   float timeCache = time;
   float timeStep = 1.0f / sampleRate;

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

@@ -21,7 +21,7 @@ class AudioParam {
       float defaultValue,
       float minValue,
       float maxValue,
-      BaseAudioContext *context);
+      std::shared_ptr<BaseAudioContext> context);
 
   /// JS-Thread only methods
   /// These methods are called only from HostObjects invoked on the JS thread.
@@ -93,7 +93,7 @@ class AudioParam {
 
  private:
   // Core parameter state
-  BaseAudioContext *context_;
+  std::weak_ptr<BaseAudioContext> context_;
   float value_;
   float defaultValue_;
   float minValue_;

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

@@ -7,6 +7,7 @@
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/IIRFilterNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
 #include <audioapi/core/effects/WorkletNode.h>
 #include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
@@ -35,12 +36,13 @@ namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
     const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    const RuntimeRegistry &runtimeRegistry) {
-  nodeManager_ = std::make_shared<AudioNodeManager>();
-  destination_ = std::make_shared<AudioDestinationNode>(this);
+    const RuntimeRegistry &runtimeRegistry)
+    : nodeManager_(std::make_shared<AudioNodeManager>()),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry),
+      runtimeRegistry_(runtimeRegistry) {}
 
-  audioEventHandlerRegistry_ = audioEventHandlerRegistry;
-  runtimeRegistry_ = runtimeRegistry;
+void BaseAudioContext::initialize() {
+  destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
 }
 
 std::string BaseAudioContext::getState() {
@@ -78,7 +80,8 @@ std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
     std::weak_ptr<worklets::WorkletRuntime> runtime,
     bool shouldLockRuntime) {
   WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
-  auto workletSourceNode = std::make_shared<WorkletSourceNode>(this, std::move(workletRunner));
+  auto workletSourceNode =
+      std::make_shared<WorkletSourceNode>(shared_from_this(), std::move(workletRunner));
   nodeManager_->addSourceNode(workletSourceNode);
   return workletSourceNode;
 }
@@ -91,7 +94,7 @@ std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
     bool shouldLockRuntime) {
   WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletNode = std::make_shared<WorkletNode>(
-      this, bufferLength, inputChannelCount, std::move(workletRunner));
+      shared_from_this(), bufferLength, inputChannelCount, std::move(workletRunner));
   nodeManager_->addProcessingNode(workletNode);
   return workletNode;
 }
@@ -102,32 +105,32 @@ std::shared_ptr<WorkletProcessingNode> BaseAudioContext::createWorkletProcessing
     bool shouldLockRuntime) {
   WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletProcessingNode =
-      std::make_shared<WorkletProcessingNode>(this, std::move(workletRunner));
+      std::make_shared<WorkletProcessingNode>(shared_from_this(), std::move(workletRunner));
   nodeManager_->addProcessingNode(workletProcessingNode);
   return workletProcessingNode;
 }
 
 std::shared_ptr<RecorderAdapterNode> BaseAudioContext::createRecorderAdapter() {
-  auto recorderAdapter = std::make_shared<RecorderAdapterNode>(this);
+  auto recorderAdapter = std::make_shared<RecorderAdapterNode>(shared_from_this());
   nodeManager_->addProcessingNode(recorderAdapter);
   return recorderAdapter;
 }
 
 std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
-  auto oscillator = std::make_shared<OscillatorNode>(this);
+  auto oscillator = std::make_shared<OscillatorNode>(shared_from_this());
   nodeManager_->addSourceNode(oscillator);
   return oscillator;
 }
 
 std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource() {
-  auto constantSource = std::make_shared<ConstantSourceNode>(this);
+  auto constantSource = std::make_shared<ConstantSourceNode>(shared_from_this());
   nodeManager_->addSourceNode(constantSource);
   return constantSource;
 }
 
 std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-  auto streamer = std::make_shared<StreamerNode>(this);
+  auto streamer = std::make_shared<StreamerNode>(shared_from_this());
   nodeManager_->addSourceNode(streamer);
   return streamer;
 #else
@@ -136,25 +139,25 @@ std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
 }
 
 std::shared_ptr<GainNode> BaseAudioContext::createGain() {
-  auto gain = std::make_shared<GainNode>(this);
+  auto gain = std::make_shared<GainNode>(shared_from_this());
   nodeManager_->addProcessingNode(gain);
   return gain;
 }
 
 std::shared_ptr<DelayNode> BaseAudioContext::createDelay(float maxDelayTime) {
-  auto delay = std::make_shared<DelayNode>(this, maxDelayTime);
+  auto delay = std::make_shared<DelayNode>(shared_from_this(), maxDelayTime);
   nodeManager_->addProcessingNode(delay);
   return delay;
 }
 
 std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner() {
-  auto stereoPanner = std::make_shared<StereoPannerNode>(this);
+  auto stereoPanner = std::make_shared<StereoPannerNode>(shared_from_this());
   nodeManager_->addProcessingNode(stereoPanner);
   return stereoPanner;
 }
 
 std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
-  auto biquadFilter = std::make_shared<BiquadFilterNode>(this);
+  auto biquadFilter = std::make_shared<BiquadFilterNode>(shared_from_this());
   nodeManager_->addProcessingNode(biquadFilter);
   return biquadFilter;
 }
@@ -162,20 +165,21 @@ std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
 std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(
     const std::vector<float> &feedforward,
     const std::vector<float> &feedback) {
-  auto iirFilter = std::make_shared<IIRFilterNode>(this, feedforward, feedback);
+  auto iirFilter = std::make_shared<IIRFilterNode>(shared_from_this(), feedforward, feedback);
   nodeManager_->addProcessingNode(iirFilter);
   return iirFilter;
 }
 
 std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(bool pitchCorrection) {
-  auto bufferSource = std::make_shared<AudioBufferSourceNode>(this, pitchCorrection);
+  auto bufferSource = std::make_shared<AudioBufferSourceNode>(shared_from_this(), pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
 std::shared_ptr<AudioBufferQueueSourceNode> BaseAudioContext::createBufferQueueSource(
     bool pitchCorrection) {
-  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(this, pitchCorrection);
+  auto bufferSource =
+      std::make_shared<AudioBufferQueueSourceNode>(shared_from_this(), pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
@@ -193,7 +197,7 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
 }
 
 std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
-  auto analyser = std::make_shared<AnalyserNode>(this);
+  auto analyser = std::make_shared<AnalyserNode>(shared_from_this());
   nodeManager_->addProcessingNode(analyser);
   return analyser;
 }
@@ -201,11 +205,18 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
 std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(
     std::shared_ptr<AudioBuffer> buffer,
     bool disableNormalization) {
-  auto convolver = std::make_shared<ConvolverNode>(this, buffer, disableNormalization);
+  auto convolver =
+      std::make_shared<ConvolverNode>(shared_from_this(), buffer, disableNormalization);
   nodeManager_->addProcessingNode(convolver);
   return convolver;
 }
 
+std::shared_ptr<WaveShaperNode> BaseAudioContext::createWaveShaper() {
+  auto waveShaper = std::make_shared<WaveShaperNode>(shared_from_this());
+  nodeManager_->addProcessingNode(waveShaper);
+  return waveShaper;
+}
+
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }

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

@@ -37,14 +37,17 @@ class WorkletSourceNode;
 class WorkletNode;
 class WorkletProcessingNode;
 class StreamerNode;
+class WaveShaperNode;
 
-class BaseAudioContext {
+class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
  public:
   explicit BaseAudioContext(
       const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const RuntimeRegistry &runtimeRegistry);
   virtual ~BaseAudioContext() = default;
 
+  virtual void initialize();
+
   std::string getState();
   [[nodiscard]] float getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
@@ -88,6 +91,7 @@ class BaseAudioContext {
   std::shared_ptr<ConvolverNode> createConvolver(
       std::shared_ptr<AudioBuffer> buffer,
       bool disableNormalization);
+  std::shared_ptr<WaveShaperNode> createWaveShaper();
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;

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

@@ -12,23 +12,20 @@
 #include <vector>
 
 namespace audioapi {
-AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
+AnalyserNode::AnalyserNode(std::shared_ptr<BaseAudioContext> context)
     : AudioNode(context),
       fftSize_(2048),
       minDecibels_(-100),
       maxDecibels_(-30),
       smoothingTimeConstant_(0.8),
-      windowType_(WindowType::BLACKMAN) {
-  inputBuffer_ = std::make_unique<CircularAudioArray>(MAX_FFT_SIZE * 2);
-  tempBuffer_ = std::make_unique<AudioArray>(fftSize_);
-  magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
-  downMixBus_ = std::make_unique<AudioBus>(RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
-
-  fft_ = std::make_unique<dsp::FFT>(fftSize_);
-  complexData_ = std::vector<std::complex<float>>(fftSize_);
-
+      windowType_(WindowType::BLACKMAN),
+      inputBuffer_(std::make_unique<CircularAudioArray>(MAX_FFT_SIZE * 2)),
+      downMixBus_(std::make_unique<AudioBus>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())),
+      tempBuffer_(std::make_unique<AudioArray>(fftSize_)),
+      fft_(std::make_unique<dsp::FFT>(fftSize_)),
+      complexData_(std::vector<std::complex<float>>(fftSize_)),
+      magnitudeBuffer_(std::make_unique<AudioArray>(fftSize_ / 2)) {
   setWindowData(windowType_, fftSize_);
-
   isInitialized_ = true;
 }
 

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

@@ -19,7 +19,7 @@ class CircularAudioArray;
 class AnalyserNode : public AudioNode {
  public:
   enum class WindowType { BLACKMAN, HANN };
-  explicit AnalyserNode(BaseAudioContext *context);
+  explicit AnalyserNode(std::shared_ptr<BaseAudioContext> context);
 
   int getFftSize() const;
   int getFrequencyBinCount() const;

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

@@ -7,7 +7,7 @@
 
 namespace audioapi {
 
-AudioDestinationNode::AudioDestinationNode(BaseAudioContext *context)
+AudioDestinationNode::AudioDestinationNode(std::shared_ptr<BaseAudioContext> context)
     : AudioNode(context), currentSampleFrame_(0) {
   numberOfOutputs_ = 0;
   numberOfInputs_ = 1;
@@ -20,7 +20,11 @@ std::size_t AudioDestinationNode::getCurrentSampleFrame() const {
 }
 
 double AudioDestinationNode::getCurrentTime() const {
-  return static_cast<double>(currentSampleFrame_) / context_->getSampleRate();
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    return static_cast<double>(currentSampleFrame_) / context->getSampleRate();
+  } else {
+    return 0.0;
+  }
 }
 
 void AudioDestinationNode::renderAudio(
@@ -30,7 +34,9 @@ void AudioDestinationNode::renderAudio(
     return;
   }
 
-  context_->getNodeManager()->preProcessGraph();
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    context->getNodeManager()->preProcessGraph();
+  }
 
   destinationBus->zero();
 

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

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

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

@@ -38,7 +38,7 @@
 
 namespace audioapi {
 
-BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context) : AudioNode(context) {
+BiquadFilterNode::BiquadFilterNode(std::shared_ptr<BaseAudioContext> context) : AudioNode(context) {
   frequencyParam_ =
       std::make_shared<AudioParam>(350.0, 0.0f, context->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
@@ -57,6 +57,7 @@ BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context) : AudioNode(contex
   y2_.resize(MAX_CHANNEL_COUNT, 0.0f);
   isInitialized_ = true;
   channelCountMode_ = ChannelCountMode::MAX;
+  isInitialized_ = true;
 }
 
 std::string BiquadFilterNode::getType() {
@@ -118,7 +119,10 @@ void BiquadFilterNode::getFrequencyResponse(
   double a1 = static_cast<double>(a1_);
   double a2 = static_cast<double>(a2_);
 
-  float nyquist = context_->getNyquistFrequency();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (!context)
+    return;
+  float nyquist = context->getNyquistFrequency();
 
   for (size_t i = 0; i < length; i++) {
     // Convert from frequency in Hz to normalized frequency [0, 1]
@@ -330,17 +334,22 @@ void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
 }
 
 void BiquadFilterNode::applyFilter() {
-  double currentTime = context_->getCurrentTime();
-
-  float frequency = frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  // NyquistFrequency is half of the sample rate.
+  // Normalized frequency is therefore:
+  // frequency / (sampleRate / 2) = (2 * frequency) / sampleRate
+  float normalizedFrequency;
+  double currentTime;
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    currentTime = context->getCurrentTime();
+    float frequency = frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+    normalizedFrequency = frequency / context->getNyquistFrequency();
+  } else {
+    return;
+  }
   float detune = detuneParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
   auto Q = QParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
   auto gain = gainParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
 
-  // NyquistFrequency is half of the sample rate.
-  // Normalized frequency is therefore:
-  // frequency / (sampleRate / 2) = (2 * frequency) / sampleRate
-  float normalizedFrequency = frequency / context_->getNyquistFrequency();
   if (detune != 0.0f) {
     normalizedFrequency *= std::pow(2.0f, detune / 1200.0f);
   }

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

@@ -54,7 +54,7 @@ class BiquadFilterNode : public AudioNode {
 #endif // RN_AUDIO_API_TEST
 
  public:
-  explicit BiquadFilterNode(BaseAudioContext *context);
+  explicit BiquadFilterNode(std::shared_ptr<BaseAudioContext> context);
 
   [[nodiscard]] std::string getType();
   void setType(const std::string &type);

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

@@ -12,12 +12,14 @@
 
 namespace audioapi {
 ConvolverNode::ConvolverNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     const std::shared_ptr<AudioBuffer> &buffer,
     bool disableNormalization)
     : AudioNode(context),
+      gainCalibrationSampleRate_(context->getSampleRate()),
       remainingSegments_(0),
       internalBufferIndex_(0),
+      normalize_(!disableNormalization),
       signalledToStop_(false),
       scaleFactor_(1.0f),
       intermediateBus_(nullptr),
@@ -25,8 +27,6 @@ ConvolverNode::ConvolverNode(
       internalBuffer_(nullptr) {
   channelCount_ = 2;
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
-  normalize_ = !disableNormalization;
-  gainCalibrationSampleRate_ = context->getSampleRate();
   setBuffer(buffer);
   audioBus_ =
       std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());

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

@@ -21,7 +21,7 @@ class AudioBuffer;
 class ConvolverNode : public AudioNode {
  public:
   explicit ConvolverNode(
-      BaseAudioContext *context,
+      std::shared_ptr<BaseAudioContext> context,
       const std::shared_ptr<AudioBuffer> &buffer,
       bool disableNormalization);
 

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

@@ -7,14 +7,16 @@
 
 namespace audioapi {
 
-DelayNode::DelayNode(BaseAudioContext *context, float maxDelayTime) : AudioNode(context) {
-  delayTimeParam_ = std::make_shared<AudioParam>(0, 0, maxDelayTime, context);
-  delayBuffer_ = std::make_shared<AudioBus>(
-      static_cast<size_t>(
-          maxDelayTime * context->getSampleRate() +
-          1), // +1 to enable delayTime equal to maxDelayTime
-      channelCount_,
-      context->getSampleRate());
+DelayNode::DelayNode(std::shared_ptr<BaseAudioContext> context, float maxDelayTime)
+    : AudioNode(context),
+      delayTimeParam_(std::make_shared<AudioParam>(0, 0, maxDelayTime, context)),
+      delayBuffer_(
+          std::make_shared<AudioBus>(
+              static_cast<size_t>(
+                  maxDelayTime * context->getSampleRate() +
+                  1), // +1 to enable delayTime equal to maxDelayTime
+              channelCount_,
+              context->getSampleRate())) {
   requiresTailProcessing_ = true;
   isInitialized_ = true;
 }
@@ -27,7 +29,11 @@ void DelayNode::onInputDisabled() {
   numberOfEnabledInputNodes_ -= 1;
   if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
     signalledToStop_ = true;
-    remainingFrames_ = delayTimeParam_->getValue() * context_->getSampleRate();
+    if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+      remainingFrames_ = delayTimeParam_->getValue() * context->getSampleRate();
+    } else {
+      remainingFrames_ = 0;
+    }
   }
 }
 
@@ -89,8 +95,11 @@ std::shared_ptr<AudioBus> DelayNode::processNode(
   }
 
   // normal processing
-  auto delayTime = delayTimeParam_->processKRateParam(framesToProcess, context_->getCurrentTime());
-  size_t writeIndex = static_cast<size_t>(readIndex_ + delayTime * context_->getSampleRate()) %
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return processingBus;
+  auto delayTime = delayTimeParam_->processKRateParam(framesToProcess, context->getCurrentTime());
+  size_t writeIndex = static_cast<size_t>(readIndex_ + delayTime * context->getSampleRate()) %
       delayBuffer_->getSize();
   delayBufferOperation(processingBus, framesToProcess, writeIndex, DelayNode::BufferAction::WRITE);
   delayBufferOperation(processingBus, framesToProcess, readIndex_, DelayNode::BufferAction::READ);

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

@@ -12,7 +12,7 @@ class AudioBus;
 
 class DelayNode : public AudioNode {
  public:
-  explicit DelayNode(BaseAudioContext *context, float maxDelayTime);
+  explicit DelayNode(std::shared_ptr<BaseAudioContext> context, float maxDelayTime);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const;
 

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

@@ -7,9 +7,14 @@
 
 namespace audioapi {
 
-GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
-  gainParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+GainNode::GainNode(std::shared_ptr<BaseAudioContext> context)
+    : AudioNode(context),
+      gainParam_(
+          std::make_shared<AudioParam>(
+              1.0,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)) {
   isInitialized_ = true;
 }
 
@@ -20,7 +25,10 @@ std::shared_ptr<AudioParam> GainNode::getGainParam() const {
 std::shared_ptr<AudioBus> GainNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  double time = context_->getCurrentTime();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return processingBus;
+  double time = context->getCurrentTime();
   auto gainParamValues = gainParam_->processARateParam(framesToProcess, time);
   for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
     dsp::multiply(

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

@@ -11,7 +11,7 @@ class AudioBus;
 
 class GainNode : public AudioNode {
  public:
-  explicit GainNode(BaseAudioContext *context);
+  explicit GainNode(std::shared_ptr<BaseAudioContext> context);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 

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

@@ -35,11 +35,10 @@
 namespace audioapi {
 
 IIRFilterNode::IIRFilterNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     const std::vector<float> &feedforward,
     const std::vector<float> &feedback)
     : AudioNode(context), feedforward_(feedforward), feedback_(feedback) {
-  isInitialized_ = true;
   channelCountMode_ = ChannelCountMode::MAX;
 
   int maxChannels = MAX_CHANNEL_COUNT;
@@ -65,6 +64,7 @@ IIRFilterNode::IIRFilterNode(
 
     feedback_[0] = 1.0f;
   }
+  isInitialized_ = true;
 }
 
 // Compute Z-transform of the filter
@@ -89,7 +89,10 @@ void IIRFilterNode::getFrequencyResponse(
     float *magResponseOutput,
     float *phaseResponseOutput,
     size_t length) {
-  float nyquist = context_->getNyquistFrequency();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return;
+  float nyquist = context->getNyquistFrequency();
 
   for (size_t k = 0; k < length; ++k) {
     float normalizedFreq = frequencyArray[k] / nyquist;

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

@@ -37,7 +37,7 @@ class IIRFilterNode : public AudioNode {
 
  public:
   explicit IIRFilterNode(
-      BaseAudioContext *context,
+      std::shared_ptr<BaseAudioContext> context,
       const std::vector<float> &feedforward,
       const std::vector<float> &feedback);
 

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

@@ -9,9 +9,9 @@
 
 namespace audioapi {
 
-StereoPannerNode::StereoPannerNode(BaseAudioContext *context) : AudioNode(context) {
+StereoPannerNode::StereoPannerNode(std::shared_ptr<BaseAudioContext> context)
+    : AudioNode(context), panParam_(std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context)) {
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
-  panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context);
   isInitialized_ = true;
 }
 
@@ -22,8 +22,11 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
 std::shared_ptr<AudioBus> StereoPannerNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  double time = context_->getCurrentTime();
-  double deltaTime = 1.0 / context_->getSampleRate();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return processingBus;
+  double time = context->getCurrentTime();
+  double deltaTime = 1.0 / context->getSampleRate();
 
   auto *inputLeft = processingBus->getChannelByType(AudioBus::ChannelLeft);
   auto panParamValues =

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

@@ -13,7 +13,7 @@ class AudioBus;
 
 class StereoPannerNode : public AudioNode {
  public:
-  explicit StereoPannerNode(BaseAudioContext *context);
+  explicit StereoPannerNode(std::shared_ptr<BaseAudioContext> context);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;