react-native-audio-api 0.4.16 → 0.4.18

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

@@ -36,6 +36,7 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
 
   ma_uint64 framesDecoded;
   ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
+
   if (framesDecoded == 0) {
     __android_log_print(
         ANDROID_LOG_ERROR,

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

@@ -73,47 +73,50 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
   }
 
   JSI_HOST_FUNCTION(getFloatFrequencyData) {
-      auto destination = args[0].getObject(runtime).asArray(runtime);
-      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
-      auto data = new float[length];
+    auto destination = args[0].getObject(runtime).asArray(runtime);
+    auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+    auto data = new float[length];
 
-      auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-        analyserNode->getFloatFrequencyData(data, length);
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+      analyserNode->getFloatFrequencyData(data, length);
 
-      for (int i = 0; i < length; i++) {
-          destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
-      }
+    for (int i = 0; i < length; i++) {
+        destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
+    }
 
+    delete[] data;
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(getByteFrequencyData) {
-      auto destination = args[0].getObject(runtime).asArray(runtime);
-      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
-      auto data = new uint8_t[length];
+    auto destination = args[0].getObject(runtime).asArray(runtime);
+    auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+    auto data = new uint8_t[length];
 
-        auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-        analyserNode->getByteFrequencyData(data, length);
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getByteFrequencyData(data, length);
 
-        for (int i = 0; i < length; i++) {
-            destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
-        }
+    for (int i = 0; i < length; i++) {
+        destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
+    }
 
+    delete[] data;
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(getFloatTimeDomainData) {
-      auto destination = args[0].getObject(runtime).asArray(runtime);
-      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
-      auto data = new float[length];
+    auto destination = args[0].getObject(runtime).asArray(runtime);
+    auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+    auto data = new float[length];
 
-      auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-      analyserNode->getFloatTimeDomainData(data, length);
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getFloatTimeDomainData(data, length);
 
     for (int i = 0; i < length; i++) {
         destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
     }
 
+    delete[] data;
     return jsi::Value::undefined();
   }
 
@@ -129,6 +132,7 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
           destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
       }
 
+      delete[] data;
       return jsi::Value::undefined();
   }
 

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

@@ -74,6 +74,7 @@ class AudioBufferHostObject : public JsiHostObject {
       destination.setValueAtIndex(runtime, i, jsi::Value(destinationData[i]));
     }
 
+    delete[] destinationData;
     return jsi::Value::undefined();
   }
 
@@ -94,6 +95,7 @@ class AudioBufferHostObject : public JsiHostObject {
     audioBuffer_->copyToChannel(
         sourceData, sourceLength, channelNumber, startInChannel);
 
+    delete[] sourceData;
     return jsi::Value::undefined();
   }
 };

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

@@ -2,6 +2,7 @@
 
 #include <audioapi/jsi/JsiHostObject.h>
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/utils/AudioArray.h>
 
 #include <jsi/jsi.h>
 #include <memory>
@@ -81,14 +82,18 @@ class AudioParamHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION(setValueCurveAtTime) {
     auto values = args[0].getObject(runtime).asArray(runtime);
     auto length = static_cast<size_t>(values.length(runtime));
-    auto valuesData = new float[length];
+
+    auto valuesArray = std::make_shared<AudioArray>(length);
+    auto rawData = valuesArray->getData();
+
     for (size_t i = 0; i < values.length(runtime); i++) {
-      valuesData[i] =
-          static_cast<float>(values.getValueAtIndex(runtime, i).getNumber());
+      rawData[i] = static_cast<float>(values.getValueAtIndex(runtime, i).getNumber());
     }
+
     double startTime = args[1].getNumber();
     double duration = args[2].getNumber();
-    param_->setValueCurveAtTime(valuesData, length, startTime, duration);
+    param_->setValueCurveAtTime(valuesArray, length, startTime, duration);
+
     return jsi::Value::undefined();
   }
 

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

@@ -123,6 +123,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
       realData[i] =
           static_cast<float>(real.getValueAtIndex(runtime, i).getNumber());
     }
+
     for (size_t i = 0; i < imag.length(runtime); i++) {
       realData[i] =
           static_cast<float>(imag.getValueAtIndex(runtime, i).getNumber());
@@ -132,6 +133,9 @@ class BaseAudioContextHostObject : public JsiHostObject {
         realData, imagData, disableNormalization, length);
     auto periodicWaveHostObject =
         std::make_shared<PeriodicWaveHostObject>(periodicWave);
+
+    delete[] realData;
+    delete[] imagData;
     return jsi::Object::createFromHostObject(runtime, periodicWaveHostObject);
   }
 

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

@@ -12,7 +12,9 @@ AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
 }
 
 AudioNode::~AudioNode() {
-  isInitialized_ = false;
+  if (isInitialized_) {
+    cleanup();
+  }
 }
 
 int AudioNode::getNumberOfInputs() const {
@@ -41,8 +43,8 @@ void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
 }
 
 void AudioNode::disconnect() {
-  for (auto &outputNode : outputNodes_) {
-    disconnect(outputNode);
+  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
+    disconnect(*it);
   }
 }
 
@@ -56,18 +58,26 @@ bool AudioNode::isEnabled() const {
 }
 
 void AudioNode::enable() {
+  if (isEnabled()) {
+    return;
+  }
+
   isEnabled_ = true;
 
-  for (auto &outputNode : outputNodes_) {
-    outputNode->onInputEnabled();
+  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
+    it->get()->onInputEnabled();
   }
 }
 
 void AudioNode::disable() {
+  if (!isEnabled()) {
+    return;
+  }
+
   isEnabled_ = false;
 
-  for (auto &outputNode : outputNodes_) {
-    outputNode->onInputDisabled();
+  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
+    it->get()->onInputDisabled();
   }
 }
 
