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

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -109,7 +109,7 @@ Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
 Result<std::string, std::string> AndroidAudioRecorder::start() {
   std::scoped_lock startLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
 
-  if (isRecording()) {
+  if (!isIdle()) {
     return Result<std::string, std::string>::Err("Recorder is already recording");
   }
 

package/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp

@@ -103,7 +103,9 @@ Result<NoneType, std::string> AndroidRecorderCallback::prepare(
 }
 
 void AndroidRecorderCallback::cleanup() {
-  emitAudioData(true);
+  if (circularBus_[0]->getNumberOfAvailableFrames() > 0) {
+    emitAudioData(true);
+  }
 
   if (converter_ != nullptr) {
     ma_data_converter_uninit(converter_.get(), NULL);
@@ -136,7 +138,10 @@ void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
   if (static_cast<float>(streamSampleRate_) == sampleRate_ &&
       streamChannelCount_ == channelCount_) {
     deinterleaveAndPushAudioData(data, numFrames);
-    emitAudioData();
+
+    if (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+      emitAudioData();
+    }
     return;
   }
 
@@ -147,7 +152,10 @@ void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
       converter_.get(), data, &inputFrameCount, processingBuffer_, &outputFrameCount);
 
   deinterleaveAndPushAudioData(processingBuffer_, static_cast<int>(outputFrameCount));
-  emitAudioData();
+
+  if (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+    emitAudioData();
+  }
 }
 
 /// @brief Deinterleaves the audio data and pushes it into the circular buffer.

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp

@@ -17,12 +17,13 @@ extern "C" {
 #include <audioapi/utils/UnitConversion.h>
 
 #include <algorithm>
+#include <cassert>
 #include <memory>
 #include <string>
 #include <utility>
 
-constexpr int defaultFrameRatio = 4;
 constexpr int fallbackFIFOSize = 8192;
+constexpr int fallbackFrameSize = 512;
 constexpr int defaultFlushInterval = 100;
 
 namespace audioapi::android::ffmpeg {
@@ -33,7 +34,7 @@ FFmpegAudioFileWriter::FFmpegAudioFileWriter(
     : AndroidFileWriterBackend(audioEventHandlerRegistry, fileProperties) {
   // Set flush interval from properties, limit minimum to 100ms
   // to avoid people hurting themselves too much
-  flushIntervalMs_ = std::min(fileProperties_->androidFlushIntervalMs, defaultFlushInterval);
+  flushIntervalMs_ = std::max(fileProperties_->androidFlushIntervalMs, defaultFlushInterval);
 }
 
 FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
@@ -278,23 +279,40 @@ Result<NoneType, std::string> FFmpegAudioFileWriter::initializeResampler(
 /// that might be needed for storing intermediate audio data or buffering before encoding.
 /// @param maxBufferSize The maximum buffer size to allocate.
 void FFmpegAudioFileWriter::initializeBuffers(int32_t maxBufferSize) {
-  frame_ = av_unique_ptr<AVFrame>(av_frame_alloc());
+  resamplerFrame_ = av_unique_ptr<AVFrame>(av_frame_alloc());
+  writingFrame_ = av_unique_ptr<AVFrame>(av_frame_alloc());
   packet_ = av_unique_ptr<AVPacket>(av_packet_alloc());
 
-  int frameRatio = defaultFrameRatio;
-  if (encoderCtx_->frame_size > 0) {
-    frameRatio = static_cast<int>(std::ceil(
-        static_cast<double>(maxBufferSize) / static_cast<double>(encoderCtx_->frame_size)));
-  }
-
-  int calculatedSize =
-      (encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size * frameRatio
-                                   : maxBufferSize * frameRatio);
-
-  int fifoSize = std::max(calculatedSize, fallbackFIFOSize);
+  // Calculate resampler size of output buffer from the resampler
+  int resamplerFrameSize = av_rescale_rnd(
+      maxBufferSize,
+      static_cast<int>(encoderCtx_->sample_rate),
+      static_cast<int>(streamSampleRate_),
+      AV_ROUND_UP);
+
+  // Configure frame parameters for desired file output
+  resamplerFrame_->nb_samples = resamplerFrameSize;
+  resamplerFrame_->format = encoderCtx_->sample_fmt;
+  av_channel_layout_copy(&resamplerFrame_->ch_layout, &encoderCtx_->ch_layout);
+  // Allocate buffer for the resampler frame
+  av_frame_get_buffer(resamplerFrame_.get(), 0);
+
+  // calculate FIFO size based on max buffer size and encoder frame size
+  // max(2 * resamplerFrameSize, 2 * encoderCtx_->frame_size, fallbackFIFOSize)
+  int writingFrameSize = 2 * std::max(encoderCtx_->frame_size, fallbackFrameSize);
+  int fifoSize = std::max(std::max(2 * resamplerFrameSize, writingFrameSize), fallbackFIFOSize);
 
   audioFifo_ = av_unique_ptr<AVAudioFifo>(
       av_audio_fifo_alloc(encoderCtx_->sample_fmt, encoderCtx_->ch_layout.nb_channels, fifoSize));
+
+  // Configure writing frame parameters
+  // size 2 x encoder frame size + same format as encoder
+  writingFrame_->nb_samples = writingFrameSize;
+  av_channel_layout_copy(&writingFrame_->ch_layout, &encoderCtx_->ch_layout);
+  writingFrame_->format = encoderCtx_->sample_fmt;
+  writingFrame_->sample_rate = encoderCtx_->sample_rate;
+  // Allocate buffer for the writing frame
+  av_frame_get_buffer(writingFrame_.get(), 0);
 }
 
 /// @brief Resamples input audio data and pushes it to the audio FIFO.
@@ -302,34 +320,30 @@ void FFmpegAudioFileWriter::initializeBuffers(int32_t maxBufferSize) {
 /// @param inputFrameCount Number of input frames.
 /// @returns True if successful, false otherwise.
 bool FFmpegAudioFileWriter::resampleAndPushToFifo(void *inputData, int inputFrameCount) {
-  int result = 0;
   int64_t outputLength = av_rescale_rnd(
       inputFrameCount, encoderCtx_->sample_rate, static_cast<int>(streamSampleRate_), AV_ROUND_UP);
 
-  result = prepareFrameForEncoding(outputLength);
-
-  if (result < 0) {
-    invokeOnErrorCallback("Failed to prepare frame for resampling: " + parseErrorCode(result));
-    return false;
-  }
-
   const uint8_t *inputs[1] = {reinterpret_cast<const uint8_t *>(inputData)};
 
+  assert(outputLength <= resamplerFrame_->nb_samples);
+
   int convertedSamples = swr_convert(
-      resampleCtx_.get(), frame_->data, static_cast<int>(outputLength), inputs, inputFrameCount);
+      resampleCtx_.get(),
+      resamplerFrame_->data,
+      static_cast<int>(outputLength),
+      inputs,
+      inputFrameCount);
 
   if (convertedSamples < 0) {
     invokeOnErrorCallback("Failed to convert audio samples: " + parseErrorCode(convertedSamples));
-    av_frame_unref(frame_.get());
     return false;
   }
 
   int written = av_audio_fifo_write(
-      audioFifo_.get(), reinterpret_cast<void **>(frame_->data), convertedSamples);
+      audioFifo_.get(), reinterpret_cast<void **>(resamplerFrame_->data), convertedSamples);
 
   if (written < convertedSamples) {
     invokeOnErrorCallback("Failed to write all samples to FIFO");
-    av_frame_unref(frame_.get());
     return false;
   }
 
@@ -344,26 +358,25 @@ bool FFmpegAudioFileWriter::resampleAndPushToFifo(void *inputData, int inputFram
 /// @returns 0 on success, -1 or AV_ERROR code on failure
 int FFmpegAudioFileWriter::processFifo(bool flush) {
   int result = 0;
-  int frameSize = encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size : 512;
+  int frameSize = std::max(encoderCtx_->frame_size, fallbackFrameSize);
 
   while (av_audio_fifo_size(audioFifo_.get()) >= (flush ? 1 : frameSize)) {
     const int chunkSize = std::min(av_audio_fifo_size(audioFifo_.get()), frameSize);
 
-    if (prepareFrameForEncoding(chunkSize) < 0) {
-      invokeOnErrorCallback("Failed to prepare frame for encoding");
-      return -1;
-    }
+    assert(chunkSize <= writingFrame_->nb_samples);
 
-    if (av_audio_fifo_read(audioFifo_.get(), reinterpret_cast<void **>(frame_->data), chunkSize) !=
+    if (av_audio_fifo_read(
+            audioFifo_.get(), reinterpret_cast<void **>(writingFrame_->data), chunkSize) !=
         chunkSize) {
       invokeOnErrorCallback("Failed to read data from FIFO");
       return -1;
     }
 
-    frame_->pts = nextPts_;
+    writingFrame_->nb_samples = chunkSize;
+    writingFrame_->pts = nextPts_;
     nextPts_ += chunkSize;
 
-    result = avcodec_send_frame(encoderCtx_.get(), frame_.get());
+    result = avcodec_send_frame(encoderCtx_.get(), writingFrame_.get());
 
     if (result < 0) {
       invokeOnErrorCallback("Failed to send frame to encoder: " + parseErrorCode(result));
@@ -418,51 +431,6 @@ int FFmpegAudioFileWriter::writeEncodedPackets() {
   }
 }
 
-/// @brief Prepares the frame for next encoding phase,
-/// if frame is same size as previously used one (99.9% cases) try to reuse it.
-/// Otherwise resize the frame and in the worst case allocate new frame to use.
-/// @param samplesToRead Number of samples to prepare the frame for.
-/// @returns 0 on success, AV_ERROR code on failure
-int FFmpegAudioFileWriter::prepareFrameForEncoding(int64_t samplesToRead) {
-  int result = 0;
-
-  if (frame_->data[0] && frame_->nb_samples == samplesToRead &&
-      av_frame_is_writable(frame_.get())) {
-    return 0;
-  }
-
-  frame_->nb_samples = static_cast<int>(samplesToRead);
-  frame_->format = encoderCtx_->sample_fmt;
-  frame_->sample_rate = encoderCtx_->sample_rate;
-
-  if (av_channel_layout_compare(&frame_->ch_layout, &encoderCtx_->ch_layout) != 0) {
-    av_channel_layout_uninit(&frame_->ch_layout);
-
-    result = av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
-
-    if (result < 0) {
-      invokeOnErrorCallback("Failed to copy channel layout: " + parseErrorCode(result));
-      return result;
-    }
-  }
-
-  result = av_frame_make_writable(frame_.get());
-
-  if (result < 0) {
-    av_frame_unref(frame_.get());
-
-    frame_->nb_samples = static_cast<int>(samplesToRead);
-    ;
-    frame_->format = encoderCtx_->sample_fmt;
-    frame_->sample_rate = encoderCtx_->sample_rate;
-    av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
-
-    result = av_frame_get_buffer(frame_.get(), 0);
-  }
-
-  return result;
-}
-
 /// @brief Closes the currently opened audio file, flushing any remaining data and finalizing the file.
 /// Method checks the file size and duration for convenience.
 /// @returns CloseFileResult indicating success or error details

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h

@@ -40,8 +40,10 @@ class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
   av_unique_ptr<SwrContext> resampleCtx_{nullptr};
   av_unique_ptr<AVAudioFifo> audioFifo_{nullptr};
   av_unique_ptr<AVPacket> packet_{nullptr};
-  av_unique_ptr<AVFrame> frame_{nullptr};
+  av_unique_ptr<AVFrame> resamplerFrame_{nullptr};
+  av_unique_ptr<AVFrame> writingFrame_{nullptr};
   AVStream* stream_{nullptr};
+
   unsigned int nextPts_{0};
 
   std::chrono::steady_clock::time_point lastFlushTime_ = std::chrono::steady_clock::now();
@@ -59,7 +61,6 @@ class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
   bool resampleAndPushToFifo(void *data, int numFrames);
   int processFifo(bool flush);
   int writeEncodedPackets();
-  int prepareFrameForEncoding(int64_t samplesToRead);
 
   // Finalization helper methods
   CloseFileResult finalizeOutput();

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/BaseAudioContextHostObject.cpp

@@ -11,6 +11,7 @@
 #include <audioapi/HostObjects/effects/IIRFilterNodeHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
+#include <audioapi/HostObjects/effects/WaveShaperNodeHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h>
@@ -57,7 +58,8 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConvolver),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser));
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWaveShaper));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
@@ -308,4 +310,10 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
   }
   return jsiObject;
 }
+
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWaveShaper) {
+  auto waveShaper = context_->createWaveShaper();
+  auto waveShaperHostObject = std::make_shared<WaveShaperNodeHostObject>(waveShaper);
+  return jsi::Object::createFromHostObject(runtime, waveShaperHostObject);
+}
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h

@@ -43,6 +43,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createPeriodicWave);
   JSI_HOST_FUNCTION_DECL(createAnalyser);
   JSI_HOST_FUNCTION_DECL(createConvolver);
+  JSI_HOST_FUNCTION_DECL(createWaveShaper);
   JSI_HOST_FUNCTION_DECL(createDelay);
 
   std::shared_ptr<BaseAudioContext> context_;

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/HostObjects/effects/WaveShaperNodeHostObject.cpp

@@ -0,0 +1,72 @@
+#include <audioapi/HostObjects/effects/WaveShaperNodeHostObject.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
+
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+WaveShaperNodeHostObject::WaveShaperNodeHostObject(const std::shared_ptr<WaveShaperNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(WaveShaperNodeHostObject, oversample),
+      JSI_EXPORT_PROPERTY_GETTER(WaveShaperNodeHostObject, curve));
+
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(WaveShaperNodeHostObject, oversample));
+  addFunctions(JSI_EXPORT_FUNCTION(WaveShaperNodeHostObject, setCurve));
+}
+
+JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, oversample) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  return jsi::String::createFromUtf8(runtime, waveShaperNode->getOversample());
+}
+
+JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, curve) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  auto curve = waveShaperNode->getCurve();
+
+  if (curve == nullptr) {
+    return jsi::Value::null();
+  }
+
+  // copy AudioArray holding curve data to avoid subsequent modifications
+  auto audioArray = std::make_shared<AudioArray>(*curve);
+  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(audioArray);
+  auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer);
+
+  auto float32ArrayCtor = runtime.global().getPropertyAsFunction(runtime, "Float32Array");
+  auto float32Array = float32ArrayCtor.callAsConstructor(runtime, arrayBuffer).getObject(runtime);
+  float32Array.setExternalMemoryPressure(runtime, audioArrayBuffer->size());
+
+  return float32Array;
+}
+
+JSI_PROPERTY_SETTER_IMPL(WaveShaperNodeHostObject, oversample) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  std::string type = value.asString(runtime).utf8(runtime);
+  waveShaperNode->setOversample(type);
+}
+
+JSI_HOST_FUNCTION_IMPL(WaveShaperNodeHostObject, setCurve) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+
+  if (args[0].isNull()) {
+    waveShaperNode->setCurve(std::shared_ptr<AudioArray>(nullptr));
+    return jsi::Value::undefined();
+  }
+
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+
+  auto curve = std::make_shared<AudioArray>(
+      reinterpret_cast<float *>(arrayBuffer.data(runtime)),
+      static_cast<size_t>(arrayBuffer.size(runtime) / sizeof(float)));
+
+  waveShaperNode->setCurve(curve);
+  thisValue.asObject(runtime).setExternalMemoryPressure(runtime, arrayBuffer.size(runtime));
+
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class WaveShaperNode;
+
+class WaveShaperNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit WaveShaperNodeHostObject(const std::shared_ptr<WaveShaperNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(oversample);
+  JSI_PROPERTY_GETTER_DECL(curve);
+
+  JSI_PROPERTY_SETTER_DECL(oversample);
+  JSI_HOST_FUNCTION_DECL(setCurve);
+};
+} // namespace audioapi

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