react-native-audio-api 0.5.5 → 0.5.7

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -2,7 +2,9 @@
 
 #include <audioapi/jsi/JsiPromise.h>
 #include <audioapi/core/AudioContext.h>
+#include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/HostObjects/AudioContextHostObject.h>
+#include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
 
 #include <memory>
 
@@ -14,8 +16,11 @@ class AudioAPIModuleInstaller {
  public:
   static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
     auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker);
     jsiRuntime->global().setProperty(
         *jsiRuntime, "createAudioContext", createAudioContext);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
   }
 
  private:
@@ -44,6 +49,29 @@ class AudioAPIModuleInstaller {
               runtime, audioContextHostObject);
         });
   }
+
+  static jsi::Function getCreateOfflineAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
+        0,
+        [jsiRuntime, jsCallInvoker](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+            auto numberOfChannels = static_cast<int>(args[0].getNumber());
+            auto length = static_cast<size_t>(args[1].getNumber());
+            auto sampleRate = static_cast<float>(args[2].getNumber());
+
+          std::shared_ptr<OfflineAudioContext> offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate);
+          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
+              offlineAudioContext, jsiRuntime, jsCallInvoker);
+
+          return jsi::Object::createFromHostObject(
+              runtime, audioContextHostObject);
+        });
+  }
 };
 
 } // namespace audioapi

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

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/HostObjects/BaseAudioContextHostObject.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class OfflineAudioContextHostObject : public BaseAudioContextHostObject {
+ public:
+  explicit OfflineAudioContextHostObject(
+          const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
+          jsi::Runtime *runtime,
+          const std::shared_ptr<react::CallInvoker> &callInvoker)
+      : BaseAudioContextHostObject(offlineAudioContext, runtime, callInvoker) {
+    addFunctions(
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, resume),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, suspend),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, startRendering));
+  }
+
+  JSI_HOST_FUNCTION(resume) {
+    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+      audioContext->resume();
+    });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(suspend) {
+    double when = args[0].getNumber();
+
+    auto promise = promiseVendor_->createPromise([this, when](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+      OfflineAudioContextSuspendCallback callback = [promise]() {
+        promise->resolve([](jsi::Runtime &runtime) {
+          return jsi::Value::undefined();
+        });
+      };
+      audioContext->suspend(when, callback);
+    });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(startRendering) {
+    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+
+      OfflineAudioContextResultCallback callback =
+          [promise](const std::shared_ptr<AudioBuffer>& audioBuffer) -> void {
+        auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+        promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
+          return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+        });
+      };
+
+      audioContext->startRendering(callback);
+    });
+
+    return promise;
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -0,0 +1,117 @@
+#include "OfflineAudioContext.h"
+
+#include <audioapi/core/AudioContext.h>
+#include <audioapi/core/Constants.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/utils/AudioDecoder.h>
+#include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/Locker.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+
+OfflineAudioContext::OfflineAudioContext(
+    int numberOfChannels,
+    size_t length,
+    float sampleRate)
+    : BaseAudioContext(),
+      length_(length),
+      numberOfChannels_(numberOfChannels),
+      currentSampleFrame_(0) {
+  sampleRate_ = sampleRate;
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
+  resultBus_ = std::make_shared<AudioBus>(
+      static_cast<int>(length_), numberOfChannels_, sampleRate_);
+}
+
+OfflineAudioContext::~OfflineAudioContext() {
+  nodeManager_->cleanup();
+}
+
+void OfflineAudioContext::resume() {
+  Locker locker(mutex_);
+
+  if (state_ == ContextState::RUNNING) {
+    return;
+  }
+
+  renderAudio();
+}
+
+void OfflineAudioContext::suspend(
+    double when,
+    const std::function<void()> &callback) {
+  Locker locker(mutex_);
+
+  // we can only suspend once per render quantum at the end of the quantum
+  // first quantum is [0, RENDER_QUANTUM_SIZE)
+  auto frame = static_cast<size_t>(when * sampleRate_);
+  frame = RENDER_QUANTUM_SIZE *
+      ((frame + RENDER_QUANTUM_SIZE - 1) / RENDER_QUANTUM_SIZE);
+
+  if (scheduledSuspends_.find(frame) != scheduledSuspends_.end()) {
+    throw std::runtime_error(
+        "cannot schedule more than one suspend at frame " +
+        std::to_string(frame) + " (" + std::to_string(when) + " seconds)");
+  }
+
+  scheduledSuspends_.emplace(frame, callback);
+}
+
+void OfflineAudioContext::renderAudio() {
+  state_ = ContextState::RUNNING;
+  std::thread([this]() {
+    auto audioBus = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, numberOfChannels_, sampleRate_);
+
+    while (currentSampleFrame_ < length_) {
+      Locker locker(mutex_);
+      int framesToProcess = std::min(
+          static_cast<int>(length_ - currentSampleFrame_), RENDER_QUANTUM_SIZE);
+
+      destination_->renderAudio(audioBus, framesToProcess);
+
+      for (int i = 0; i < framesToProcess; i++) {
+        for (int channel = 0; channel < numberOfChannels_; channel += 1) {
+          resultBus_->getChannel(channel)->getData()[currentSampleFrame_ + i] =
+              audioBus->getChannel(channel)->getData()[i];
+        }
+      }
+
+      currentSampleFrame_ += framesToProcess;
+
+      // Execute scheduled suspend if exists
+      auto suspend = scheduledSuspends_.find(currentSampleFrame_);
+      if (suspend != scheduledSuspends_.end()) {
+        assert(currentSampleFrame_ < length_);
+        auto callback = suspend->second;
+        scheduledSuspends_.erase(currentSampleFrame_);
+        state_ = ContextState::SUSPENDED;
+        callback();
+        return;
+      }
+    }
+
+    // Rendering completed
+    auto buffer = std::make_shared<AudioBuffer>(resultBus_);
+    resultCallback_(buffer);
+  }).detach();
+}
+
+void OfflineAudioContext::startRendering(
+    OfflineAudioContextResultCallback callback) {
+  Locker locker(mutex_);
+
+  resultCallback_ = std::move(callback);
+  renderAudio();
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "BaseAudioContext.h"
+
+#include <mutex>
+#include <map>
+#include <unordered_map>
+#include <memory>
+
+namespace audioapi {
+
+using OfflineAudioContextSuspendCallback = std::function<void()>;
+using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<AudioBuffer>)>;
+
+class OfflineAudioContext : public BaseAudioContext {
+ public:
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate);
+  ~OfflineAudioContext() override;
+
+  void resume();
+  void suspend(double when, const OfflineAudioContextSuspendCallback& callback);
+
+  void startRendering(OfflineAudioContextResultCallback callback);
+
+ private:
+  std::mutex mutex_;
+
+  std::unordered_map<size_t, OfflineAudioContextSuspendCallback> scheduledSuspends_;
+  OfflineAudioContextResultCallback resultCallback_;
+
+  size_t length_;
+  int numberOfChannels_;
+  size_t currentSampleFrame_;
+
+  std::shared_ptr<AudioBus> resultBus_;
+
+  void renderAudio();
+};
+
+} // namespace audioapi

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

