react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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

@@ -3,8 +3,8 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
-#include <memory>
 #include <functional>
+#include <memory>
 
 namespace audioapi {
 #ifdef ANDROID
@@ -15,13 +15,16 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  explicit AudioContext(float sampleRate, bool initSuspended, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
+  explicit AudioContext(
+      float sampleRate,
+      const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const RuntimeRegistry &runtimeRegistry);
   ~AudioContext() override;
 
   void close();
   bool resume();
   bool suspend();
-
+  bool start();
 
  private:
 #ifdef ANDROID

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

@@ -4,12 +4,15 @@
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
+#include <utility>
 
 namespace audioapi {
 
 AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
 }
 
 AudioNode::~AudioNode() {
@@ -50,9 +53,7 @@ void AudioNode::connect(const std::shared_ptr<AudioParam> &param) {
 
 void AudioNode::disconnect() {
   context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(),
-      nullptr,
-      AudioNodeManager::ConnectionType::DISCONNECT_ALL);
+      shared_from_this(), nullptr, AudioNodeManager::ConnectionType::DISCONNECT_ALL);
 }
 
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
@@ -69,6 +70,10 @@ bool AudioNode::isEnabled() const {
   return isEnabled_;
 }
 
+bool AudioNode::requiresTailProcessing() const {
+  return requiresTailProcessing_;
+}
+
 void AudioNode::enable() {
   if (isEnabled()) {
     return;
@@ -76,8 +81,7 @@ void AudioNode::enable() {
 
   isEnabled_ = true;
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
     it->get()->onInputEnabled();
   }
 }
@@ -89,8 +93,7 @@ void AudioNode::disable() {
 
   isEnabled_ = false;
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
     it->get()->onInputDisabled();
   }
 }
@@ -132,8 +135,7 @@ std::shared_ptr<AudioBus> AudioNode::processAudio(
   }
 
   // Process inputs and return the bus with the most channels.
-  auto processingBus =
-      processInputs(outputBus, framesToProcess, checkIsAlreadyProcessed);
+  auto processingBus = processInputs(outputBus, framesToProcess, checkIsAlreadyProcessed);
 
   // Apply channel count mode.
   processingBus = applyChannelCountMode(processingBus);
@@ -172,8 +174,7 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
   processingBus->zero();
 
   int maxNumberOfChannels = 0;
-  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end; ++it) {
     auto inputNode = *it;
     assert(inputNode != nullptr);
 
@@ -181,8 +182,7 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
       continue;
     }
 
-    auto inputBus = inputNode->processAudio(
-        outputBus, framesToProcess, checkIsAlreadyProcessed);
+    auto inputBus = inputNode->processAudio(outputBus, framesToProcess, checkIsAlreadyProcessed);
     inputBuses_.push_back(inputBus);
 
     if (maxNumberOfChannels < inputBus->getNumberOfChannels()) {
@@ -215,8 +215,7 @@ std::shared_ptr<AudioBus> AudioNode::applyChannelCountMode(
 void AudioNode::mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus) {
   assert(processingBus != nullptr);
 
-  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end;
-       ++it) {
+  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end; ++it) {
     processingBus->sum(it->get(), channelInterpretation_);
   }
 
@@ -306,8 +305,7 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
 void AudioNode::cleanup() {
   isInitialized_ = false;
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
     it->get()->onInputDisconnected(this);
   }
 

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

@@ -4,12 +4,12 @@
 #include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/core/utils/Constants.h>
 
+#include <cassert>
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <unordered_set>
-#include <cstddef>
 #include <vector>
-#include <cassert>
 
 namespace audioapi {
 
@@ -32,15 +32,21 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   void disconnect();
   void disconnect(const std::shared_ptr<AudioNode> &node);
   void disconnect(const std::shared_ptr<AudioParam> &param);
-  virtual std::shared_ptr<AudioBus> processAudio(const 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);
 
   bool isEnabled() const;
+  bool requiresTailProcessing() const;
   void enable();
   virtual void disable();
 
  protected:
   friend class AudioNodeManager;
   friend class AudioDestinationNode;
+  friend class ConvolverNode;
+  friend class DelayNodeHostObject;
 
   BaseAudioContext *context_;
   std::shared_ptr<AudioBus> audioBus_;
@@ -50,7 +56,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   int channelCount_ = 2;
   ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
   ChannelInterpretation channelInterpretation_ =
-          ChannelInterpretation::SPEAKERS;
+
+      ChannelInterpretation::SPEAKERS;
 
   std::unordered_set<AudioNode *> inputNodes_ = {};
   std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
@@ -59,6 +66,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;
   bool isEnabled_ = true;
+  bool requiresTailProcessing_ = false;
 
   std::size_t lastRenderedFrame_{SIZE_MAX};
 
@@ -68,12 +76,15 @@ 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> processNode(const std::shared_ptr<AudioBus>&, int) = 0;
+  virtual std::shared_ptr<AudioBus> processInputs(
+      const std::shared_ptr<AudioBus> &outputBus,
+      int framesToProcess,
+      bool checkIsAlreadyProcessed);
+  virtual std::shared_ptr<AudioBus> 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(const std::shared_ptr<AudioBus> &processingBus);
-  void mixInputsBuses(const 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);
@@ -81,7 +92,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   void disconnectParam(const std::shared_ptr<AudioParam> &param);
 
   void onInputEnabled();
-  void onInputDisabled();
+  virtual void onInputDisabled();
   void onInputConnected(AudioNode *node);
   void onInputDisconnected(AudioNode *node);
 

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

@@ -3,6 +3,8 @@
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -18,11 +20,7 @@ AudioParam::AudioParam(
       maxValue_(maxValue),
       eventsQueue_(),
       eventScheduler_(32),
-      audioBus_(
-          std::make_shared<AudioBus>(
-              RENDER_QUANTUM_SIZE,
-              1,
-              context->getSampleRate())) {
+      audioBus_(std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())) {
   inputBuses_.reserve(4);
   inputNodes_.reserve(4);
   startTime_ = 0;
@@ -56,22 +54,19 @@ float AudioParam::getValueAtTime(double time) {
 void AudioParam::setValueAtTime(float value, double startTime) {
   auto event = [value, startTime](AudioParam &param) {
     // Ignore events scheduled before the end of existing automation
-    if (startTime <= param.getQueueEndTime()) {
+    if (startTime < param.getQueueEndTime()) {
       return;
     }
 
     // Step function: instant change at startTime
-    auto calculateValue = [](double startTime,
-                             double /* endTime */,
-                             float startValue,
-                             float endValue,
-                             double time) {
-      if (time < startTime) {
-        return startValue;
-      }
+    auto calculateValue =
+        [](double startTime, double /* endTime */, float startValue, float endValue, double time) {
+          if (time < startTime) {
+            return startValue;
+          }
 
-      return endValue;
-    };
+          return endValue;
+        };
 
     param.updateQueue(ParamChangeEvent(
         startTime,
@@ -87,29 +82,24 @@ void AudioParam::setValueAtTime(float value, double startTime) {
 void AudioParam::linearRampToValueAtTime(float value, double endTime) {
   auto event = [value, endTime](AudioParam &param) {
     // Ignore events scheduled before the end of existing automation
-    if (endTime <= param.getQueueEndTime()) {
+    if (endTime < param.getQueueEndTime()) {
       return;
     }
 
     // Linear interpolation function
-    auto calculateValue = [](double startTime,
-                             double endTime,
-                             float startValue,
-                             float endValue,
-                             double time) {
-      if (time < startTime) {
-        return startValue;
-      }
+    auto calculateValue =
+        [](double startTime, double endTime, float startValue, float endValue, double time) {
+          if (time < startTime) {
+            return startValue;
+          }
 
-      if (time < endTime) {
-        return static_cast<float>(
-            startValue +
-            (endValue - startValue) * (time - startTime) /
-                (endTime - startTime));
-      }
+          if (time < endTime) {
+            return static_cast<float>(
+                startValue + (endValue - startValue) * (time - startTime) / (endTime - startTime));
+          }
 
-      return endValue;
-    };
+          return endValue;
+        };
 
     param.updateQueue(ParamChangeEvent(
         param.getQueueEndTime(),
@@ -129,24 +119,20 @@ void AudioParam::exponentialRampToValueAtTime(float value, double endTime) {
     }
 
     // Exponential curve function using power law
-    auto calculateValue = [](double startTime,
-                             double endTime,
-                             float startValue,
-                             float endValue,
-                             double time) {
-      if (time < startTime) {
-        return startValue;
-      }
+    auto calculateValue =
+        [](double startTime, double endTime, float startValue, float endValue, double time) {
+          if (time < startTime) {
+            return startValue;
+          }
 
-      if (time < endTime) {
-        return static_cast<float>(
-            startValue *
-            pow(endValue / startValue,
-                (time - startTime) / (endTime - startTime)));
-      }
+          if (time < endTime) {
+            return static_cast<float>(
+                startValue *
+                pow(endValue / startValue, (time - startTime) / (endTime - startTime)));
+          }
 
-      return endValue;
-    };
+          return endValue;
+        };
 
     param.updateQueue(ParamChangeEvent(
         param.getQueueEndTime(),
@@ -159,26 +145,21 @@ void AudioParam::exponentialRampToValueAtTime(float value, double endTime) {
   eventScheduler_.scheduleEvent(std::move(event));
 }
 
-void AudioParam::setTargetAtTime(
-    float target,
-    double startTime,
-    double timeConstant) {
+void AudioParam::setTargetAtTime(float target, double startTime, double timeConstant) {
   auto event = [target, startTime, timeConstant](AudioParam &param) {
     if (startTime <= param.getQueueEndTime()) {
       return;
     }
     // Exponential decay function towards target value
-    auto calculateValue =
-        [timeConstant, target](
-            double startTime, double, float startValue, float, double time) {
-          if (time < startTime) {
-            return startValue;
-          }
+    auto calculateValue = [timeConstant, target](
+                              double startTime, double, float startValue, float, double time) {
+      if (time < startTime) {
+        return startValue;
+      }
 
-          return static_cast<float>(
-              target +
-              (startValue - target) * exp(-(time - startTime) / timeConstant));
-        };
+      return static_cast<float>(
+          target + (startValue - target) * exp(-(time - startTime) / timeConstant));
+    };
     param.updateQueue(ParamChangeEvent(
         startTime,
         startTime, // SetTarget events have infinite duration conceptually
@@ -202,31 +183,25 @@ void AudioParam::setValueCurveAtTime(
       return;
     }
 
-    auto calculateValue = [values, length](
-                              double startTime,
-                              double endTime,
-                              float startValue,
-                              float endValue,
-                              double time) {
-      if (time < startTime) {
-        return startValue;
-      }
+    auto calculateValue =
+        [values, length](
+            double startTime, double endTime, float startValue, float endValue, double time) {
+          if (time < startTime) {
+            return startValue;
+          }
 
-      if (time < endTime) {
-        // Calculate position in the array based on time progress
-        auto k = static_cast<int>(std::floor(
-            static_cast<double>(length - 1) / (endTime - startTime) *
-            (time - startTime)));
-        // Calculate interpolation factor between adjacent array elements
-        auto factor = static_cast<float>(
-            (time - startTime) * static_cast<double>(length - 1) /
-                (endTime - startTime) -
-            k);
-        return dsp::linearInterpolate(values->data(), k, k + 1, factor);
-      }
+          if (time < endTime) {
+            // Calculate position in the array based on time progress
+            auto k = static_cast<int>(std::floor(
+                static_cast<double>(length - 1) / (endTime - startTime) * (time - startTime)));
+            // Calculate interpolation factor between adjacent array elements
+            auto factor = static_cast<float>(
+                (time - startTime) * static_cast<double>(length - 1) / (endTime - startTime) - k);
+            return dsp::linearInterpolate(values->data(), k, k + 1, factor);
+          }
 
-      return endValue;
-    };
+          return endValue;
+        };
 
     param.updateQueue(ParamChangeEvent(
         startTime,
@@ -243,9 +218,8 @@ void AudioParam::setValueCurveAtTime(
 }
 
 void AudioParam::cancelScheduledValues(double cancelTime) {
-  eventScheduler_.scheduleEvent([cancelTime](AudioParam &param) {
-    param.eventsQueue_.cancelScheduledValues(cancelTime);
-  });
+  eventScheduler_.scheduleEvent(
+      [cancelTime](AudioParam &param) { param.eventsQueue_.cancelScheduledValues(cancelTime); });
 }
 
 void AudioParam::cancelAndHoldAtTime(double cancelTime) {
@@ -280,9 +254,7 @@ std::shared_ptr<AudioBus> AudioParam::calculateInputs(
   return processingBus;
 }
 
-std::shared_ptr<AudioBus> AudioParam::processARateParam(
-    int framesToProcess,
-    double time) {
+std::shared_ptr<AudioBus> AudioParam::processARateParam(int framesToProcess, double time) {
   processScheduledEvents();
   auto processingBus = calculateInputs(audioBus_, framesToProcess);
 
@@ -313,8 +285,7 @@ void AudioParam::processInputs(
     const std::shared_ptr<AudioBus> &outputBus,
     int framesToProcess,
     bool checkIsAlreadyProcessed) {
-  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end; ++it) {
     auto inputNode = *it;
     assert(inputNode != nullptr);
 
@@ -323,19 +294,16 @@ void AudioParam::processInputs(
     }
 
     // Process this input node and store its output bus
-    auto inputBus = inputNode->processAudio(
-        outputBus, framesToProcess, checkIsAlreadyProcessed);
+    auto inputBus = inputNode->processAudio(outputBus, framesToProcess, checkIsAlreadyProcessed);
     inputBuses_.emplace_back(inputBus);
   }
 }
 
-void AudioParam::mixInputsBuses(
-    const std::shared_ptr<AudioBus> &processingBus) {
+void AudioParam::mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus) {
   assert(processingBus != nullptr);
 
   // Sum all input buses into the processing bus
-  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end;
-       ++it) {
+  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end; ++it) {
     processingBus->sum(it->get(), ChannelInterpretation::SPEAKERS);
   }
 

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

@@ -1,23 +1,27 @@
 #pragma once
 
+#include <audioapi/core/AudioNode.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/core/utils/AudioParamEventQueue.h>
 #include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/utils/AudioBus.h>
-#include <audioapi/core/AudioNode.h>
-#include <audioapi/core/utils/AudioParamEventQueue.h>
 
+#include <audioapi/utils/CrossThreadEventScheduler.hpp>
 #include <cstddef>
-#include <utility>
 #include <memory>
-#include <vector>
 #include <unordered_set>
-#include <audioapi/utils/CrossThreadEventScheduler.hpp>
+#include <utility>
+#include <vector>
 
 namespace audioapi {
 
 class AudioParam {
  public:
-  explicit AudioParam(float defaultValue, float minValue, float maxValue, BaseAudioContext *context);
+  explicit AudioParam(
+      float defaultValue,
+      float minValue,
+      float maxValue,
+      BaseAudioContext *context);
 
   /// JS-Thread only methods
   /// These methods are called only from HostObjects invoked on the JS thread.
@@ -72,15 +76,14 @@ class AudioParam {
   // JS-Thread only
   void cancelAndHoldAtTime(double cancelTime);
 
-
   /// Audio-Thread only methods
   /// These methods are called only from the Audio rendering thread.
 
   // Audio-Thread only (indirectly through AudioNode::connectParam by AudioNodeManager)
-  void addInputNode(AudioNode* node);
+  void addInputNode(AudioNode *node);
 
   // Audio-Thread only (indirectly through AudioNode::disconnectParam by AudioNodeManager)
-  void removeInputNode(AudioNode* node);
+  void removeInputNode(AudioNode *node);
 
   // Audio-Thread only
   std::shared_ptr<AudioBus> processARateParam(int framesToProcess, double time);
@@ -141,9 +144,14 @@ class AudioParam {
     eventsQueue_.pushBack(std::move(event));
   }
   float getValueAtTime(double time);
-  void processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
-  void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
-  std::shared_ptr<AudioBus> calculateInputs(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess);
+  void processInputs(
+      const std::shared_ptr<AudioBus> &outputBus,
+      int framesToProcess,
+      bool checkIsAlreadyProcessed);
+  void mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus);
+  std::shared_ptr<AudioBus> calculateInputs(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess);
 };
 
 } // namespace audioapi