@@ -96,7 +106,7 @@ std::string AudioNode::toString(ChannelInterpretation interpretation) {
 }
 
 std::shared_ptr<AudioBus> AudioNode::processAudio(
-    std::shared_ptr<AudioBus> outputBus,
+    const std::shared_ptr<AudioBus> &outputBus,
     int framesToProcess,
     bool checkIsAlreadyProcessed) {
   if (!isInitialized_) {
@@ -148,7 +158,9 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
   processingBus->zero();
 
   int maxNumberOfChannels = 0;
-  for (auto inputNode : inputNodes_) {
+
+  for (auto it = inputNodes_.begin(); it != inputNodes_.end(); ++it) {
+    auto inputNode = *it;
     assert(inputNode != nullptr);
 
     if (!inputNode->isEnabled()) {
@@ -169,7 +181,7 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
 }
 
 std::shared_ptr<AudioBus> AudioNode::applyChannelCountMode(
-    std::shared_ptr<AudioBus> processingBus) {
+    std::shared_ptr<AudioBus> &processingBus) {
   // If the channelCountMode is EXPLICIT, the node should output the number of
   // channels specified by the channelCount.
   if (channelCountMode_ == ChannelCountMode::EXPLICIT) {
@@ -189,21 +201,35 @@ std::shared_ptr<AudioBus> AudioNode::applyChannelCountMode(
 void AudioNode::mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus) {
   assert(processingBus != nullptr);
 
-  for (const auto &inputBus : inputBuses_) {
-    processingBus->sum(inputBus.get(), channelInterpretation_);
+  for (auto it = inputBuses_.begin(); it != inputBuses_.end(); ++it) {
+    processingBus->sum(it->get(), channelInterpretation_);
   }
 
   inputBuses_.clear();
 }
 
 void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
-  outputNodes_.insert(node);
-  node->onInputConnected(this);
+  auto position = std::find_if(
+      outputNodes_.begin(), outputNodes_.end(), [&node](auto const &nodeSP) {
+        return nodeSP.get() == node.get();
+      });
+
+  if (position == outputNodes_.end()) {
+    outputNodes_.emplace_back(node);
+    node->onInputConnected(this);
+  }
 }
 
 void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
-  outputNodes_.erase(node);
-  node->onInputDisconnected(this);
+  auto position = std::find_if(
+      outputNodes_.begin(), outputNodes_.end(), [&node](auto const &nodeSP) {
+        return nodeSP.get() == node.get();
+      });
+
+  if (position != outputNodes_.end()) {
+    node->onInputDisconnected(this);
+    outputNodes_.erase(position);
+  }
 }
 
 void AudioNode::onInputEnabled() {
@@ -227,7 +253,7 @@ void AudioNode::onInputConnected(AudioNode *node) {
     return;
   }
 
-  inputNodes_.insert(node);
+  inputNodes_.push_back(node);
 
   if (node->isEnabled()) {
     onInputEnabled();
@@ -239,26 +265,27 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
     return;
   }
 
-  inputNodes_.erase(node);
+  if (node->isEnabled()) {
+    onInputDisabled();
+  }
+
+  auto position = std::find(inputNodes_.begin(), inputNodes_.end(), node);
 
-  if (isEnabled()) {
-    node->onInputDisabled();
+  if (position != inputNodes_.end()) {
+    inputNodes_.erase(position);
+  } else {
+    assert(false);
   }
 }
 
 void AudioNode::cleanup() {
   isInitialized_ = false;
 
-  for (const auto &outputNode : outputNodes_) {
-    outputNode->onInputDisconnected(this);
-  }
-
-  for (const auto &inputNode : inputNodes_) {
-    inputNode->disconnectNode(shared_from_this());
+  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
+    it->get()->onInputDisconnected(this);
   }
 
   outputNodes_.clear();
-  inputNodes_.clear();
 }
 
 } // namespace audioapi

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

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-#include <unordered_set>
 #include <cstddef>
 #include <vector>
 #include <cassert>
@@ -48,8 +47,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   ChannelInterpretation channelInterpretation_ =
           ChannelInterpretation::SPEAKERS;
 
-  std::unordered_set<AudioNode *> inputNodes_ = {};
-  std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
+  std::vector<AudioNode *> inputNodes_ = {};
+  std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
 
   int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;
@@ -65,13 +64,13 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
 
-  virtual std::shared_ptr<AudioBus> processAudio(std::shared_ptr<AudioBus> outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
+  virtual std::shared_ptr<AudioBus> processAudio(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   virtual void processNode(const std::shared_ptr<AudioBus>&, int) = 0;
 
   bool isAlreadyProcessed();
-  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
-  std::shared_ptr<AudioBus> applyChannelCountMode(std::shared_ptr<AudioBus> processingBus);
-  void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
+  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
+  std::shared_ptr<AudioBus> applyChannelCountMode(std::shared_ptr<AudioBus> &processingBus);
+  void mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus);
 
   void connectNode(const std::shared_ptr<AudioNode> &node);
   void disconnectNode(const std::shared_ptr<AudioNode> &node);

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

@@ -1,5 +1,6 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/utils/AudioArray.h>
 #include <audioapi/dsp/AudioUtils.h>
 
 namespace audioapi {
@@ -179,7 +180,7 @@ void AudioParam::setTargetAtTime(
 }
 
 void AudioParam::setValueCurveAtTime(
-    const float *values,
+    const std::shared_ptr<AudioArray> &values,
     size_t length,
     double startTime,
     double duration) {
@@ -206,7 +207,7 @@ void AudioParam::setValueCurveAtTime(
           (time - startTime) * static_cast<double>(length - 1) /
               (endTime - startTime));
 
-      return AudioUtils::linearInterpolate(values, k, k + 1, factor);
+      return AudioUtils::linearInterpolate(values->getData(), k, k + 1, factor);
     }
 
     return endValue;
@@ -216,7 +217,7 @@ void AudioParam::setValueCurveAtTime(
       startTime,
       startTime + duration,
       getQueueEndValue(),
-      values[length - 1],
+      values->operator[](values->getSize() - 1),
       calculateValue,
       ParamChangeEventType::SET_VALUE_CURVE);
   updateQueue(event);

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

@@ -10,6 +10,8 @@
 
 namespace audioapi {
 
+class AudioArray;
+
 class AudioParam {
  public:
   explicit AudioParam(float defaultValue, float minValue, float maxValue);
@@ -27,7 +29,7 @@ class AudioParam {
   void exponentialRampToValueAtTime(float value, double endTime);
   void setTargetAtTime(float target, double startTime, double timeConstant);
   void setValueCurveAtTime(
-      const float *values,
+      const std::shared_ptr<AudioArray> &values,
       size_t length,
       double startTime,
       double duration);

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

@@ -67,6 +67,15 @@ PeriodicWave::PeriodicWave(
   createBandLimitedTables(real, imaginary, length);
 }
 
+PeriodicWave::~PeriodicWave() {
+  for (int i = 0; i < numberOfRanges_; i++) {
+    delete[] bandLimitedTables_[i];
+  }
+
+  delete[] bandLimitedTables_;
+  bandLimitedTables_ = nullptr;
+}
+
 int PeriodicWave::getPeriodicWaveSize() const {
   if (sampleRate_ <= 24000) {
     return 2048;
@@ -185,6 +194,9 @@ void PeriodicWave::generateBasicWaveForm(OscillatorType type) {
   }
 
   createBandLimitedTables(real, imaginary, halfSize);
+
+  delete[] real;
+  delete[] imaginary;
 }
 
 void PeriodicWave::createBandLimitedTables(
@@ -368,4 +380,5 @@ float PeriodicWave::doInterpolation(
   return (1 - waveTableInterpolationFactor) * higherWaveDataSample +
       waveTableInterpolationFactor * lowerWaveDataSample;
 }
+
 } // namespace audioapi

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

@@ -47,6 +47,7 @@ class PeriodicWave {
       float *imaginary,
       int length,
       bool disableNormalization);
+  ~PeriodicWave();
 
   [[nodiscard]] int getPeriodicWaveSize() const;
   [[nodiscard]] float getScale() const;

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

@@ -42,7 +42,7 @@ void StretcherNode::processNode(
 }
 
 std::shared_ptr<AudioBus> StretcherNode::processAudio(
-    std::shared_ptr<AudioBus> outputBus,
+    const std::shared_ptr<AudioBus> &outputBus,
     int framesToProcess,
     bool checkIsAlreadyProcessed) {
   if (!isInitialized_) {

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

@@ -20,7 +20,7 @@ class StretcherNode : public AudioNode {
 
  protected:
     void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-    std::shared_ptr<AudioBus> processAudio(std::shared_ptr<AudioBus> outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
+    std::shared_ptr<AudioBus> processAudio(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
 
  private:
     // k-rate params

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

@@ -122,38 +122,38 @@ std::mutex &AudioBufferSourceNode::getBufferLock() {
 void AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  if (!Locker::tryLock(getBufferLock())) {
-    processingBus->zero();
-    return;
-  }
+  if (auto locker = Locker::tryLock(getBufferLock())) {
+    // No audio data to fill, zero the output and return.
+    if (!buffer_) {
+      processingBus->zero();
+      return;
+    }
 
-  // No audio data to fill, zero the output and return.
-  if (!buffer_) {
-    processingBus->zero();
-    return;
-  }
+    size_t startOffset = 0;
+    size_t offsetLength = 0;
 
-  size_t startOffset = 0;
-  size_t offsetLength = 0;
+    updatePlaybackInfo(
+        processingBus, framesToProcess, startOffset, offsetLength);
+    float playbackRate = getPlaybackRateValue(startOffset);
 
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
-  float playbackRate = getPlaybackRateValue(startOffset);
+    assert(alignedBus_ != nullptr);
+    assert(alignedBus_->getSize() > 0);
 
-  assert(alignedBus_ != nullptr);
-  assert(alignedBus_->getSize() > 0);
+    if (playbackRate == 0.0f || !isPlaying()) {
+      processingBus->zero();
+      return;
+    } else if (std::fabs(playbackRate) == 1.0) {
+      processWithoutInterpolation(
+          processingBus, startOffset, offsetLength, playbackRate);
+    } else {
+      processWithInterpolation(
+          processingBus, startOffset, offsetLength, playbackRate);
+    }
 
-  if (playbackRate == 0.0f || !isPlaying()) {
-    processingBus->zero();
-    return;
-  } else if (std::fabs(playbackRate) == 1.0) {
-    processWithoutInterpolation(
-        processingBus, startOffset, offsetLength, playbackRate);
+    handleStopScheduled();
   } else {
-    processWithInterpolation(
-        processingBus, startOffset, offsetLength, playbackRate);
+    processingBus->zero();
   }
-
-  handleStopScheduled();
 }
 
 /**

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

@@ -63,7 +63,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   size_t stopFrame = stopTime_ == -1.0
       ? std::numeric_limits<size_t>::max()
       : std::max(
-            AudioUtils::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
+            AudioUtils::timeToSampleFrame(stopTime_, sampleRate), lastFrame);
 
   if (isUnscheduled() || isFinished()) {
     startOffset = 0;
@@ -85,7 +85,10 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     startOffset = std::max(startFrame, firstFrame) - firstFrame > 0
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
-    nonSilentFramesToProcess = std::min(lastFrame, stopFrame) - startFrame;
+    nonSilentFramesToProcess = std::max(std::min(lastFrame, stopFrame), startFrame) - startFrame;
+
+    assert(startOffset < framesToProcess);
+    assert(nonSilentFramesToProcess <= framesToProcess);
     processingBus->zero(0, startOffset);
     return;
   }
@@ -97,6 +100,9 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   if (stopFrame < lastFrame && stopFrame >= firstFrame) {
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
+
+    assert(startOffset < framesToProcess);
+    assert(nonSilentFramesToProcess <= framesToProcess);
     processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
     return;
   }

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

@@ -12,6 +12,7 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
+
   isInitialized_ = true;
 }
 

package/common/cpp/audioapi/core/utils/AudioNodeManager.cpp

@@ -5,7 +5,7 @@
 namespace audioapi {
 
 AudioNodeManager::~AudioNodeManager() {
-  audioNodesToConnect_.clear();
+  cleanup();
 }
 
 void AudioNodeManager::addPendingConnection(
@@ -18,12 +18,10 @@ void AudioNodeManager::addPendingConnection(
 }
 
 void AudioNodeManager::preProcessGraph() {
-  if (!Locker::tryLock(getGraphLock())) {
-    return;
+  if (auto locker = Locker::tryLock(getGraphLock())) {
+    settlePendingConnections();
+    prepareNodesForDestruction();
   }
-
-  settlePendingConnections();
-  prepareNodesForDestruction();
 }
 
 std::mutex &AudioNodeManager::getGraphLock() {
@@ -32,19 +30,18 @@ std::mutex &AudioNodeManager::getGraphLock() {
 
 void AudioNodeManager::addNode(const std::shared_ptr<AudioNode> &node) {
   Locker lock(getGraphLock());
-
-  nodes_.insert(node);
+  nodes_.emplace_back(node);
 }
 
 void AudioNodeManager::settlePendingConnections() {
-  for (auto &connection : audioNodesToConnect_) {
-    std::shared_ptr<AudioNode> from = std::get<0>(connection);
-    std::shared_ptr<AudioNode> to = std::get<1>(connection);
-    ConnectionType type = std::get<2>(connection);
+  for (auto it = audioNodesToConnect_.begin(); it != audioNodesToConnect_.end();
+       ++it) {
+    std::shared_ptr<AudioNode> from = std::get<0>(*it);
+    std::shared_ptr<AudioNode> to = std::get<1>(*it);
+    ConnectionType type = std::get<2>(*it);
 
-    if (!to || !from) {
-      continue;
-    }
+    assert(from != nullptr);
+    assert(to != nullptr);
 
     if (type == ConnectionType::CONNECT) {
       from->connectNode(to);
@@ -57,8 +54,11 @@ void AudioNodeManager::settlePendingConnections() {
 }
 
 void AudioNodeManager::prepareNodesForDestruction() {
-  for (auto it = nodes_.begin(); it != nodes_.end();) {
+  auto it = nodes_.begin();
+
+  while (it != nodes_.end()) {
     if (it->use_count() == 1) {
+      assert(it->get()->inputNodes_.size() == 0);
       it->get()->cleanup();
       it = nodes_.erase(it);
     } else {
@@ -70,11 +70,12 @@ void AudioNodeManager::prepareNodesForDestruction() {
 void AudioNodeManager::cleanup() {
   Locker lock(getGraphLock());
 
-  for (auto &node : nodes_) {
-    node->cleanup();
+  for (auto it = nodes_.begin(); it != nodes_.end(); ++it) {
+    it->get()->cleanup();
   }
 
   nodes_.clear();
+  audioNodesToConnect_.clear();
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioNodeManager.h

@@ -4,7 +4,6 @@
 #include <mutex>
 #include <tuple>
 #include <vector>
-#include <unordered_set>
 
 namespace audioapi {
 
@@ -30,10 +29,11 @@ class AudioNodeManager {
   void cleanup();
 
  private:
+  friend class AudioNode;
   std::mutex graphLock_;
 
   // all nodes created in the context
-  std::unordered_set<std::shared_ptr<AudioNode>> nodes_;
+  std::vector<std::shared_ptr<AudioNode>> nodes_;
 
   // connections to be settled
   std::vector<std::tuple<

package/ios/audioapi/ios/core/AudioPlayer.h

@@ -15,6 +15,8 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 @property (nonatomic, copy) RenderAudioBlock renderAudio;
 @property (nonatomic, assign) float sampleRate;
 @property (nonatomic, assign) bool isRunning;
+@property (nonatomic, strong) AVAudioSourceNodeRenderBlock renderBlock;
+@property (nonatomic, assign) bool isAudioSessionActive;
 
 - (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio;
 
@@ -34,10 +36,6 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 - (void)setupAndInitAudioSession;
 
-- (void)setupAndInitNotificationHandlers;
-
 - (void)connectAudioEngine;
 
-- (void)handleEngineConfigurationChange:(NSNotification *)notification;
-
 @end

package/ios/audioapi/ios/core/AudioPlayer.m

@@ -9,26 +9,25 @@
     self.audioEngine = [[AVAudioEngine alloc] init];
     self.audioEngine.mainMixerNode.outputVolume = 1;
     self.isRunning = true;
+    self.isAudioSessionActive = false;
 
     [self setupAndInitAudioSession];
-    [self setupAndInitNotificationHandlers];
 
     self.sampleRate = [self.audioSession sampleRate];
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:2];
-
     __weak typeof(self) weakSelf = self;
-    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
-                                                renderBlock:^OSStatus(
-                                                    BOOL *isSilence,
-                                                    const AudioTimeStamp *timestamp,
-                                                    AVAudioFrameCount frameCount,
-                                                    AudioBufferList *outputData) {
-                                                  return [weakSelf renderCallbackWithIsSilence:isSilence
-                                                                                     timestamp:timestamp
-                                                                                    frameCount:frameCount
-                                                                                    outputData:outputData];
-                                                }];
+    self.renderBlock = ^OSStatus(
+        BOOL *isSilence, const AudioTimeStamp *timestamp, AVAudioFrameCount frameCount, AudioBufferList *outputData) {
+      if (outputData->mNumberBuffers != 2) {
+        return kAudioServicesBadPropertySizeError;
+      }
+
+      weakSelf.renderAudio(outputData, frameCount);
+      return kAudioServicesNoError;
+    };
+
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:2];
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
   }
 
   return self;
@@ -41,26 +40,26 @@
     self.audioEngine = [[AVAudioEngine alloc] init];
     self.audioEngine.mainMixerNode.outputVolume = 1;
     self.isRunning = true;
+    self.isAudioSessionActive = false;
 
     [self setupAndInitAudioSession];
-    [self setupAndInitNotificationHandlers];
 
     self.sampleRate = sampleRate;
 
     _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:2];
 
     __weak typeof(self) weakSelf = self;
-    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
-                                                renderBlock:^OSStatus(
-                                                    BOOL *isSilence,
-                                                    const AudioTimeStamp *timestamp,
-                                                    AVAudioFrameCount frameCount,
-                                                    AudioBufferList *outputData) {
-                                                  return [weakSelf renderCallbackWithIsSilence:isSilence
-                                                                                     timestamp:timestamp
-                                                                                    frameCount:frameCount
-                                                                                    outputData:outputData];
-                                                }];
+    self.renderBlock = ^OSStatus(
+        BOOL *isSilence, const AudioTimeStamp *timestamp, AVAudioFrameCount frameCount, AudioBufferList *outputData) {
+      if (outputData->mNumberBuffers != 2) {
+        return kAudioServicesBadPropertySizeError;
+      }
+
+      weakSelf.renderAudio(outputData, frameCount);
+      return kAudioServicesNoError;
+    };
+
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
   }
 
   return self;
@@ -90,7 +89,9 @@
   [self.audioSession setActive:false error:&error];
 
   if (error != nil) {
-    @throw error;
+    NSLog(@"Error while de-activating audio session: %@", [error debugDescription]);
+  } else {
+    self.isAudioSessionActive = false;
   }
 }
 
@@ -114,20 +115,6 @@
   self.renderAudio = nil;
 }
 
-- (OSStatus)renderCallbackWithIsSilence:(BOOL *)isSilence
-                              timestamp:(const AudioTimeStamp *)timestamp
-                             frameCount:(AVAudioFrameCount)frameCount
-                             outputData:(AudioBufferList *)outputData
-{
-  if (outputData->mNumberBuffers < 2) {
-    return noErr; // Ensure we have stereo output
-  }
-
-  self.renderAudio(outputData, frameCount);
-
-  return noErr;
-}
-
 - (void)setupAndInitAudioSession
 {
   NSError *error = nil;
@@ -136,33 +123,53 @@
     self.audioSession = [AVAudioSession sharedInstance];
   }
 
-  [self.audioSession setCategory:AVAudioSessionCategoryPlayback
-                            mode:AVAudioSessionModeDefault
-                         options:AVAudioSessionCategoryOptionDuckOthers | AVAudioSessionCategoryOptionAllowBluetooth |
-                         AVAudioSessionCategoryOptionAllowAirPlay
-                           error:&error];
+  AVAudioSessionCategory desiredCategory = AVAudioSessionCategoryPlayback;
+  AVAudioSessionMode desiredMode = AVAudioSessionModeDefault;
+  AVAudioSessionCategoryOptions desiredOptions = AVAudioSessionCategoryOptionAllowBluetooth | AVAudioSessionCategoryOptionAllowAirPlay;
 
-  if (error != nil) {
-    NSLog(@"Error while configuring audio session: %@", [error localizedDescription]);
+  if (self.audioSession.category != desiredCategory || self.audioSession.mode != desiredMode || self.audioSession.categoryOptions != desiredOptions) {
+    [self.audioSession setCategory:desiredCategory mode:desiredMode options:desiredOptions error:&error];
+
+    if (error != nil) {
+      NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
+    }
+  } else {
+    NSLog(@"AVAudioSession category mode and options are valid, skipping configuration");
   }
 
-  [self.audioSession setActive:true error:&error];
+  if (self.sampleRate) {
+    if (self.audioSession.preferredSampleRate != self.sampleRate) {
+      [self.audioSession setPreferredSampleRate:self.sampleRate error:&error];
 
-  if (error != nil) {
-    NSLog(@"Error while activating audio session: %@", [error localizedDescription]);
+      if (error != nil) {
+        NSLog(@"Error while setting preferred sample rate buffer duration: %@", [error debugDescription]);
+      }
+    } else {
+      NSLog(@"AVAudioSession preferred sample rate is valid, skipping configuration");
+    }
   }
-}
 
-- (void)setupAndInitNotificationHandlers
-{
-  if (!self.notificationCenter) {
-    self.notificationCenter = [NSNotificationCenter defaultCenter];
+  if (self.audioSession.preferredIOBufferDuration != 0.02) {
+    [self.audioSession setPreferredIOBufferDuration:0.02 error:&error];
+
+    if (error != nil) {
+      NSLog(@"Error while setting preferred IO buffer duration: %@", [error debugDescription]);
+    }
+  } else {
+    NSLog(@"AVAudioSession preferred IO buffer duration is valid, skipping configuration");
   }
 
-  [self.notificationCenter addObserver:self
-                              selector:@selector(handleEngineConfigurationChange:)
-                                  name:AVAudioEngineConfigurationChangeNotification
-                                object:nil];
+  if (!self.isAudioSessionActive) {
+    [self.audioSession setActive:true error:&error];
+
+    if (error != nil) {
+      NSLog(@"Error while activating audio session: %@", [error debugDescription]);
+    } else {
+      self.isAudioSessionActive = true;
+    }
+  } else {
+    NSLog(@"AVAudioSession was active, skipping unnecessary activation");
+  }
 }
 
 - (void)connectAudioEngine
@@ -183,13 +190,4 @@
   }
 }
 
-- (void)handleEngineConfigurationChange:(NSNotification *)notification
-{
-  if (!self.isRunning) {
-    return;
-  }
-
-  [self connectAudioEngine];
-}
-
 @end

package/ios/audioapi/ios/core/IOSAudioPlayer.mm

@@ -69,7 +69,7 @@ IOSAudioPlayer::~IOSAudioPlayer()
   [audioPlayer_ cleanup];
 
   if (audioBus_) {
-    audioBus_ = 0;
+    audioBus_ = nullptr;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.4.16",
+  "version": "0.4.18",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-custom-wasm": "./scripts/setup-custom-wasm.js"