react-native-audio-api 0.5.3 → 0.5.5

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, "AudioDecoder", "Failed to decode");
 

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -24,7 +24,7 @@ class AudioAPIModuleInstaller {
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioContext"),
         0,
-        [jsiRuntime, jsCallInvoker](
+        [jsCallInvoker](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -38,7 +38,7 @@ class AudioAPIModuleInstaller {
           }
 
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
-              audioContext, jsiRuntime, jsCallInvoker);
+              audioContext, &runtime, jsCallInvoker);
 
           return jsi::Object::createFromHostObject(
               runtime, audioContextHostObject);

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,9 @@ void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
 }
 
 void AudioNode::disconnect() {
-  for (auto &outputNode : outputNodes_) {
-    disconnect(outputNode);
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
+       ++it) {
+    disconnect(*it);
   }
 }
 
@@ -56,18 +59,28 @@ bool AudioNode::isEnabled() const {
 }
 
 void AudioNode::enable() {
+  if (isEnabled()) {
+    return;
+  }
+
   isEnabled_ = true;
 
-  for (auto &outputNode : outputNodes_) {
-    outputNode->onInputEnabled();
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
+       ++it) {
+    it->get()->onInputEnabled();
   }
 }
 
 void AudioNode::disable() {
+  if (!isEnabled()) {
+    return;
+  }
+
   isEnabled_ = false;
 
-  for (auto &outputNode : outputNodes_) {
-    outputNode->onInputDisabled();
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
+       ++it) {
+    it->get()->onInputDisabled();
   }
 }
 
@@ -96,7 +109,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 +161,9 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
   processingBus->zero();
 
   int maxNumberOfChannels = 0;
-  for (auto inputNode : inputNodes_) {
+  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
+       ++it) {
+    auto inputNode = *it;
     assert(inputNode != nullptr);
 
     if (!inputNode->isEnabled()) {
@@ -169,7 +184,7 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
 }
 
 std::shared_ptr<AudioBus> AudioNode::applyChannelCountMode(
-    std::shared_ptr<AudioBus> processingBus) {
+    const 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 +204,30 @@ 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(), end = inputBuses_.end(); it != 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 = outputNodes_.find(node);
+
+  if (position == outputNodes_.end()) {
+    outputNodes_.insert(node);
+    node->onInputConnected(this);
+  }
 }
 
 void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
-  outputNodes_.erase(node);
-  node->onInputDisconnected(this);
+  auto position = outputNodes_.find(node);
+
+  if (position != outputNodes_.end()) {
+    node->onInputDisconnected(this);
+    outputNodes_.erase(node);
+  }
 }
 
 void AudioNode::onInputEnabled() {
@@ -239,28 +263,26 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
     return;
   }
 
-  inputNodes_.erase(node);
+  if (node->isEnabled()) {
+    onInputDisabled();
+  }
 
-  if (isEnabled()) {
-    node->onInputDisabled();
+  auto position = inputNodes_.find(node);
+
+  if (position != inputNodes_.end()) {
+    inputNodes_.erase(position);
   }
 }
 
 void AudioNode::cleanup() {
   isInitialized_ = false;
 
-  for (const auto &outputNode : outputNodes_) {
-    outputNode->onInputDisconnected(this);
-  }
-
-  for (const auto &inputNode : inputNodes_) {
-    if (inputNode) {
-      inputNode->disconnectNode(shared_from_this());
-    }
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
+       ++it) {
+    it->get()->onInputDisconnected(this);
   }
 
   outputNodes_.clear();
-  inputNodes_.clear();
 }
 
 } // namespace audioapi

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

@@ -58,19 +58,17 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   std::size_t lastRenderedFrame_{SIZE_MAX};
 
  private:
-  friend class StretcherNode;
-
   std::vector<std::shared_ptr<AudioBus>> inputBuses_ = {};
 
   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);
