react-native-audio-api 0.11.0-nightly-141c86f-20251118 → 0.11.0-nightly-4e6f25c-20251119

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;
@@ -61,17 +59,14 @@ void AudioParam::setValueAtTime(float value, double startTime) {
     }
 
     // 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,
@@ -92,24 +87,19 @@ void AudioParam::linearRampToValueAtTime(float value, double endTime) {
     }
 
     // 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

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

@@ -22,12 +22,15 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
-    const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry,
+    const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
@@ -71,8 +74,7 @@ std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
     std::weak_ptr<worklets::WorkletRuntime> runtime,
     bool shouldLockRuntime) {
   WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
-  auto workletSourceNode =
-      std::make_shared<WorkletSourceNode>(this, std::move(workletRunner));
+  auto workletSourceNode = std::make_shared<WorkletSourceNode>(this, std::move(workletRunner));
   nodeManager_->addSourceNode(workletSourceNode);
   return workletSourceNode;
 }
@@ -90,8 +92,7 @@ std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
   return workletNode;
 }
 
-std::shared_ptr<WorkletProcessingNode>
-BaseAudioContext::createWorkletProcessingNode(
+std::shared_ptr<WorkletProcessingNode> BaseAudioContext::createWorkletProcessingNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     std::weak_ptr<worklets::WorkletRuntime> runtime,
     bool shouldLockRuntime) {
@@ -146,26 +147,21 @@ std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
   return biquadFilter;
 }
 
