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

package/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp

@@ -1,4 +1,7 @@
 #include <audioapi/android/AudioAPIModule.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace audioapi {
 
@@ -25,20 +28,16 @@ jni::local_ref<AudioAPIModule::jhybriddata> AudioAPIModule::initHybrid(
     jni::alias_ref<jhybridobject> jThis,
     jni::alias_ref<jni::JObject> jWorkletsModule,
     jlong jsContext,
-    jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
-        jsCallInvokerHolder) {
+    jni::alias_ref<facebook::react::CallInvokerHolder::javaobject> jsCallInvokerHolder) {
   auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
   auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
 #if RN_AUDIO_API_ENABLE_WORKLETS
   if (jWorkletsModule) {
-    auto castedModule =
-        jni::static_ref_cast<WorkletsModule::javaobject>(jWorkletsModule);
+    auto castedModule = jni::static_ref_cast<WorkletsModule::javaobject>(jWorkletsModule);
     auto workletsModuleProxy = castedModule->cthis()->getWorkletsModuleProxy();
-    return makeCxxInstance(
-        jThis, workletsModuleProxy, rnRuntime, jsCallInvoker);
+    return makeCxxInstance(jThis, workletsModuleProxy, rnRuntime, jsCallInvoker);
   }
-  throw std::runtime_error(
-      "Worklets module is required but not provided from Java/Kotlin side");
+  throw std::runtime_error("Worklets module is required but not provided from Java/Kotlin side");
 #else
   return makeCxxInstance(jThis, rnRuntime, jsCallInvoker);
 #endif
@@ -57,16 +56,12 @@ void AudioAPIModule::registerNatives() {
 
 void AudioAPIModule::injectJSIBindings() {
 #if RN_AUDIO_API_ENABLE_WORKLETS
-  auto uiWorkletRuntime =
-      weakWorkletsModuleProxy_.lock()->getUIWorkletRuntime();
+  auto uiWorkletRuntime = weakWorkletsModuleProxy_.lock()->getUIWorkletRuntime();
 #else
   auto uiWorkletRuntime = nullptr;
 #endif
   AudioAPIModuleInstaller::injectJSIBindings(
-      jsiRuntime_,
-      jsCallInvoker_,
-      audioEventHandlerRegistry_,
-      uiWorkletRuntime);
+      jsiRuntime_, jsCallInvoker_, audioEventHandlerRegistry_, uiWorkletRuntime);
 }
 
 void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(
@@ -98,8 +93,7 @@ void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(
   }
 
   if (audioEventHandlerRegistry_ != nullptr) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        eventName->toStdString(), body);
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(eventName->toStdString(), body);
   }
 }
 

package/android/src/main/cpp/audioapi/android/OnLoad.cpp

@@ -5,6 +5,5 @@
 using namespace audioapi;
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
-  return facebook::jni::initialize(
-      vm, [] { AudioAPIModule::registerNatives(); });
+  return facebook::jni::initialize(vm, [] { AudioAPIModule::registerNatives(); });
 }

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -7,6 +7,8 @@
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 
+#include <memory>
+
 namespace audioapi {
 
 AndroidAudioRecorder::AndroidAudioRecorder(
@@ -45,8 +47,7 @@ void AndroidAudioRecorder::start() {
   }
 
   if (mStream_) {
-    jni::ThreadScope::WithClassLoader(
-        [this]() { nativeAudioRecorder_->start(); });
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->start(); });
     mStream_->requestStart();
   }
 
@@ -61,8 +62,7 @@ void AndroidAudioRecorder::stop() {
   isRunning_.store(false);
 
   if (mStream_) {
-    jni::ThreadScope::WithClassLoader(
-        [this]() { nativeAudioRecorder_->stop(); });
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->stop(); });
     mStream_->requestStop();
   }
 

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -6,15 +6,16 @@
 #include <audioapi/utils/AudioBus.h>
 #include <jni.h>
 
+#include <algorithm>
+#include <memory>
+
 namespace audioapi {
 
 AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio),