+  std::shared_ptr<AudioBus> applyChannelCountMode(const std::shared_ptr<AudioBus> &processingBus);
   void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
 
   void connectNode(const std::shared_ptr<AudioNode> &node);

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

@@ -72,6 +72,7 @@ PeriodicWave::~PeriodicWave() {
     delete[] bandLimitedTables_[i];
   }
   delete[] bandLimitedTables_;
+  bandLimitedTables_ = nullptr;
 }
 
 int PeriodicWave::getPeriodicWaveSize() const {

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

@@ -11,17 +11,10 @@ AudioBuffer::AudioBuffer(
     size_t length,
     float sampleRate) {
   bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
-  stretch_ =
-      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
-  stretch_->presetDefault(numberOfChannels, sampleRate);
 }
 
 AudioBuffer::AudioBuffer(std::shared_ptr<AudioBus> bus) {
   bus_ = std::move(bus);
-
-  stretch_ =
-      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
-  stretch_->presetDefault(bus_->getNumberOfChannels(), bus_->getSampleRate());
 }
 
 size_t AudioBuffer::getLength() const {

package/common/cpp/audioapi/core/sources/AudioBuffer.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
-
 #include <algorithm>
 #include <memory>
 #include <string>
@@ -39,7 +37,6 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
   friend class AudioBufferSourceNode;
 
   std::shared_ptr<AudioBus> bus_;
-  std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
 };
 
 } // namespace audioapi

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

