react-native-audio-api 0.6.0-rc.4 → 0.6.0

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

@@ -24,42 +24,28 @@ class AudioRecorderHostObject : public JsiHostObject {
  public:
   explicit AudioRecorderHostObject(
       jsi::Runtime *runtime,
-      const std::shared_ptr<react::CallInvoker> &callInvoker,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       float sampleRate,
-      int bufferLength)
-      : callInvoker_(callInvoker) {
-    promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
-
+      int bufferLength) {
 #ifdef ANDROID
     audioRecorder_ = std::make_shared<AndroidAudioRecorder>(
       sampleRate,
       bufferLength,
-      this->getOnError(),
-      this->getOnStatusChange(),
-      this->getOnAudioReady()
+      audioEventHandlerRegistry
     );
 #else
   audioRecorder_ = std::make_shared<IOSAudioRecorder>(
       sampleRate,
       bufferLength,
-      this->getOnError(),
-      this->getOnStatusChange(),
-      this->getOnAudioReady()
+      audioEventHandlerRegistry
     );
 #endif
 
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioRecorderHostObject, onAudioReady));
+
     addFunctions(
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, start),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, onAudioReady),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, onError),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, onStatusChange));
-  }
-
-  ~AudioRecorderHostObject() override {
-    errorCallback_ = nullptr;
-    audioReadyCallback_ = nullptr;
-    statusChangeCallback_ = nullptr;
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop));
   }
 
   JSI_HOST_FUNCTION(start) {
@@ -74,76 +60,11 @@ class AudioRecorderHostObject : public JsiHostObject {
     return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(onAudioReady) {
-    audioReadyCallback_ = std::make_unique<jsi::Function>(args[0].getObject(runtime).getFunction(runtime));
-
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(onError) {
-    errorCallback_ = std::make_unique<jsi::Function>(args[0].getObject(runtime).getFunction(runtime));
-
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(onStatusChange) {
-    statusChangeCallback_ = std::make_unique<jsi::Function>(args[0].getObject(runtime).getFunction(runtime));
-
-    return jsi::Value::undefined();
+  JSI_PROPERTY_SETTER(onAudioReady) {
+    audioRecorder_->setOnAudioReadyCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
   }
 
- protected:
+ private:
   std::shared_ptr<AudioRecorder> audioRecorder_;
-  std::shared_ptr<PromiseVendor> promiseVendor_;
-  std::shared_ptr<react::CallInvoker> callInvoker_;
-
-  std::unique_ptr<jsi::Function> errorCallback_;
-  std::unique_ptr<jsi::Function> audioReadyCallback_;
-  std::unique_ptr<jsi::Function> statusChangeCallback_;
-
-  std::function<void(std::shared_ptr<AudioBus>, int, double)> getOnAudioReady() {
-    return [this](const std::shared_ptr<AudioBus> &bus, int numFrames, double when) {
-      if (audioReadyCallback_ == nullptr) {
-        return;
-      }
-
-      callInvoker_->invokeAsync([this, bus = bus, numFrames, when](jsi::Runtime &runtime) {
-        auto buffer = std::make_shared<AudioBuffer>(bus);
-        auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
-
-        audioReadyCallback_->call(
-          runtime,
-          jsi::Object::createFromHostObject(runtime, bufferHostObject),
-          jsi::Value(numFrames),
-          jsi::Value(when)
-        );
-      });
-    };
-  }
-
-  std::function<void(void)> getOnError() {
-    return [this]() {
-      if (errorCallback_ == nullptr) {
-        return;
-      }
-
-      callInvoker_->invokeAsync([this](jsi::Runtime &runtime) {
-        errorCallback_->call(runtime);
-      });
-    };
-  }
-
-  std::function<void(void)> getOnStatusChange() {
-    return [this]() {
-      if (statusChangeCallback_ == nullptr) {
-        return;
-      }
-
-      callInvoker_->invokeAsync([this](jsi::Runtime &runtime) {
-        statusChangeCallback_->call(runtime);
-      });
-    };
-  }
 };
-
 } // namespace audioapi

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

@@ -12,9 +12,8 @@ using namespace facebook;
 class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AudioScheduledSourceNodeHostObject(
-      const std::shared_ptr<AudioScheduledSourceNode> &node,
-      const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : AudioNodeHostObject(node), callInvoker_(callInvoker) {
+      const std::shared_ptr<AudioScheduledSourceNode> &node)
+      : AudioNodeHostObject(node) {
     addSetters(
       JSI_EXPORT_PROPERTY_SETTER(AudioScheduledSourceNodeHostObject, onended));
     addFunctions(
@@ -22,27 +21,11 @@ class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
         JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, stop));
   }
 
-  ~AudioScheduledSourceNodeHostObject() override {
-    // https://github.com/software-mansion/react-native-reanimated/blob/2b669b069bd70ba876d97a9e19daa509808a1b3a/packages/react-native-worklets/Common/cpp/worklets/SharedItems/Shareables.h#L39-L63
-    auto audioScheduleSourceNode =
-            std::static_pointer_cast<AudioScheduledSourceNode>(node_);
-    audioScheduleSourceNode->setOnendedCallback(nullptr);
-
-    onendedCallback_ = nullptr;
-  }
-
   JSI_PROPERTY_SETTER(onended) {
-      onendedCallback_ = std::make_unique<jsi::Function>(value.getObject(runtime).getFunction(runtime));
     auto audioScheduleSourceNode =
             std::static_pointer_cast<AudioScheduledSourceNode>(node_);
 
-    auto lambda = [this, &runtime](double stopTime) {
-        callInvoker_->invokeAsync([this, &runtime, stopTime] () {
-            onendedCallback_->call(runtime, stopTime);
-        });
-    };
-
-    audioScheduleSourceNode->setOnendedCallback(lambda);
+    audioScheduleSourceNode->setOnEndedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
   }
 
   JSI_HOST_FUNCTION(start) {
@@ -60,9 +43,5 @@ class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
     audioScheduleSourceNode->stop(time);
     return jsi::Value::undefined();
   }
-
- private:
-    std::shared_ptr<react::CallInvoker> callInvoker_;
-    std::unique_ptr<jsi::Function> onendedCallback_;
 };
 } // namespace audioapi

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

@@ -71,7 +71,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION(createOscillator) {
     auto oscillator = context_->createOscillator();
     auto oscillatorHostObject =
-        std::make_shared<OscillatorNodeHostObject>(oscillator, callInvoker_);
+        std::make_shared<OscillatorNodeHostObject>(oscillator);
     return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
   }
 
@@ -99,7 +99,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
     auto pitchCorrection = args[0].asBool();
     auto bufferSource = context_->createBufferSource(pitchCorrection);
     auto bufferSourceHostObject =
-        std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource, callInvoker_);
+        std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
     return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
   }
 

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