-std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
-    bool pitchCorrection) {
-  auto bufferSource =
-      std::make_shared<AudioBufferSourceNode>(this, pitchCorrection);
+std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(bool pitchCorrection) {
+  auto bufferSource = std::make_shared<AudioBufferSourceNode>(this, pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
-std::shared_ptr<AudioBufferQueueSourceNode>
-BaseAudioContext::createBufferQueueSource(bool pitchCorrection) {
-  auto bufferSource =
-      std::make_shared<AudioBufferQueueSourceNode>(this, pitchCorrection);
+std::shared_ptr<AudioBufferQueueSourceNode> BaseAudioContext::createBufferQueueSource(
+    bool pitchCorrection) {
+  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(this, pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
-std::shared_ptr<AudioBuffer> BaseAudioContext::createBuffer(
-    int numberOfChannels,
-    size_t length,
-    float sampleRate) {
+std::shared_ptr<AudioBuffer>
+BaseAudioContext::createBuffer(int numberOfChannels, size_t length, float sampleRate) {
   return std::make_shared<AudioBuffer>(numberOfChannels, length, sampleRate);
 }
 
@@ -173,8 +169,7 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
     const std::vector<std::complex<float>> &complexData,
     bool disableNormalization,
     int length) {
-  return std::make_shared<PeriodicWave>(
-      sampleRate_, complexData, length, disableNormalization);
+  return std::make_shared<PeriodicWave>(sampleRate_, complexData, length, disableNormalization);
 }
 
 std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
@@ -186,8 +181,7 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
 std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(
     std::shared_ptr<AudioBuffer> buffer,
     bool disableNormalization) {
-  auto convolver =
-      std::make_shared<ConvolverNode>(this, buffer, disableNormalization);
+  auto convolver = std::make_shared<ConvolverNode>(this, buffer, disableNormalization);
   nodeManager_->addProcessingNode(convolver);
   return convolver;
 }
@@ -225,36 +219,30 @@ std::string BaseAudioContext::toString(ContextState state) {
   }
 }
 
-std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(
-    OscillatorType type) {
+std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType type) {
   switch (type) {
     case OscillatorType::SINE:
       if (cachedSineWave_ == nullptr) {
-        cachedSineWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        cachedSineWave_ = std::make_shared<PeriodicWave>(sampleRate_, type, false);
       }
       return cachedSineWave_;
     case OscillatorType::SQUARE:
       if (cachedSquareWave_ == nullptr) {
-        cachedSquareWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        cachedSquareWave_ = std::make_shared<PeriodicWave>(sampleRate_, type, false);
       }
       return cachedSquareWave_;
     case OscillatorType::SAWTOOTH:
       if (cachedSawtoothWave_ == nullptr) {
-        cachedSawtoothWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        cachedSawtoothWave_ = std::make_shared<PeriodicWave>(sampleRate_, type, false);
       }
       return cachedSawtoothWave_;
     case OscillatorType::TRIANGLE:
       if (cachedTriangleWave_ == nullptr) {
-        cachedTriangleWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        cachedTriangleWave_ = std::make_shared<PeriodicWave>(sampleRate_, type, false);
       }
       return cachedTriangleWave_;
     case OscillatorType::CUSTOM:
-      throw std::invalid_argument(
-          "You can't get a custom wave form. You need to create it.");
+      throw std::invalid_argument("You can't get a custom wave form. You need to create it.");
       break;
   }
 }

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

@@ -38,7 +38,9 @@ class StreamerNode;
 
 class BaseAudioContext {
  public:
-  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
+  explicit BaseAudioContext(
+      const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const RuntimeRegistry &runtimeRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -49,19 +51,19 @@ class BaseAudioContext {
 
   std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
   std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    bool shouldLockRuntime = true);
+      std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
+      bool shouldLockRuntime = true);
   std::shared_ptr<WorkletNode> createWorkletNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    size_t bufferLength,
-    size_t inputChannelCount,
-    bool shouldLockRuntime = true);
+      std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
+      size_t bufferLength,
+      size_t inputChannelCount,
+      bool shouldLockRuntime = true);
   std::shared_ptr<WorkletProcessingNode> createWorkletProcessingNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    bool shouldLockRuntime = true);
+      std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
+      bool shouldLockRuntime = true);
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();
@@ -77,7 +79,9 @@ class BaseAudioContext {
       bool disableNormalization,
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
-  std::shared_ptr<ConvolverNode> createConvolver(std::shared_ptr<AudioBuffer> buffer, bool disableNormalization);
+  std::shared_ptr<ConvolverNode> createConvolver(
+      std::shared_ptr<AudioBuffer> buffer,
+      bool disableNormalization);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
@@ -105,8 +109,8 @@ class BaseAudioContext {
   [[nodiscard]] virtual bool isDriverRunning() const = 0;
 
  public:
-    std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
-    RuntimeRegistry runtimeRegistry_;
+  std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  RuntimeRegistry runtimeRegistry_;
 };
 
 } // namespace audioapi

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

@@ -12,6 +12,7 @@
 #include <algorithm>
 #include <cassert>
 #include <iostream>
+#include <memory>
 #include <thread>
 #include <utility>
 
@@ -21,16 +22,15 @@ OfflineAudioContext::OfflineAudioContext(
     int numberOfChannels,
     size_t length,
     float sampleRate,
-    const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry,
+    const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry)
     : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {
   sampleRate_ = sampleRate;
-  resultBus_ = std::make_shared<AudioBus>(
-      static_cast<int>(length_), numberOfChannels_, sampleRate_);
+  resultBus_ =
+      std::make_shared<AudioBus>(static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }
 
 OfflineAudioContext::~OfflineAudioContext() {
@@ -47,21 +47,18 @@ void OfflineAudioContext::resume() {
   renderAudio();
 }
 
-void OfflineAudioContext::suspend(
-    double when,
-    const std::function<void()> &callback) {
+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);
+  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)");
+        "cannot schedule more than one suspend at frame " + std::to_string(frame) + " (" +
+        std::to_string(when) + " seconds)");
   }
 
   scheduledSuspends_.emplace(frame, callback);
@@ -70,13 +67,12 @@ void OfflineAudioContext::suspend(
 void OfflineAudioContext::renderAudio() {
   state_ = ContextState::RUNNING;
   std::thread([this]() {
-    auto audioBus = std::make_shared<AudioBus>(
-        RENDER_QUANTUM_SIZE, numberOfChannels_, sampleRate_);
+    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);
+      int framesToProcess =
+          std::min(static_cast<int>(length_ - currentSampleFrame_), RENDER_QUANTUM_SIZE);
 
       destination_->renderAudio(audioBus, framesToProcess);
 
@@ -107,8 +103,7 @@ void OfflineAudioContext::renderAudio() {
   }).detach();
 }
 
-void OfflineAudioContext::startRendering(
-    OfflineAudioContextResultCallback callback) {
+void OfflineAudioContext::startRendering(OfflineAudioContextResultCallback callback) {
   Locker locker(mutex_);
 
   resultCallback_ = std::move(callback);

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

@@ -1,12 +1,12 @@
 #pragma once
 
-#include "BaseAudioContext.h"
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include "BaseAudioContext.h"
 
-#include <mutex>
 #include <map>
-#include <unordered_map>
 #include <memory>
+#include <mutex>
+#include <unordered_map>
 
 namespace audioapi {
 
@@ -15,11 +15,16 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
+  explicit OfflineAudioContext(
+      int numberOfChannels,
+      size_t length,
+      float sampleRate,
+      const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const RuntimeRegistry &runtimeRegistry);
   ~OfflineAudioContext() override;
 
   void resume();
-  void suspend(double when, const OfflineAudioContextSuspendCallback& callback);
+  void suspend(double when, const OfflineAudioContextSuspendCallback &callback);
 
   void startRendering(OfflineAudioContextResultCallback callback);