react-native-audio-api 0.11.0-nightly-568a154-20251222 → 0.11.0-nightly-9548557-20251223

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -82,6 +82,7 @@ class AudioAPIModuleInstaller {
 
           audioContext = std::make_shared<AudioContext>(
               sampleRate, audioEventHandlerRegistry, runtimeRegistry);
+          audioContext->initialize();
 
           auto audioContextHostObject =
               std::make_shared<AudioContextHostObject>(audioContext, &runtime, jsCallInvoker);
@@ -118,6 +119,7 @@ class AudioAPIModuleInstaller {
 
           auto offlineAudioContext = std::make_shared<OfflineAudioContext>(
               numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
+          offlineAudioContext->initialize();
 
           auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
               offlineAudioContext, &runtime, jsCallInvoker);

package/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp

@@ -14,8 +14,12 @@ DelayNodeHostObject::DelayNodeHostObject(const std::shared_ptr<DelayNode> &node)
 
 size_t DelayNodeHostObject::getSizeInBytes() const {
   auto delayNode = std::static_pointer_cast<DelayNode>(node_);
-  return sizeof(float) * delayNode->context_->getSampleRate() *
-      delayNode->getDelayTimeParam()->getMaxValue();
+  auto base = sizeof(float) * delayNode->getDelayTimeParam()->getMaxValue();
+  if (std::shared_ptr<BaseAudioContext> context = delayNode->context_.lock()) {
+    return base * context->getSampleRate();
+  } else {
+    return base * 44100; // Fallback to common sample rate
+  }
 }
 
 JSI_PROPERTY_GETTER_IMPL(DelayNodeHostObject, delayTime) {

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

@@ -15,17 +15,8 @@ AudioContext::AudioContext(
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry) {
-#ifdef ANDROID
-  audioPlayer_ = std::make_shared<AudioPlayer>(
-      this->renderAudio(), sampleRate, destination_->getChannelCount());
-#else
-  audioPlayer_ = std::make_shared<IOSAudioPlayer>(
-      this->renderAudio(), sampleRate, destination_->getChannelCount());
-#endif
-
+    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry), isInitialized_(false) {
   sampleRate_ = sampleRate;
-  playerHasBeenStarted_ = false;
   state_ = ContextState::SUSPENDED;
 }
 
@@ -35,6 +26,17 @@ AudioContext::~AudioContext() {
   }
 }
 
+void AudioContext::initialize() {
+  BaseAudioContext::initialize();
+#ifdef ANDROID
+  audioPlayer_ = std::make_shared<AudioPlayer>(
+      this->renderAudio(), sampleRate_, destination_->getChannelCount());
+#else
+  audioPlayer_ = std::make_shared<IOSAudioPlayer>(
+      this->renderAudio(), sampleRate_, destination_->getChannelCount());
+#endif
+}
+
 void AudioContext::close() {
   state_ = ContextState::CLOSED;
 
@@ -52,7 +54,7 @@ bool AudioContext::resume() {
     return true;
   }
 
-  if (playerHasBeenStarted_ && audioPlayer_->resume()) {
+  if (isInitialized_ && audioPlayer_->resume()) {
     state_ = ContextState::RUNNING;
     return true;
   }
@@ -80,8 +82,8 @@ bool AudioContext::start() {
     return false;
   }
 
-  if (!playerHasBeenStarted_ && audioPlayer_->start()) {
-    playerHasBeenStarted_ = true;
+  if (!isInitialized_ && audioPlayer_->start()) {
+    isInitialized_ = true;
     state_ = ContextState::RUNNING;
 
     return true;

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

@@ -25,6 +25,7 @@ class AudioContext : public BaseAudioContext {
   bool resume();
   bool suspend();
   bool start();
+  void initialize() override;
 
  private:
 #ifdef ANDROID
@@ -32,7 +33,7 @@ class AudioContext : public BaseAudioContext {
 #else
   std::shared_ptr<IOSAudioPlayer> audioPlayer_;
 #endif
-  bool playerHasBeenStarted_;
+  bool isInitialized_;
 
   bool isDriverRunning() const override;
 

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

@@ -10,10 +10,13 @@
 
 namespace audioapi {
 
-AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
-  audioBus_ =
-      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
-}
+AudioNode::AudioNode(std::shared_ptr<BaseAudioContext> context)
+    : context_(context),
+      audioBus_(
+          std::make_shared<AudioBus>(
+              RENDER_QUANTUM_SIZE,
+              channelCount_,
+              context->getSampleRate())) {}
 
 AudioNode::~AudioNode() {
   if (isInitialized_) {
@@ -42,28 +45,38 @@ std::string AudioNode::getChannelInterpretation() const {
 }
 
 void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    context->getNodeManager()->addPendingNodeConnection(
+        shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
+  }
 }
 
 void AudioNode::connect(const std::shared_ptr<AudioParam> &param) {
-  context_->getNodeManager()->addPendingParamConnection(
-      shared_from_this(), param, AudioNodeManager::ConnectionType::CONNECT);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    context->getNodeManager()->addPendingParamConnection(
+        shared_from_this(), param, AudioNodeManager::ConnectionType::CONNECT);
+  }
 }
 
 void AudioNode::disconnect() {
-  context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(), nullptr, AudioNodeManager::ConnectionType::DISCONNECT_ALL);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    context->getNodeManager()->addPendingNodeConnection(
+        shared_from_this(), nullptr, AudioNodeManager::ConnectionType::DISCONNECT_ALL);
+  }
 }
 
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    context->getNodeManager()->addPendingNodeConnection(
+        shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
+  }
 }
 
 void AudioNode::disconnect(const std::shared_ptr<AudioParam> &param) {
-  context_->getNodeManager()->addPendingParamConnection(
-      shared_from_this(), param, AudioNodeManager::ConnectionType::DISCONNECT);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    context->getNodeManager()->addPendingParamConnection(
+        shared_from_this(), param, AudioNodeManager::ConnectionType::DISCONNECT);
+  }
 }
 
 bool AudioNode::isEnabled() const {
@@ -147,23 +160,25 @@ std::shared_ptr<AudioBus> AudioNode::processAudio(
 
   // Finally, process the node itself.
   return processNode(processingBus, framesToProcess);
-  ;
 }
 
 bool AudioNode::isAlreadyProcessed() {
-  assert(context_ != nullptr);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    std::size_t currentSampleFrame = context->getCurrentSampleFrame();
+
+    // check if the node has already been processed for this rendering quantum
+    if (currentSampleFrame == lastRenderedFrame_) {
+      return true;
+    }
 
-  std::size_t currentSampleFrame = context_->getCurrentSampleFrame();
+    // Update the last rendered frame before processing node and its inputs.
+    lastRenderedFrame_ = currentSampleFrame;
 
-  // check if the node has already been processed for this rendering quantum
-  if (currentSampleFrame == lastRenderedFrame_) {
-    return true;
+    return false;
   }
 
-  // Update the last rendered frame before processing node and its inputs.
-  lastRenderedFrame_ = currentSampleFrame;
-
-  return false;
+  // If context is invalid, consider it as already processed to avoid processing
+  return true;
 }
 
 std::shared_ptr<AudioBus> AudioNode::processInputs(

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

@@ -19,7 +19,7 @@ class AudioParam;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
-  explicit AudioNode(BaseAudioContext *context);
+  explicit AudioNode(std::shared_ptr<BaseAudioContext> context);
   virtual ~AudioNode();
 
   int getNumberOfInputs() const;
@@ -47,13 +47,13 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   friend class AudioDestinationNode;
   friend class ConvolverNode;
   friend class DelayNodeHostObject;
+  int channelCount_ = 2;
 
-  BaseAudioContext *context_;
+  std::weak_ptr<BaseAudioContext> context_;
   std::shared_ptr<AudioBus> audioBus_;
 
   int numberOfInputs_ = 1;
   int numberOfOutputs_ = 1;
-  int channelCount_ = 2;
   ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
   ChannelInterpretation channelInterpretation_ =
 

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

@@ -35,12 +35,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 +79,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 +93,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 +104,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 +138,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 +164,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 +196,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,7 +204,8 @@ 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;
 }

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

@@ -38,13 +38,15 @@ class WorkletNode;
 class WorkletProcessingNode;
 class StreamerNode;
 
-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;

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)),
+      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_)) {
   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,7 +12,7 @@
 
 namespace audioapi {
 ConvolverNode::ConvolverNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     const std::shared_ptr<AudioBuffer> &buffer,
     bool disableNormalization)
     : AudioNode(context),
@@ -22,11 +22,11 @@ ConvolverNode::ConvolverNode(
       scaleFactor_(1.0f),
       intermediateBus_(nullptr),
       buffer_(nullptr),
-      internalBuffer_(nullptr) {
+      internalBuffer_(nullptr),
+      gainCalibrationSampleRate_(context->getSampleRate()),
+      normalize_(!disableNormalization) {
   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);