@@ -101,7 +101,7 @@ void AudioBufferSourceNode::setBuffer(
 
   loopEnd_ = buffer_->getDuration();
 
-  stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
+  stretch_->presetDefault(channelCount_, buffer_->getSampleRate(), true);
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
@@ -181,7 +181,7 @@ void AudioBufferSourceNode::processWithoutPitchCorrection(
   auto computedPlaybackRate = getComputedPlaybackRateValue();
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
 
-  if (computedPlaybackRate == 0.0f || !isPlaying()) {
+  if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
     return;
   }
@@ -215,7 +215,7 @@ void AudioBufferSourceNode::processWithPitchCorrection(
   updatePlaybackInfo(
       playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
 
-  if (playbackRate == 0.0f || !isPlaying()) {
+  if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
     return;
   }

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

@@ -71,7 +71,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
       std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
   size_t stopFrame = stopTime_ == -1.0
       ? std::numeric_limits<size_t>::max()
-      : std::max(dsp::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
+      : dsp::timeToSampleFrame(stopTime_, sampleRate);
 
   if (isUnscheduled() || isFinished()) {
     startOffset = 0;
@@ -93,7 +93,18 @@ 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);
+
+    // stop will happen in the same render quantum
+    if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+      playbackState_ = PlaybackState::STOP_SCHEDULED;
+      processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
+    }
+
     processingBus->zero(0, startOffset);
     return;
   }
@@ -106,10 +117,25 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     playbackState_ = PlaybackState::STOP_SCHEDULED;
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
+
+    assert(startOffset <= framesToProcess);
+    assert(nonSilentFramesToProcess <= framesToProcess);
+
     processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
     return;
   }
 
+  // mark as finished in first silent render quantum
+  if (stopFrame < firstFrame) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+
+    playbackState_ = PlaybackState::STOP_SCHEDULED;
+    handleStopScheduled();
+    playbackState_ = PlaybackState::FINISHED;
+    return;
+  }
+
   // normal "mid-buffer" playback
   startOffset = 0;
   nonSilentFramesToProcess = framesToProcess;

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

@@ -0,0 +1,53 @@
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/utils/AudioNodeDestructor.h>
+#include <audioapi/core/utils/Locker.h>
+
+namespace audioapi {
+
+AudioNodeDestructor::AudioNodeDestructor()
+    : thread_(std::thread(&AudioNodeDestructor::process, this)),
+      isExiting_(false) {}
+
+AudioNodeDestructor::~AudioNodeDestructor() {
+  isExiting_ = true;
+
+  cv_.notify_one(); // call process for the last time
+  if (thread_.joinable()) {
+    thread_.join();
+  }
+}
+
+void AudioNodeDestructor::tryCallWithLock(
+    const std::function<void()> &callback) {
+  if (auto lock = Locker::tryLock(mutex_)) {
+    callback();
+  }
+}
+
+void AudioNodeDestructor::addNodeForDeconstruction(
+    const std::shared_ptr<AudioNode> &node) {
+  // NOTE: this method must be called within `tryCallWithLock`
+  nodesForDeconstruction_.emplace_back(node);
+}
+
+void AudioNodeDestructor::notify() {
+  cv_.notify_one();
+}
+
+void AudioNodeDestructor::process() {
+  std::unique_lock<std::mutex> lock(mutex_);
+  while (!isExiting_) {
+    cv_.wait(lock, [this] {
+      return isExiting_ || !nodesForDeconstruction_.empty();
+    });
+
+    if (isExiting_)
+      break;
+
+    if (!isExiting_ && !nodesForDeconstruction_.empty()) {
+      nodesForDeconstruction_.clear();
+    }
+  }
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <atomic>
+#include <vector>
+#include <memory>
+
+namespace audioapi {
+
+class AudioNode;
+
+class AudioNodeDestructor {
+ public:
+  AudioNodeDestructor();
+  ~AudioNodeDestructor();
+
+  void tryCallWithLock(const std::function<void()> &callback);
+  void addNodeForDeconstruction(const std::shared_ptr<AudioNode> &node);
+  void notify();
+
+ private:
+  mutable std::mutex mutex_;
+  std::thread thread_;
+  std::condition_variable cv_;
+  std::vector<std::shared_ptr<AudioNode>> nodesForDeconstruction_;
+
+  std::atomic<bool> isExiting_;
+
+  void process();
+};
+} // namespace audioapi

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

@@ -55,17 +55,20 @@ void AudioNodeManager::settlePendingConnections() {
 }
 
 void AudioNodeManager::prepareNodesForDestruction() {
-  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 {
-      ++it;
+  nodeDeconstructor_.tryCallWithLock([this]() {
+    auto it = nodes_.begin();
+
+    while (it != nodes_.end()) {
+      if (it->use_count() == 1) {
+        nodeDeconstructor_.addNodeForDeconstruction(*it);
+        it->get()->cleanup();
+        it = nodes_.erase(it);
+      } else {
+        ++it;
+      }
     }
-  }
+  });
+  nodeDeconstructor_.notify();
 }
 
 void AudioNodeManager::cleanup() {

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

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/core/utils/AudioNodeDestructor.h>
+
 #include <memory>
 #include <mutex>
 #include <tuple>
@@ -31,6 +33,7 @@ class AudioNodeManager {
 
  private:
   std::mutex graphLock_;
+  AudioNodeDestructor nodeDeconstructor_;
 
   // all nodes created in the context
   std::unordered_set<std::shared_ptr<AudioNode>> nodes_;