-      sampleRate_(sampleRate),
-      channelCount_(channelCount) {
+    : renderAudio_(renderAudio), sampleRate_(sampleRate), channelCount_(channelCount) {
   isInitialized_ = openAudioStream();
 
   nativeAudioPlayer_ = jni::make_global(NativeAudioPlayer::create());
@@ -36,22 +37,17 @@ bool AudioPlayer::openAudioStream() {
   auto result = builder.openStream(mStream_);
   if (result != oboe::Result::OK || mStream_ == nullptr) {
     __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AudioPlayer",
-        "Failed to open stream: %s",
-        oboe::convertToText(result));
+        ANDROID_LOG_ERROR, "AudioPlayer", "Failed to open stream: %s", oboe::convertToText(result));
     return false;
   }
 
-  mBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
+  mBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
   return true;
 }
 
 bool AudioPlayer::start() {
   if (mStream_) {
-    jni::ThreadScope::WithClassLoader(
-        [this]() { nativeAudioPlayer_->start(); });
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->start(); });
     auto result = mStream_->requestStart();
     return result == oboe::Result::OK;
   }
@@ -94,10 +90,8 @@ bool AudioPlayer::isRunning() const {
   return mStream_ && mStream_->getState() == oboe::StreamState::Started;
 }
 
-DataCallbackResult AudioPlayer::onAudioReady(
-    AudioStream *oboeStream,
-    void *audioData,
-    int32_t numFrames) {
+DataCallbackResult
+AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numFrames) {
   if (!isInitialized_) {
     return DataCallbackResult::Continue;
   }
@@ -108,8 +102,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   assert(buffer != nullptr);
 
   while (processedFrames < numFrames) {
-    int framesToProcess =
-        std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
+    int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
     renderAudio_(mBus_, framesToProcess);
 
     // TODO: optimize this with SIMD?
@@ -126,9 +119,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   return DataCallbackResult::Continue;
 }
 
-void AudioPlayer::onErrorAfterClose(
-    oboe::AudioStream *stream,
-    oboe::Result error) {
+void AudioPlayer::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) {
   if (error == oboe::Result::ErrorDisconnected) {
     cleanup();
     if (openAudioStream()) {

package/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp

@@ -15,14 +15,16 @@
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #endif
 
+#include <memory>
+#include <string>
+#include <vector>
+
 namespace audioapi {
 
 // Decoding audio in fixed-size chunks because total frame count can't be
 // determined in advance. Note: ma_decoder_get_length_in_pcm_frames() always
 // returns 0 for Vorbis decoders.
-std::vector<float> AudioDecoder::readAllPcmFrames(
-    ma_decoder &decoder,
-    int outputChannels) {
+std::vector<float> AudioDecoder::readAllPcmFrames(ma_decoder &decoder, int outputChannels) {
   std::vector<float> buffer;
   std::vector<float> temp(CHUNK_SIZE * outputChannels);
   ma_uint64 outFramesRead = 0;
@@ -30,16 +32,12 @@ std::vector<float> AudioDecoder::readAllPcmFrames(
 #ifndef AUDIO_API_TEST_SUITE
   while (true) {
     ma_uint64 tempFramesDecoded = 0;
-    ma_decoder_read_pcm_frames(
-        &decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
+    ma_decoder_read_pcm_frames(&decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
     if (tempFramesDecoded == 0) {
       break;
     }
 
-    buffer.insert(
-        buffer.end(),
-        temp.data(),
-        temp.data() + tempFramesDecoded * outputChannels);
+    buffer.insert(buffer.end(), temp.data(), temp.data() + tempFramesDecoded * outputChannels);
     outFramesRead += tempFramesDecoded;
   }
 
@@ -59,8 +57,7 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
   }
 
   auto outputFrames = buffer.size() / outputChannels;
-  auto audioBus = std::make_shared<AudioBus>(
-      outputFrames, outputChannels, outputSampleRate);
+  auto audioBus = std::make_shared<AudioBus>(outputFrames, outputChannels, outputSampleRate);
 
   for (int ch = 0; ch < outputChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();
@@ -76,27 +73,21 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
     float sampleRate) {
 #ifndef AUDIO_API_TEST_SUITE
   if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
-    auto buffer =
-        ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
+    auto buffer = ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       __android_log_print(
-          ANDROID_LOG_ERROR,
-          "AudioDecoder",
-          "Failed to decode with FFmpeg: %s",
-          path.c_str());
+          ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg: %s", path.c_str());
       return nullptr;
     }
     return buffer;
   }
   ma_decoder decoder;
-  ma_decoder_config config =
-      ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
+  ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
   ma_decoding_backend_vtable *customBackends[] = {
       ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
-  config.customBackendCount =
-      sizeof(customBackends) / sizeof(customBackends[0]);
+  config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
 
   if (ma_decoder_init_file(path.c_str(), &config, &decoder) != MA_SUCCESS) {
     __android_log_print(
@@ -113,46 +104,36 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
 
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(
-      buffer, outputSampleRate, outputChannels);
+  return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
 #else
   return nullptr;
 #endif
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
-    const void *data,
-    size_t size,
-    float sampleRate) {
+std::shared_ptr<AudioBuffer>
+AudioDecoder::decodeWithMemoryBlock(const void *data, size_t size, float sampleRate) {
 #ifndef AUDIO_API_TEST_SUITE
   const AudioFormat format = AudioDecoder::detectAudioFormat(data, size);
-  if (format == AudioFormat::MP4 || format == AudioFormat::M4A ||
-      format == AudioFormat::AAC) {
-    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(
-        data, size, static_cast<int>(sampleRate));
+  if (format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC) {
+    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(data, size, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
-      __android_log_print(
-          ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg");
+      __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg");
       return nullptr;
     }
     return buffer;
   }
   ma_decoder decoder;
-  ma_decoder_config config =
-      ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
+  ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
 
   ma_decoding_backend_vtable *customBackends[] = {
       ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
-  config.customBackendCount =
-      sizeof(customBackends) / sizeof(customBackends[0]);
+  config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
 
   if (ma_decoder_init_memory(data, size, &config, &decoder) != MA_SUCCESS) {
     __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AudioDecoder",
-        "Failed to initialize decoder for memory block");
+        ANDROID_LOG_ERROR, "AudioDecoder", "Failed to initialize decoder for memory block");
     ma_decoder_uninit(&decoder);
     return nullptr;
   }
@@ -162,8 +143,7 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
 
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(
-      buffer, outputSampleRate, outputChannels);
+  return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
 #else
   return nullptr;
 #endif
@@ -176,11 +156,9 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(
     bool interleaved) {
   auto decodedData = base64_decode(data, false);
   const auto uint8Data = reinterpret_cast<uint8_t *>(decodedData.data());
-  size_t numFramesDecoded =
-      decodedData.size() / (inputChannelCount * sizeof(int16_t));
+  size_t numFramesDecoded = decodedData.size() / (inputChannelCount * sizeof(int16_t));
 
-  auto audioBus = std::make_shared<AudioBus>(
-      numFramesDecoded, inputChannelCount, inputSampleRate);
+  auto audioBus = std::make_shared<AudioBus>(numFramesDecoded, inputChannelCount, inputSampleRate);
 
   for (int ch = 0; ch < inputChannelCount; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -30,8 +30,7 @@ class AudioAPIModuleInstaller {
   static void injectJSIBindings(
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       std::shared_ptr<worklets::WorkletRuntime> uiRuntime = nullptr) {
     auto createAudioContext = getCreateAudioContextFunction(
         jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
@@ -39,30 +38,22 @@ class AudioAPIModuleInstaller {
         getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
     auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(
         jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
-    auto createAudioDecoder =
-        getCreateAudioDecoderFunction(jsiRuntime, jsCallInvoker);
-    auto createAudioStretcher =
-        getCreateAudioStretcherFunction(jsiRuntime, jsCallInvoker);
+    auto createAudioDecoder = getCreateAudioDecoderFunction(jsiRuntime, jsCallInvoker);
+    auto createAudioStretcher = getCreateAudioStretcherFunction(jsiRuntime, jsCallInvoker);
 
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioContext", createAudioContext);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioRecorder", createAudioRecorder);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
     jsiRuntime->global().setProperty(
         *jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioDecoder", createAudioDecoder);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioStretcher", createAudioStretcher);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioDecoder", createAudioDecoder);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioStretcher", createAudioStretcher);
 
     auto audioEventHandlerRegistryHostObject =
-        std::make_shared<AudioEventHandlerRegistryHostObject>(
-            audioEventHandlerRegistry);
+        std::make_shared<AudioEventHandlerRegistryHostObject>(audioEventHandlerRegistry);
     jsiRuntime->global().setProperty(
         *jsiRuntime,
         "AudioEventEmitter",
-        jsi::Object::createFromHostObject(
-            *jsiRuntime, audioEventHandlerRegistryHostObject));
+        jsi::Object::createFromHostObject(*jsiRuntime, audioEventHandlerRegistryHostObject));
   }
 
   static void closeAllContexts() {
@@ -74,7 +65,7 @@ class AudioAPIModuleInstaller {
       }
 
       it = contexts_.erase(it);
-    --it;
+      --it;
     }
   }
 
@@ -82,8 +73,7 @@ class AudioAPIModuleInstaller {
   static jsi::Function getCreateAudioContextFunction(
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
@@ -97,35 +87,29 @@ class AudioAPIModuleInstaller {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
 
-          #if RN_AUDIO_API_ENABLE_WORKLETS
-              auto runtimeRegistry = RuntimeRegistry{
-                  .uiRuntime = uiRuntime,
-                  .audioRuntime = worklets::extractWorkletRuntime(runtime, args[1])
-              };
-          #else
-              auto runtimeRegistry = RuntimeRegistry{};
-          #endif
+#if RN_AUDIO_API_ENABLE_WORKLETS
+          auto runtimeRegistry = RuntimeRegistry{
+              .uiRuntime = uiRuntime,
+              .audioRuntime = worklets::extractWorkletRuntime(runtime, args[1])};
+#else
+          auto runtimeRegistry = RuntimeRegistry{};
+#endif
 
           audioContext = std::make_shared<AudioContext>(
-              sampleRate,
-              audioEventHandlerRegistry,
-              runtimeRegistry);
+              sampleRate, audioEventHandlerRegistry, runtimeRegistry);
           AudioAPIModuleInstaller::contexts_.push_back(audioContext);
 
           auto audioContextHostObject =
-              std::make_shared<AudioContextHostObject>(
-                  audioContext, &runtime, jsCallInvoker);
+              std::make_shared<AudioContextHostObject>(audioContext, &runtime, jsCallInvoker);
 
-          return jsi::Object::createFromHostObject(
-              runtime, audioContextHostObject);
+          return jsi::Object::createFromHostObject(runtime, audioContextHostObject);
         });
   }
 
   static jsi::Function getCreateOfflineAudioContextFunction(
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
@@ -140,35 +124,27 @@ class AudioAPIModuleInstaller {
           auto length = static_cast<size_t>(args[1].getNumber());
           auto sampleRate = static_cast<float>(args[2].getNumber());
 
-            #if RN_AUDIO_API_ENABLE_WORKLETS
-                auto runtimeRegistry = RuntimeRegistry{
-                    .uiRuntime = uiRuntime,
-                    .audioRuntime = worklets::extractWorkletRuntime(runtime, args[3])
-                };
-            #else
-            auto runtimeRegistry = RuntimeRegistry{};
-            #endif
-
-            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(
-              numberOfChannels,
-              length,
-              sampleRate,
-              audioEventHandlerRegistry,
-              runtimeRegistry);
-
-            auto audioContextHostObject =
-              std::make_shared<OfflineAudioContextHostObject>(
-                    offlineAudioContext, &runtime, jsCallInvoker);
-
-            return jsi::Object::createFromHostObject(
-                runtime, audioContextHostObject);
+#if RN_AUDIO_API_ENABLE_WORKLETS
+          auto runtimeRegistry = RuntimeRegistry{
+              .uiRuntime = uiRuntime,
+              .audioRuntime = worklets::extractWorkletRuntime(runtime, args[3])};
+#else
+          auto runtimeRegistry = RuntimeRegistry{};
+#endif
+
+          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(
+              numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
+
+          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
+              offlineAudioContext, &runtime, jsCallInvoker);
+
+          return jsi::Object::createFromHostObject(runtime, audioContextHostObject);
         });
   }
 
   static jsi::Function getCreateAudioRecorderFunction(
       jsi::Runtime *jsiRuntime,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry) {
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
@@ -180,18 +156,15 @@ class AudioAPIModuleInstaller {
             size_t count) -> jsi::Value {
           auto options = args[0].getObject(runtime);
 
-          auto sampleRate = static_cast<float>(
-              options.getProperty(runtime, "sampleRate").getNumber());
-          auto bufferLength = static_cast<int>(
-              options.getProperty(runtime, "bufferLengthInSamples")
-                  .getNumber());
+          auto sampleRate =
+              static_cast<float>(options.getProperty(runtime, "sampleRate").getNumber());
+          auto bufferLength =
+              static_cast<int>(options.getProperty(runtime, "bufferLengthInSamples").getNumber());
 
-          auto audioRecorderHostObject =
-              std::make_shared<AudioRecorderHostObject>(
-                  audioEventHandlerRegistry, sampleRate, bufferLength);
+          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(
+              audioEventHandlerRegistry, sampleRate, bufferLength);
 
-          auto jsiObject = jsi::Object::createFromHostObject(
-              runtime, audioRecorderHostObject);
+          auto jsiObject = jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
           jsiObject.setExternalMemoryPressure(
               runtime, sizeof(float) * bufferLength); // rough estimate of underlying buffer
 
@@ -213,8 +186,7 @@ class AudioAPIModuleInstaller {
             size_t count) -> jsi::Value {
           auto audioDecoderHostObject =
               std::make_shared<AudioDecoderHostObject>(&runtime, jsCallInvoker);
-          return jsi::Object::createFromHostObject(
-              runtime, audioDecoderHostObject);
+          return jsi::Object::createFromHostObject(runtime, audioDecoderHostObject);
         });
   }
 
@@ -231,10 +203,8 @@ class AudioAPIModuleInstaller {
             const jsi::Value *args,
             size_t count) -> jsi::Value {
           auto audioStretcherHostObject =
-              std::make_shared<AudioStretcherHostObject>(
-                  &runtime, jsCallInvoker);
-          return jsi::Object::createFromHostObject(
-              runtime, audioStretcherHostObject);
+              std::make_shared<AudioStretcherHostObject>(&runtime, jsCallInvoker);
+          return jsi::Object::createFromHostObject(runtime, audioStretcherHostObject);
         });
   }
 };

package/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp

@@ -1,6 +1,8 @@
 #include <audioapi/HostObjects/AudioContextHostObject.h>
 
 #include <audioapi/core/AudioContext.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -17,38 +19,35 @@ AudioContextHostObject::AudioContextHostObject(
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createAsyncPromise(
-      [audioContext = std::move(audioContext)]() {
-        return [audioContext](jsi::Runtime &runtime) {
-          audioContext->close();
-          return jsi::Value::undefined();
-        };
-      });
+  auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
+    return [audioContext](jsi::Runtime &runtime) {
+      audioContext->close();
+      return jsi::Value::undefined();
+    };
+  });
 
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createAsyncPromise(
-      [audioContext = std::move(audioContext)]() {
-        auto result = audioContext->resume();
-        return [result](jsi::Runtime &runtime) {
-          return jsi::Value(result);
-        };
-      });
+  auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
+    auto result = audioContext->resume();
+    return [result](jsi::Runtime &runtime) {
+      return jsi::Value(result);
+    };
+  });
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, suspend) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createAsyncPromise(
-      [audioContext = std::move(audioContext)]() {
-        auto result = audioContext->suspend();
-        return [result](jsi::Runtime &runtime) {
-          return jsi::Value(result);
-        };
-      });
+  auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
+    auto result = audioContext->suspend();
+    return [result](jsi::Runtime &runtime) {
+      return jsi::Value(result);
+    };
+  });
 
   return promise;
 }

package/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp

@@ -2,11 +2,11 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/AudioNode.h>
+#include <memory>
 
 namespace audioapi {
 
-AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node)
-    : node_(node) {
+AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node) : node_(node) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfInputs),
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfOutputs),
@@ -36,8 +36,7 @@ JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCountMode) {
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
-  return jsi::String::createFromUtf8(
-      runtime, node_->getChannelInterpretation());
+  return jsi::String::createFromUtf8(runtime, node_->getChannelInterpretation());
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {