Refactor/communication between audio and js threads

packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -55,7 +55,7 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
     }
   }
 
-  if (mStream_) {
+  if (mStream_ != nullptr) {
     mStream_->requestStop();
     mStream_->close();
     mStream_.reset();
@@ -68,7 +68,7 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
 /// Callable from the JS thread only.
 /// @returns Success status or Error status with message.
 Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
-  if (mStream_) {
+  if (mStream_ != nullptr) {
     return Result<NoneType, std::string>::Ok(None);
   }
 
@@ -404,7 +404,7 @@ bool AndroidAudioRecorder::isIdle() const {
 void AndroidAudioRecorder::cleanup() {
   state_.store(RecorderState::Idle, std::memory_order_release);
 
-  if (mStream_) {
+  if (mStream_ != nullptr) {
     mStream_->close();
     mStream_.reset();
   }

packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -15,7 +15,10 @@ AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio), sampleRate_(sampleRate), channelCount_(channelCount) {
+    : renderAudio_(renderAudio),
+      sampleRate_(sampleRate),
+      channelCount_(channelCount),
+      isRunning_(false) {
   isInitialized_ = openAudioStream();
 }
 
@@ -39,51 +42,60 @@ bool AudioPlayer::openAudioStream() {
     return false;
   }
 
-  mBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
   return true;
 }
 
 bool AudioPlayer::start() {
-  if (mStream_) {
-    auto result = mStream_->requestStart();
-    return result == oboe::Result::OK;
+  if (mStream_ != nullptr) {
+    auto result = mStream_->requestStart() == oboe::Result::OK;
+    isRunning_.store(result, std::memory_order_release);
+    return result;
   }
 
   return false;
 }
 
 void AudioPlayer::stop() {
-  if (mStream_) {
+  if (mStream_ != nullptr) {
+    isRunning_.store(false, std::memory_order_release);
     mStream_->requestStop();
   }
 }
 
 bool AudioPlayer::resume() {
-  if (mStream_) {
-    auto result = mStream_->requestStart();
-    return result == oboe::Result::OK;
+  if (isRunning()) {
+    return true;
+  }
+
+  if (mStream_ != nullptr) {
+    auto result = mStream_->requestStart() == oboe::Result::OK;
+    isRunning_.store(result, std::memory_order_release);
+    return result;
   }
 
   return false;
 }
 
 void AudioPlayer::suspend() {
-  if (mStream_) {
+  if (mStream_ != nullptr) {
+    isRunning_.store(false, std::memory_order_release);
     mStream_->requestPause();
   }
 }
 
 void AudioPlayer::cleanup() {
   isInitialized_ = false;
 
-  if (mStream_) {
+  if (mStream_ != nullptr) {
     mStream_->close();
     mStream_.reset();
   }
 }
 
 bool AudioPlayer::isRunning() const {
-  return mStream_ && mStream_->getState() == oboe::StreamState::Started;
+  return mStream_ && mStream_->getState() == oboe::StreamState::Started &&
+      isRunning_.load(std::memory_order_acquire);
 }
 
 DataCallbackResult
@@ -95,17 +107,19 @@ AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numF
   auto buffer = static_cast<float *>(audioData);
   int processedFrames = 0;
 
-  assert(buffer != nullptr);
-
   while (processedFrames < numFrames) {
     int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
-    renderAudio_(mBus_, framesToProcess);
 
-    // TODO: optimize this with SIMD?
+    if (isRunning_.load(std::memory_order_acquire)) {
+      renderAudio_(audioBus_, framesToProcess);
+    } else {
+      audioBus_->zero();
+    }
+
     for (int i = 0; i < framesToProcess; i++) {
-      for (int channel = 0; channel < channelCount_; channel += 1) {
+      for (int channel = 0; channel < channelCount_; channel++) {
         buffer[(processedFrames + i) * channelCount_ + channel] =
-            mBus_->getChannel(channel)->getData()[i];
+            audioBus_->getChannel(channel)->getData()[i];
       }
     }
 

packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <oboe/Oboe.h>
-#include <cassert>
 #include <functional>
 #include <memory>
 
@@ -45,10 +44,11 @@ class AudioPlayer : public AudioStreamDataCallback, AudioStreamErrorCallback {
  private:
   std::function<void(std::shared_ptr<AudioBus>, int)> renderAudio_;
   std::shared_ptr<AudioStream> mStream_;
-  std::shared_ptr<AudioBus> mBus_;
+  std::shared_ptr<AudioBus> audioBus_;
   bool isInitialized_ = false;
   float sampleRate_;
   int channelCount_;
+  std::atomic<bool> isRunning_;
 
   bool openAudioStream();
 

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp

@@ -1,12 +1,19 @@
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
-
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
+
 #include <memory>
 
 namespace audioapi {
 
-AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node) : node_(node) {
+AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node) :
+    node_(node),
+    numberOfInputs_(node->getNumberOfInputs()),
+    numberOfOutputs_(node->getNumberOfOutputs()),
+    channelCount_(node->getChannelCount()),
+    channelCountMode_(node->getChannelCountMode()),
+    channelInterpretation_(node->getChannelInterpretation()) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfInputs),
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfOutputs),
@@ -26,23 +33,23 @@ AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node)
 AudioNodeHostObject::~AudioNodeHostObject() = default;
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, numberOfInputs) {
-  return {node_->getNumberOfInputs()};
+  return numberOfInputs_;
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, numberOfOutputs) {
-  return {node_->getNumberOfOutputs()};
+  return numberOfOutputs_;
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCount) {
-  return {node_->getChannelCount()};
+  return channelCount_;
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCountMode) {
-  return jsi::String::createFromUtf8(runtime, node_->getChannelCountMode());
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::channelCountModeToString(channelCountMode_));
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
-  return jsi::String::createFromUtf8(runtime, node_->getChannelInterpretation());
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::channelInterpretationToString(channelInterpretation_));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/core/types/ChannelCountMode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
@@ -27,5 +29,11 @@ class AudioNodeHostObject : public JsiHostObject {
 
  protected:
   std::shared_ptr<AudioNode> node_;
+
+  int numberOfInputs_;
+  int numberOfOutputs_;
+  int channelCount_;
+  ChannelCountMode channelCountMode_;
+  ChannelInterpretation channelInterpretation_;
 };
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp

@@ -7,7 +7,7 @@
 namespace audioapi {
 
 AudioParamHostObject::AudioParamHostObject(const std::shared_ptr<AudioParam> &param)
-    : param_(param) {
+    : param_(param), defaultValue_(param->getDefaultValue()), minValue_(param->getMinValue()), maxValue_(param->getMaxValue()) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, defaultValue),
@@ -31,47 +31,58 @@ JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, value) {
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, defaultValue) {
-  return {param_->getDefaultValue()};
+  return {defaultValue_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, minValue) {
-  return {param_->getMinValue()};
+  return {minValue_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, maxValue) {
-  return {param_->getMaxValue()};
+  return {maxValue_};
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioParamHostObject, value) {
-  param_->setValue(static_cast<float>(value.getNumber()));
+  auto event = [param = param_, value = static_cast<float>(value.getNumber())](BaseAudioContext &) {
+    param->setValue(value);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueAtTime) {
-  auto value = static_cast<float>(args[0].getNumber());
-  double startTime = args[1].getNumber();
-  param_->setValueAtTime(value, startTime);
+  auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), startTime = args[1].getNumber()](BaseAudioContext &) {
+    param->setValueAtTime(value, startTime);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, linearRampToValueAtTime) {
-  auto value = static_cast<float>(args[0].getNumber());
-  double endTime = args[1].getNumber();
-  param_->linearRampToValueAtTime(value, endTime);
+  auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), endTime = args[1].getNumber()](BaseAudioContext &) {
+    param->linearRampToValueAtTime(value, endTime);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, exponentialRampToValueAtTime) {
-  auto value = static_cast<float>(args[0].getNumber());
-  double endTime = args[1].getNumber();
-  param_->exponentialRampToValueAtTime(value, endTime);
+  auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), endTime = args[1].getNumber()](BaseAudioContext &) {
+    param->exponentialRampToValueAtTime(value, endTime);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setTargetAtTime) {
-  auto target = static_cast<float>(args[0].getNumber());
-  double startTime = args[1].getNumber();
-  double timeConstant = args[2].getNumber();
-  param_->setTargetAtTime(target, startTime, timeConstant);
+  auto event = [param = param_, target = static_cast<float>(args[0].getNumber()), startTime = args[1].getNumber(), timeConstant = args[2].getNumber()](BaseAudioContext &) {
+    param->setTargetAtTime(target, startTime, timeConstant);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
@@ -80,24 +91,32 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueCurveAtTime) {
       args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto rawValues = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime));
-  auto values = std::make_unique<std::vector<float>>(rawValues, rawValues + length);
+  auto values = std::make_shared<std::vector<float>>(rawValues, rawValues + length);
 
-  double startTime = args[1].getNumber();
-  double duration = args[2].getNumber();
-  param_->setValueCurveAtTime(std::move(values), length, startTime, duration);
+  auto event = [param = param_, values, length, startTime = args[1].getNumber(), duration = args[2].getNumber()](BaseAudioContext &) {
+      param->setValueCurveAtTime(values, length, startTime, duration);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, cancelScheduledValues) {
-  double cancelTime = args[0].getNumber();
-  param_->cancelScheduledValues(cancelTime);
+  auto event = [param = param_, cancelTime = args[0].getNumber()](BaseAudioContext &) {
+    param->cancelScheduledValues(cancelTime);
+  };
+
+    param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, cancelAndHoldAtTime) {
-  double cancelTime = args[0].getNumber();
-  param_->cancelAndHoldAtTime(cancelTime);
-  return jsi::Value::undefined();
+    auto event = [param = param_, cancelTime = args[0].getNumber()](BaseAudioContext &) {
+        param->cancelAndHoldAtTime(cancelTime);
+    };
+
+    param_->scheduleAudioEvent(std::move(event));
+    return jsi::Value::undefined();
 }
 
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h

@@ -36,5 +36,8 @@ class AudioParamHostObject : public JsiHostObject {
   friend class AudioNodeHostObject;
 
   std::shared_ptr<AudioParam> param_;
+  float defaultValue_;
+  float minValue_;
+  float maxValue_;
 };
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp

@@ -1,6 +1,6 @@
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
-#include <audioapi/HostObjects/WorkletNodeHostObject.h>
-#include <audioapi/HostObjects/WorkletProcessingNodeHostObject.h>
+#include <audioapi/HostObjects/effects/WorkletNodeHostObject.h>
+#include <audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h>
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp

@@ -24,9 +24,7 @@ size_t DelayNodeHostObject::getSizeInBytes() const {
 }
 
 JSI_PROPERTY_GETTER_IMPL(DelayNodeHostObject, delayTime) {
-  auto delayNode = std::static_pointer_cast<DelayNode>(node_);
-  auto delayTimeParam = std::make_shared<AudioParamHostObject>(delayNode->getDelayTimeParam());
-  return jsi::Object::createFromHostObject(runtime, delayTimeParam);
+  return jsi::Object::createFromHostObject(runtime, delayTimeParam_);
 }
 
 } // namespace audioapi