@@ -15,9 +15,8 @@ using namespace facebook;
 class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
   explicit OscillatorNodeHostObject(
-          const std::shared_ptr<OscillatorNode> &node,
-          const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : AudioScheduledSourceNodeHostObject(node, callInvoker) {
+          const std::shared_ptr<OscillatorNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
     addGetters(
         JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
         JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, detune),

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

@@ -10,7 +10,10 @@
 #include <audioapi/core/utils/AudioNodeManager.h>
 
 namespace audioapi {
-AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
+AudioContext::AudioContext(
+    float sampleRate,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry) {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio(), sampleRate);
 #else

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

@@ -14,7 +14,7 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  explicit AudioContext(float sampleRate);
+  explicit AudioContext(float sampleRate, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~AudioContext() override;
 
   void close();

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

@@ -1,4 +1,5 @@
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/utils/AudioArray.h>
@@ -38,10 +39,15 @@ std::string AudioNode::getChannelInterpretation() const {
 }
 
 void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingConnection(
+  context_->getNodeManager()->addPendingNodeConnection(
       shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
 }
 
+void AudioNode::connect(const std::shared_ptr<AudioParam> &param) {
+  context_->getNodeManager()->addPendingParamConnection(
+      shared_from_this(), param, AudioNodeManager::ConnectionType::CONNECT);
+}
+
 void AudioNode::disconnect() {
   for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
        ++it) {
@@ -50,10 +56,15 @@ void AudioNode::disconnect() {
 }
 
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingConnection(
+  context_->getNodeManager()->addPendingNodeConnection(
       shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
 }
 
+void AudioNode::disconnect(const std::shared_ptr<AudioParam> &param) {
+  context_->getNodeManager()->addPendingParamConnection(
+      shared_from_this(), param, AudioNodeManager::ConnectionType::DISCONNECT);
+}
+
 bool AudioNode::isEnabled() const {
   return isEnabled_;
 }
@@ -221,6 +232,15 @@ void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
   }
 }
 
+void AudioNode::connectParam(const std::shared_ptr<AudioParam> &param) {
+  auto position = outputParams_.find(param);
+
+  if (position == outputParams_.end()) {
+    outputParams_.insert(param);
+    param->addInputNode(this);
+  }
+}
+
 void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
   auto position = outputNodes_.find(node);
 
@@ -230,6 +250,15 @@ void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
   }
 }
 
+void AudioNode::disconnectParam(const std::shared_ptr<AudioParam> &param) {
+  auto position = outputParams_.find(param);
+
+  if (position != outputParams_.end()) {
+    param->removeInputNode(this);
+    outputParams_.erase(param);
+  }
+}
+
 void AudioNode::onInputEnabled() {
   numberOfEnabledInputNodes_ += 1;
 

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

@@ -15,6 +15,7 @@ namespace audioapi {
 
 class AudioBus;
 class BaseAudioContext;
+class AudioParam;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
@@ -27,8 +28,11 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   std::string getChannelCountMode() const;
   std::string getChannelInterpretation() const;
   void connect(const std::shared_ptr<AudioNode> &node);
+  void connect(const std::shared_ptr<AudioParam> &param);
   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);
 
   bool isEnabled() const;
   void enable();
@@ -50,6 +54,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
 
   std::unordered_set<AudioNode *> inputNodes_ = {};
   std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
+  std::unordered_set<std::shared_ptr<AudioParam>> outputParams_ = {};
 
   int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;
@@ -63,7 +68,6 @@ 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(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   virtual void processNode(const std::shared_ptr<AudioBus>&, int) = 0;
 
   bool isAlreadyProcessed();
@@ -73,6 +77,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
 
   void connectNode(const std::shared_ptr<AudioNode> &node);
   void disconnectNode(const std::shared_ptr<AudioNode> &node);
+  void connectParam(const std::shared_ptr<AudioParam> &param);
+  void disconnectParam(const std::shared_ptr<AudioParam> &param);
 
   void onInputEnabled();
   void onInputDisabled();

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

@@ -1,14 +1,27 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <iostream>
 
 namespace audioapi {
 
-AudioParam::AudioParam(float defaultValue, float minValue, float maxValue)
+AudioParam::AudioParam(
+    float defaultValue,
+    float minValue,
+    float maxValue,
+    BaseAudioContext *context)
     : value_(defaultValue),
       defaultValue_(defaultValue),
       minValue_(minValue),
-      maxValue_(maxValue) {
+      maxValue_(maxValue),
+      context_(context),
+      audioBus_(
+          std::make_shared<AudioBus>(
+              RENDER_QUANTUM_SIZE,
+              1,
+              context->getSampleRate())) {
   startTime_ = 0;
   endTime_ = 0;
   startValue_ = value_;
@@ -256,6 +269,44 @@ void AudioParam::cancelAndHoldAtTime(double cancelTime) {
   }
 }
 
+void AudioParam::addInputNode(AudioNode *node) {
+  auto position = inputNodes_.find(node);
+  if (position == inputNodes_.end()) {
+    inputNodes_.insert(node);
+  }
+}
+
+void AudioParam::removeInputNode(AudioNode *node) {
+  auto position = inputNodes_.find(node);
+
+  if (position != inputNodes_.end()) {
+    inputNodes_.erase(position);
+  }
+}
+
+std::shared_ptr<AudioBus> AudioParam::processARateParam(
+    int framesToProcess,
+    double time) {
+  auto processingBus = audioBus_;
+  processingBus->zero();
+  if (!inputNodes_.empty()) {
+    processInputs(processingBus, framesToProcess, true);
+    mixInputsBuses(processingBus);
+  }
+  for (size_t i = 0; i < framesToProcess; i++) {
+    auto sample = getValueAtTime(time + i / context_->getSampleRate());
+    processingBus->getChannel(0)->getData()[i] += sample;
+  }
+  // processingBus is a mono bus
+  return processingBus;
+}
+
+float AudioParam::processKRateParam(int framesToProcess, double time) {
+  auto processingBus = processARateParam(framesToProcess, time);
+  // processingBus is a mono bus
+  return processingBus->getChannel(0)->getData()[0];
+}
+
 double AudioParam::getQueueEndTime() {
   if (eventsQueue_.empty()) {
     return endTime_;
@@ -292,4 +343,35 @@ void AudioParam::updateQueue(ParamChangeEvent &event) {
   eventsQueue_.push_back(event);
 }
 
+void AudioParam::processInputs(
+    const std::shared_ptr<AudioBus> &outputBus,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
+       ++it) {
+    auto inputNode = *it;
+    assert(inputNode != nullptr);
+
+    if (!inputNode->isEnabled()) {
+      continue;
+    }
+
+    auto inputBus = inputNode->processAudio(
+        outputBus, framesToProcess, checkIsAlreadyProcessed);
+    inputBuses_.push_back(inputBus);
+  }
+}
+
+void AudioParam::mixInputsBuses(
+    const std::shared_ptr<AudioBus> &processingBus) {
+  assert(processingBus != nullptr);
+
+  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end;
+       ++it) {
+    processingBus->sum(it->get(), ChannelInterpretation::SPEAKERS);
+  }
+
+  inputBuses_.clear();
+}
+
 } // namespace audioapi

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

@@ -2,17 +2,20 @@
 
 #include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/AudioNode.h>
 
 #include <deque>
 #include <memory>
 #include <vector>
+#include <unordered_set>
 #include <cstddef>
 
 namespace audioapi {
 
 class AudioParam {
  public:
-  explicit AudioParam(float defaultValue, float minValue, float maxValue);
+  explicit AudioParam(float defaultValue, float minValue, float maxValue, BaseAudioContext *context);
 
   [[nodiscard]] float getValue() const;
   float getValueAtTime(double time);
@@ -33,23 +36,33 @@ class AudioParam {
       double duration);
   void cancelScheduledValues(double cancelTime);
   void cancelAndHoldAtTime(double cancelTime);
+  void addInputNode(AudioNode* node);
+  void removeInputNode(AudioNode* node);
+  std::shared_ptr<AudioBus> processARateParam(int framesToProcess, double time);
+  float processKRateParam(int framesToProcess, double time);
 
  private:
   float value_;
   float defaultValue_;
   float minValue_;
   float maxValue_;
+  BaseAudioContext *context_;
   std::deque<ParamChangeEvent> eventsQueue_;
+  std::unordered_set<AudioNode *> inputNodes_;
+  std::shared_ptr<AudioBus> audioBus_;
 
   double startTime_;
   double endTime_;
   float startValue_;
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
+  std::vector<std::shared_ptr<AudioBus>> inputBuses_ = {};
 
   double getQueueEndTime();
   float getQueueEndValue();
   void updateQueue(ParamChangeEvent &event);
+  void processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
+  void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -9,14 +9,20 @@
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
 
 namespace audioapi {
 
-BaseAudioContext::BaseAudioContext() {
+BaseAudioContext::BaseAudioContext(
+    const std::shared_ptr<AudioEventHandlerRegistry>
+        &audioEventHandlerRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
+
+  audioEventHandlerRegistry_ = audioEventHandlerRegistry;
 }
 
 std::string BaseAudioContext::getState() {

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

@@ -26,10 +26,11 @@ class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioDecoder;
 class AnalyserNode;
+class AudioEventHandlerRegistry;
 
 class BaseAudioContext {
  public:
-  BaseAudioContext();
+  explicit BaseAudioContext(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -77,6 +78,11 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedSquareWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
+
+ protected:
+    friend class AudioScheduledSourceNode;
+
+    std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 
 } // namespace audioapi

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

@@ -21,8 +21,9 @@ namespace audioapi {
 OfflineAudioContext::OfflineAudioContext(
     int numberOfChannels,
     size_t length,
-    float sampleRate)
-    : BaseAudioContext(),
+    float sampleRate,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {

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

@@ -14,7 +14,7 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate);
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~OfflineAudioContext() override;
 
   void resume();