@@ -19,6 +19,7 @@ AudioBufferSourceNode::AudioBufferSourceNode(
       pitchCorrection_(pitchCorrection),
       vReadIndex_(0.0) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+  alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
 
   detuneParam_ = std::make_shared<AudioParam>(
       0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
@@ -28,9 +29,19 @@ AudioBufferSourceNode::AudioBufferSourceNode(
   playbackRateBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
 
+  stretch_ =
+      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
+
   isInitialized_ = true;
 }
 
+AudioBufferSourceNode::~AudioBufferSourceNode() {
+  Locker locker(getBufferLock());
+
+  buffer_.reset();
+  alignedBus_.reset();
+}
+
 bool AudioBufferSourceNode::getLoop() const {
   return loop_;
 }
@@ -74,11 +85,13 @@ void AudioBufferSourceNode::setBuffer(
 
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+    alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
     loopEnd_ = 0;
     return;
   }
 
   buffer_ = buffer;
+  alignedBus_ = std::make_shared<AudioBus>(*buffer_->bus_);
   channelCount_ = buffer_->getNumberOfChannels();
 
   audioBus_ = std::make_shared<AudioBus>(
@@ -87,6 +100,8 @@ void AudioBufferSourceNode::setBuffer(
       RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
 
   loopEnd_ = buffer_->getDuration();
+
+  stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
@@ -96,22 +111,30 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
     AudioScheduledSourceNode::stop(when + duration);
   }
 
-  if (!buffer_) {
+  if (!alignedBus_) {
     return;
   }
 
-  offset = std::min(offset, buffer_->getDuration());
+  offset = std::min(
+      offset,
+      static_cast<double>(alignedBus_->getSize()) /
+          alignedBus_->getSampleRate());
 
   if (loop_) {
     offset = std::min(offset, loopEnd_);
   }
 
-  vReadIndex_ = static_cast<double>(buffer_->getSampleRate() * offset);
+  vReadIndex_ = static_cast<double>(alignedBus_->getSampleRate() * offset);
 }
 
 void AudioBufferSourceNode::disable() {
   AudioNode::disable();
-  buffer_ = nullptr;
+
+  if (onendedCallback_) {
+    onendedCallback_(getStopTime());
+  }
+
+  alignedBus_.reset();
 }
 
 std::mutex &AudioBufferSourceNode::getBufferLock() {
@@ -121,88 +144,96 @@ std::mutex &AudioBufferSourceNode::getBufferLock() {
 void AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  // No audio data to fill, zero the output and return.
-  if (!buffer_ || !buffer_->bus_) {
-    processingBus->zero();
-    return;
-  }
+  if (auto locker = Locker::tryLock(getBufferLock())) {
+    // No audio data to fill, zero the output and return.
+    if (!alignedBus_) {
+      processingBus->zero();
+      return;
+    }
+
+    if (!pitchCorrection_) {
+      processWithoutPitchCorrection(processingBus, framesToProcess);
+    } else {
+      processWithPitchCorrection(processingBus, framesToProcess);
+    }
 
-  if (!Locker::tryLock(getBufferLock())) {
+    handleStopScheduled();
+  } else {
     processingBus->zero();
-    return;
   }
+}
 
+double AudioBufferSourceNode::getStopTime() const {
+  return dsp::sampleFrameToTime(
+      static_cast<int>(vReadIndex_), alignedBus_->getSampleRate());
+}
+
+/**
+ * Helper functions
+ */
+
+void AudioBufferSourceNode::processWithoutPitchCorrection(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  if (!pitchCorrection_) {
-    auto computedPlaybackRate = getComputedPlaybackRateValue();
-    updatePlaybackInfo(
-        processingBus, framesToProcess, startOffset, offsetLength);
+  auto computedPlaybackRate = getComputedPlaybackRateValue();
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
 
-    if (computedPlaybackRate == 0.0f || !isPlaying()) {
-      processingBus->zero();
-      return;
-    } else if (std::fabs(computedPlaybackRate) == 1.0) {
-      processWithoutInterpolation(
-          processingBus, startOffset, offsetLength, computedPlaybackRate);
-    } else {
-      processWithInterpolation(
-          processingBus, startOffset, offsetLength, computedPlaybackRate);
-    }
+  if (computedPlaybackRate == 0.0f || !isPlaying()) {
+    processingBus->zero();
+    return;
+  }
+
+  if (std::fabs(computedPlaybackRate) == 1.0) {
+    processWithoutInterpolation(
+        processingBus, startOffset, offsetLength, computedPlaybackRate);
   } else {
-    auto time = context_->getCurrentTime();
-    auto playbackRate =
-        std::clamp(playbackRateParam_->getValueAtTime(time), 0.0f, 3.0f);
-    auto detune =
-        std::clamp(detuneParam_->getValueAtTime(time) / 100.0f, -12.0f, 12.0f);
+    processWithInterpolation(
+        processingBus, startOffset, offsetLength, computedPlaybackRate);
+  }
+}
 
-    playbackRateBus_->zero();
+void AudioBufferSourceNode::processWithPitchCorrection(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
 
-    auto framesNeededToStretch =
-        static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
+  auto time = context_->getCurrentTime();
+  auto playbackRate =
+      std::clamp(playbackRateParam_->getValueAtTime(time), 0.0f, 3.0f);
+  auto detune =
+      std::clamp(detuneParam_->getValueAtTime(time) / 100.0f, -12.0f, 12.0f);
 
-    updatePlaybackInfo(
-        playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
+  playbackRateBus_->zero();
 
-    if (playbackRate == 0.0f || !isPlaying() || !buffer_) {
-      processingBus->zero();
-      return;
-    }
+  auto framesNeededToStretch =
+      static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
 
-    processWithoutInterpolation(
-        playbackRateBus_, startOffset, offsetLength, playbackRate);
+  updatePlaybackInfo(
+      playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
 
-    if (!buffer_) {
-      processingBus->zero();
-      return;
-    }
+  if (playbackRate == 0.0f || !isPlaying()) {
+    processingBus->zero();
+    return;
+  }
 
-    auto stretch = buffer_->stretch_;
+  processWithoutInterpolation(
+      playbackRateBus_, startOffset, offsetLength, playbackRate);
 
-    stretch->process(
-        playbackRateBus_.get()[0],
-        framesNeededToStretch,
-        processingBus.get()[0],
-        framesToProcess);
+  stretch_->process(
+      playbackRateBus_.get()[0],
+      framesNeededToStretch,
+      processingBus.get()[0],
+      framesToProcess);
 
-    if (detune != 0.0f) {
-      stretch->setTransposeSemitones(detune);
-    }
+  if (detune != 0.0f) {
+    stretch_->setTransposeSemitones(detune);
   }
-
-  handleStopScheduled();
 }
 
-double AudioBufferSourceNode::getStopTime() const {
-  return dsp::sampleFrameToTime(
-      static_cast<int>(vReadIndex_), buffer_->getSampleRate());
-}
-
-/**
- * Helper functions
- */
-
 void AudioBufferSourceNode::processWithoutInterpolation(
     const std::shared_ptr<AudioBus> &processingBus,
     size_t startOffset,
@@ -228,15 +259,20 @@ void AudioBufferSourceNode::processWithoutInterpolation(
     size_t framesToCopy = std::min(framesToEnd, framesLeft);
     framesToCopy = framesToCopy > 0 ? framesToCopy : 0;
 
+    assert(readIndex >= 0);
+    assert(writeIndex >= 0);
+    assert(readIndex + framesToCopy <= alignedBus_->getSize());
+    assert(writeIndex + framesToCopy <= processingBus->getSize());
+
     // Direction is forward, we can normally copy the data
     if (direction == 1) {
       processingBus->copy(
-          buffer_->bus_.get(), readIndex, writeIndex, framesToCopy);
+          alignedBus_.get(), readIndex, writeIndex, framesToCopy);
     } else {
       for (int i = 0; i < framesToCopy; i += 1) {
         for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
           (*processingBus->getChannel(j))[writeIndex + i] =
-              (*buffer_->bus_->getChannel(j))[readIndex - i];
+              (*alignedBus_->getChannel(j))[readIndex - i];
         }
       }
     }
@@ -250,12 +286,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
 
       if (!loop_) {
         processingBus->zero(writeIndex, framesLeft);
-
-        if (onendedCallback_) {
-          onendedCallback_(getStopTime());
-        }
-        playbackState_ = PlaybackState::FINISHED;
-        disable();
+        playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
     }
@@ -301,7 +332,7 @@ void AudioBufferSourceNode::processWithInterpolation(
 
     for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
       float *destination = processingBus->getChannel(i)->getData();
-      const float *source = buffer_->bus_->getChannel(i)->getData();
+      const float *source = alignedBus_->getChannel(i)->getData();
 
       destination[writeIndex] =
           dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
@@ -316,8 +347,7 @@ void AudioBufferSourceNode::processWithInterpolation(
 
       if (!loop_) {
         processingBus->zero(writeIndex, framesLeft);
-        playbackState_ = PlaybackState::FINISHED;
-        disable();
+        playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
     }
@@ -327,7 +357,8 @@ void AudioBufferSourceNode::processWithInterpolation(
 float AudioBufferSourceNode::getComputedPlaybackRateValue() {
   auto time = context_->getCurrentTime();
 
-  auto sampleRateFactor = buffer_->getSampleRate() / context_->getSampleRate();
+  auto sampleRateFactor =
+      alignedBus_->getSampleRate() / context_->getSampleRate();
   auto playbackRate = playbackRateParam_->getValueAtTime(time);
   auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
 
@@ -342,7 +373,7 @@ double AudioBufferSourceNode::getVirtualStartFrame() {
 }
 
 double AudioBufferSourceNode::getVirtualEndFrame() {
-  auto inputBufferLength = static_cast<double>(buffer_->bus_->getSize());
+  auto inputBufferLength = static_cast<double>(alignedBus_->getSize());
   auto loopEndFrame = loopEnd_ * context_->getSampleRate();
 
   return loop_ && loopEndFrame > 0 && loopStart_ < loopEnd_

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

@@ -2,6 +2,7 @@
 
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
 #include <memory>
 #include <cstddef>
@@ -16,6 +17,7 @@ class AudioParam;
 class AudioBufferSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferSourceNode(BaseAudioContext *context, bool pitchCorrection);
+  ~AudioBufferSourceNode();
 
   [[nodiscard]] bool getLoop() const;
   [[nodiscard]] double getLoopStart() const;
@@ -46,6 +48,7 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
 
   // pitch correction
   bool pitchCorrection_;
+  std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
 
   // k-rate params
   std::shared_ptr<AudioParam> detuneParam_;
@@ -58,6 +61,13 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
 
   // User provided buffer
   std::shared_ptr<AudioBuffer> buffer_;
+  std::shared_ptr<AudioBus> alignedBus_;
+
+  void processWithoutPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
+                                     int framesToProcess);
+
+  void processWithPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
+                                  int framesToProcess);
 
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus>& processingBus,

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

@@ -40,6 +40,10 @@ bool AudioScheduledSourceNode::isFinished() {
   return playbackState_ == PlaybackState::FINISHED;
 }
 
+bool AudioScheduledSourceNode::isStopScheduled() {
+  return playbackState_ == PlaybackState::STOP_SCHEDULED;
+}
+
 void AudioScheduledSourceNode::setOnendedCallback(
     const std::function<void(double)> &onendedCallback) {
   onendedCallback_ = onendedCallback;
@@ -99,36 +103,24 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   // stop will happen in this render quantum
   // zero remaining frames after stop frame
   if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+    playbackState_ = PlaybackState::STOP_SCHEDULED;
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
     processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
     return;
   }
 
-  // mark as finished in first silent render quantum
-  if (stopFrame < firstFrame) {
-    startOffset = 0;
-    nonSilentFramesToProcess = 0;
-
-    if (onendedCallback_) {
-      onendedCallback_(getStopTime());
-    }
-
-    playbackState_ = PlaybackState::FINISHED;
-    disable();
-    return;
-  }
-
   // normal "mid-buffer" playback
   startOffset = 0;
   nonSilentFramesToProcess = framesToProcess;
 }
 
 void AudioScheduledSourceNode::handleStopScheduled() {
-  if (isPlaying() && stopTime_ > 0 && context_->getCurrentTime() >= stopTime_) {
+  if (isStopScheduled()) {
     if (onendedCallback_) {
       onendedCallback_(getStopTime());
     }
+
     playbackState_ = PlaybackState::FINISHED;
     disable();
   }

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

@@ -18,7 +18,7 @@ namespace audioapi {
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
-  enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, FINISHED };
+  enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, FINISHED, STOP_SCHEDULED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
 
   void start(double when);
@@ -28,6 +28,7 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isScheduled();
   bool isPlaying();
   bool isFinished();
+  bool isStopScheduled();
 
   void setOnendedCallback(const std::function<void(double)> &onendedCallback);
 

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

@@ -16,6 +16,7 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
       1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT);
   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,19 @@ std::mutex &AudioNodeManager::getGraphLock() {
 
 void AudioNodeManager::addNode(const std::shared_ptr<AudioNode> &node) {
   Locker lock(getGraphLock());
-
   nodes_.insert(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(), end = audioNodesToConnect_.end();
+       it != 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 +55,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_.empty());
       it->get()->cleanup();
       it = nodes_.erase(it);
     } else {
@@ -70,8 +71,8 @@ void AudioNodeManager::prepareNodesForDestruction() {
 void AudioNodeManager::cleanup() {
   Locker lock(getGraphLock());
 
-  for (auto &node : nodes_) {
-    node->cleanup();
+  for (auto it = nodes_.begin(), end = nodes_.end(); it != end; ++it) {
+    it->get()->cleanup();
   }
 
   nodes_.clear();

package/common/cpp/audioapi/utils/AudioArray.cpp

@@ -7,6 +7,12 @@ AudioArray::AudioArray(size_t size) : data_(nullptr), size_(size) {
   resize(size);
 }
 
+AudioArray::AudioArray(const AudioArray &other) : data_(nullptr), size_(0) {
+  resize(other.size_);
+
+  copy(&other);
+}
+
 AudioArray::~AudioArray() {
   if (data_) {
     delete[] data_;

package/common/cpp/audioapi/utils/AudioArray.h

@@ -9,6 +9,7 @@ namespace audioapi {
 class AudioArray {
  public:
   explicit AudioArray(size_t size);
+  AudioArray(const AudioArray &other);
   ~AudioArray();
 
   [[nodiscard]] size_t getSize() const;

package/common/cpp/audioapi/utils/AudioBus.cpp

@@ -22,6 +22,18 @@ AudioBus::AudioBus(size_t size, int numberOfChannels, float sampleRate)
   createChannels();
 }
 
+AudioBus::AudioBus(const AudioBus &other) {
+  numberOfChannels_ = other.numberOfChannels_;
+  sampleRate_ = other.sampleRate_;
+  size_ = other.size_;
+
+  createChannels();
+
+  for (int i = 0; i < numberOfChannels_; i += 1) {
+    channels_[i] = std::make_shared<AudioArray>(*other.channels_[i]);
+  }
+}
+
 AudioBus::~AudioBus() {
   channels_.clear();
 }

package/common/cpp/audioapi/utils/AudioBus.h

@@ -25,6 +25,7 @@ class AudioBus {
   };
 
   explicit AudioBus(size_t size, int numberOfChannels, float sampleRate);
+  AudioBus(const AudioBus &other);
 
   ~AudioBus();
 
@@ -34,8 +35,8 @@ class AudioBus {
   [[nodiscard]] AudioArray *getChannel(int index) const;
   [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
 
-    AudioArray &operator[](size_t index);
-    const AudioArray &operator[](size_t index) const;
+  AudioArray &operator[](size_t index);
+  const AudioArray &operator[](size_t index) const;
 
   void normalize();
   void scale(float value);

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

@@ -16,8 +16,7 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 @property (nonatomic, assign) float sampleRate;
 @property (nonatomic, assign) int channelCount;
 @property (nonatomic, assign) bool isRunning;
-@property (nonatomic, assign) bool isInterrupted;
-@property (nonatomic, assign) bool configurationChanged;
+@property (nonatomic, strong) AVAudioSourceNodeRenderBlock renderBlock;
 
 - (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio channelCount:(int)channelCount;
 
@@ -39,11 +38,6 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 - (void)setupAndInitAudioSession;
 
-- (void)setupAndInitNotificationHandlers;
-
 - (void)connectAudioEngine;
 
-- (void)handleEngineConfigurationChange:(NSNotification *)notification;
-- (void)handleInterruption:(NSNotification *)notification;
-
 @end

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

@@ -9,29 +9,25 @@
     self.audioEngine = [[AVAudioEngine alloc] init];
     self.audioEngine.mainMixerNode.outputVolume = 1;
     self.isRunning = true;
-    self.isInterrupted = false;
-    self.configurationChanged = false;
 
     [self setupAndInitAudioSession];
-    [self setupAndInitNotificationHandlers];
 
     self.sampleRate = [self.audioSession sampleRate];
     self.channelCount = channelCount;
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
-
     __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 != weakSelf.channelCount) {
+        return kAudioServicesBadPropertySizeError;
+      }
+
+      weakSelf.renderAudio(outputData, frameCount);
+      return kAudioServicesNoError;
+    };
+
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
   }
 
   return self;
@@ -46,29 +42,25 @@
     self.audioEngine = [[AVAudioEngine alloc] init];
     self.audioEngine.mainMixerNode.outputVolume = 1;
     self.isRunning = true;
-    self.isInterrupted = false;
-    self.configurationChanged = false;
 
     [self setupAndInitAudioSession];
-    [self setupAndInitNotificationHandlers];
 
     self.sampleRate = sampleRate;
     self.channelCount = channelCount;
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
-
     __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 != weakSelf.channelCount) {
+        return kAudioServicesBadPropertySizeError;
+      }
+
+      weakSelf.renderAudio(outputData, frameCount);
+      return kAudioServicesNoError;
+    };
+
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
   }
 
   return self;
@@ -122,20 +114,6 @@
   self.renderAudio = nil;
 }
 
-- (OSStatus)renderCallbackWithIsSilence:(BOOL *)isSilence
-                              timestamp:(const AudioTimeStamp *)timestamp
-                             frameCount:(AVAudioFrameCount)frameCount
-                             outputData:(AudioBufferList *)outputData
-{
-  if (outputData->mNumberBuffers < self.channelCount) {
-    return noErr; // Ensure we have stereo output
-  }
-
-  self.renderAudio(outputData, frameCount);
-
-  return noErr;
-}
-
 - (void)setupAndInitAudioSession
 {
   NSError *error = nil;
@@ -144,17 +122,20 @@
     self.audioSession = [AVAudioSession sharedInstance];
   }
 
-  [self.audioSession setPreferredIOBufferDuration:0.022 error:&error];
+  [self.audioSession setCategory:AVAudioSessionCategoryPlayback
+                            mode:AVAudioSessionModeDefault
+                         options:AVAudioSessionCategoryOptionDuckOthers | AVAudioSessionCategoryOptionAllowAirPlay
+                           error:&error];
 
   if (error != nil) {
-    NSLog(@"Error while setting buffer size in audio session: %@", [error debugDescription]);
+    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
     return;
   }
 
-  [self.audioSession setCategory:AVAudioSessionCategoryPlayback error:&error];
+  [self.audioSession setPreferredIOBufferDuration:0.022 error:&error];
 
   if (error != nil) {
-    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
+    NSLog(@"Error while setting buffer size in audio session: %@", [error debugDescription]);
     return;
   }
 
@@ -164,24 +145,6 @@
     NSLog(@"Error while activating audio session: %@", [error debugDescription]);
     return;
   }
-
-  self.isInterrupted = false;
-}
-
-- (void)setupAndInitNotificationHandlers
-{
-  if (!self.notificationCenter) {
-    self.notificationCenter = [NSNotificationCenter defaultCenter];
-  }
-
-  [self.notificationCenter addObserver:self
-                              selector:@selector(handleEngineConfigurationChange:)
-                                  name:AVAudioEngineConfigurationChangeNotification
-                                object:nil];
-  [self.notificationCenter addObserver:self
-                              selector:@selector(handleInterruption:)
-                                  name:AVAudioSessionInterruptionNotification
-                                object:nil];
 }
 
 - (void)connectAudioEngine
@@ -200,44 +163,6 @@
       NSLog(@"Error starting audio engine: %@", [error debugDescription]);
     }
   }
-
-  self.configurationChanged = false;
-}
-
-- (void)handleEngineConfigurationChange:(NSNotification *)notification
-{
-  if (!self.isRunning || self.isInterrupted) {
-    self.configurationChanged = true;
-    return;
-  }
-
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [self connectAudioEngine];
-  });
-}
-
-- (void)handleInterruption:(NSNotification *)notification
-{
-  NSError *error;
-  UInt8 type = [[notification.userInfo valueForKey:AVAudioSessionInterruptionTypeKey] intValue];
-  UInt8 option = [[notification.userInfo valueForKey:AVAudioSessionInterruptionOptionKey] intValue];
-
-  if (type == AVAudioSessionInterruptionTypeBegan) {
-    self.isInterrupted = true;
-    return;
-  }
-
-  if (type != AVAudioSessionInterruptionTypeEnded || option != AVAudioSessionInterruptionOptionShouldResume) {
-    return;
-  }
-
-  [self setupAndInitAudioSession];
-
-  if (self.configurationChanged && self.isRunning) {
-    dispatch_async(dispatch_get_main_queue(), ^{
-      [self connectAudioEngine];
-    });
-  }
 }
 
 @end

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

@@ -66,7 +66,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.5.3",
+  "version": "0.5.5",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"