react-native-audio-api 0.8.3 → 0.9.0-nightly-96a5bcd-20251007

package/android/src/main/cpp/audioapi/android/core/{AudioDecoder.cpp → utils/AudioDecoder.cpp}

@@ -1,3 +1,4 @@
+#include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/libs/base64/base64.h>
@@ -5,28 +6,28 @@
 #include <audioapi/utils/AudioBus.h>
 
 #define MINIAUDIO_IMPLEMENTATION
+#include <audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.h>
+#include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
 #ifndef AUDIO_API_TEST_SUITE
 #include <android/log.h>
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #endif
-#include <audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.h>
-#include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
 
 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<int16_t> AudioDecoder::readAllPcmFrames(
+std::vector<float> AudioDecoder::readAllPcmFrames(
     ma_decoder &decoder,
-    int numChannels,
-    ma_uint64 &outFramesRead) {
-  std::vector<int16_t> buffer;
-  std::vector<int16_t> temp(CHUNK_SIZE * numChannels);
-  outFramesRead = 0;
+    int outputChannels) {
+  std::vector<float> buffer;
+  std::vector<float> temp(CHUNK_SIZE * outputChannels);
+  ma_uint64 outFramesRead = 0;
 
+#ifndef AUDIO_API_TEST_SUITE
   while (true) {
     ma_uint64 tempFramesDecoded = 0;
     ma_decoder_read_pcm_frames(
@@ -38,38 +39,46 @@ std::vector<int16_t> AudioDecoder::readAllPcmFrames(
     buffer.insert(
         buffer.end(),
         temp.data(),
-        temp.data() + tempFramesDecoded * numChannels);
+        temp.data() + tempFramesDecoded * outputChannels);
     outFramesRead += tempFramesDecoded;
   }
 
+  if (outFramesRead == 0) {
+    __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
+  }
+#endif
   return buffer;
 }
 
-std::shared_ptr<AudioBus> AudioDecoder::makeAudioBusFromInt16Buffer(
-    const std::vector<int16_t> &buffer,
-    int numChannels,
-    float sampleRate) {
-  auto outputFrames = buffer.size() / numChannels;
-  auto audioBus =
-      std::make_shared<AudioBus>(outputFrames, numChannels, sampleRate);
+std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
+    const std::vector<float> &buffer,
+    float outputSampleRate,
+    int outputChannels) {
+  if (buffer.empty()) {
+    return nullptr;
+  }
 
-  for (int ch = 0; ch < numChannels; ++ch) {
+  auto outputFrames = buffer.size() / outputChannels;
+  auto audioBus = std::make_shared<AudioBus>(
+      outputFrames, outputChannels, outputSampleRate);
+
+  for (int ch = 0; ch < outputChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();
     for (int i = 0; i < outputFrames; ++i) {
-      channelData[i] = int16ToFloat(buffer[i * numChannels + ch]);
+      channelData[i] = buffer[i * outputChannels + ch];
     }
   }
-  return audioBus;
+  return std::make_shared<AudioBuffer>(audioBus);
 }
 
-std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
-    const std::string &path) const {
+std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
+    const std::string &path,
+    float sampleRate) {
 #ifndef AUDIO_API_TEST_SUITE
-  std::vector<int16_t> buffer;
   if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
-    buffer = ffmpegdecoding::decodeWithFilePath(
-        path, numChannels_, static_cast<int>(sampleRate_));
-    if (buffer.empty()) {
+    auto buffer =
+        ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
+    if (buffer == nullptr) {
       __android_log_print(
           ANDROID_LOG_ERROR,
           "AudioDecoder",
@@ -77,11 +86,11 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
           path.c_str());
       return nullptr;
     }
-    return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
+    return buffer;
   }
   ma_decoder decoder;
-  ma_decoder_config config = ma_decoder_config_init(
-      ma_format_s16, numChannels_, 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};
 
@@ -99,41 +108,38 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
     return nullptr;
   }
 
-  ma_uint64 framesRead = 0;
-  buffer = readAllPcmFrames(decoder, numChannels_, framesRead);
-  if (framesRead == 0) {
-    __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
-    ma_decoder_uninit(&decoder);
-    return nullptr;
-  }
+  auto outputSampleRate = static_cast<float>(decoder.outputSampleRate);
+  auto outputChannels = static_cast<int>(decoder.outputChannels);
 
+  std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
+  return makeAudioBufferFromFloatBuffer(
+      buffer, outputSampleRate, outputChannels);
 #else
   return nullptr;
 #endif
 }
 
-std::shared_ptr<AudioBus> AudioDecoder::decodeWithMemoryBlock(
+std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
     const void *data,
-    size_t size) const {
+    size_t size,
+    float sampleRate) {
 #ifndef AUDIO_API_TEST_SUITE
-  std::vector<int16_t> buffer;
   const AudioFormat format = AudioDecoder::detectAudioFormat(data, size);
   if (format == AudioFormat::MP4 || format == AudioFormat::M4A ||
       format == AudioFormat::AAC) {
-    buffer = ffmpegdecoding::decodeWithMemoryBlock(
-        data, size, numChannels_, sampleRate_);
-    if (buffer.empty()) {
+    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");
       return nullptr;
     }
-    return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
+    return buffer;
   }
   ma_decoder decoder;
-  ma_decoder_config config = ma_decoder_config_init(
-      ma_format_s16, numChannels_, 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};
@@ -151,50 +157,48 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithMemoryBlock(
     return nullptr;
   }
 
-  ma_uint64 framesRead = 0;
-  buffer = readAllPcmFrames(decoder, numChannels_, framesRead);
-  if (framesRead == 0) {
-    __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
-    ma_decoder_uninit(&decoder);
-    return nullptr;
-  }
+  auto outputSampleRate = static_cast<float>(decoder.outputSampleRate);
+  auto outputChannels = static_cast<int>(decoder.outputChannels);
 
+  std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
+  return makeAudioBufferFromFloatBuffer(
+      buffer, outputSampleRate, outputChannels);
 #else
   return nullptr;
 #endif
 }
 
-std::shared_ptr<AudioBus> AudioDecoder::decodeWithPCMInBase64(
+std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(
     const std::string &data,
-    float playbackSpeed) const {
+    float inputSampleRate,
+    int inputChannelCount,
+    bool interleaved) {
   auto decodedData = base64_decode(data, false);
-
   const auto uint8Data = reinterpret_cast<uint8_t *>(decodedData.data());
-  size_t framesDecoded = decodedData.size() / 2;
-
-  std::vector<int16_t> buffer(framesDecoded);
-  for (size_t i = 0; i < framesDecoded; ++i) {
-    buffer[i] =
-        static_cast<int16_t>((uint8Data[i * 2 + 1] << 8) | uint8Data[i * 2]);
-  }
+  size_t numFramesDecoded =
+      decodedData.size() / (inputChannelCount * sizeof(int16_t));
 
-  changePlaybackSpeedIfNeeded(buffer, framesDecoded, 1, playbackSpeed);
-  auto outputFrames = buffer.size();
+  auto audioBus = std::make_shared<AudioBus>(
+      numFramesDecoded, inputChannelCount, inputSampleRate);
 
-  auto audioBus =
-      std::make_shared<AudioBus>(outputFrames, numChannels_, sampleRate_);
-  auto leftChannelData = audioBus->getChannel(0)->getData();
-  auto rightChannelData = audioBus->getChannel(1)->getData();
+  for (int ch = 0; ch < inputChannelCount; ++ch) {
+    auto channelData = audioBus->getChannel(ch)->getData();
 
-  for (size_t i = 0; i < outputFrames; ++i) {
-    auto sample = int16ToFloat(buffer[i]);
-    leftChannelData[i] = sample;
-    rightChannelData[i] = sample;
+    for (size_t i = 0; i < numFramesDecoded; ++i) {
+      size_t offset;
+      if (interleaved) {
+        // Ch1, Ch2, Ch1, Ch2, ...
+        offset = (i * inputChannelCount + ch) * sizeof(int16_t);
+      } else {
+        // Ch1, Ch1, Ch1, ..., Ch2, Ch2, Ch2, ...
+        offset = (ch * numFramesDecoded + i) * sizeof(int16_t);
+      }
+
+      channelData[i] = uint8ToFloat(uint8Data[offset], uint8Data[offset + 1]);
+    }
   }
-
-  return audioBus;
+  return std::make_shared<AudioBuffer>(audioBus);
 }
 
 } // namespace audioapi

package/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt

@@ -26,6 +26,7 @@ class AudioAPIModule(
   private val mHybridData: HybridData
 
   external fun initHybrid(
+    workletsModule: Any?,
     jsContext: Long,
     callInvoker: CallInvokerHolderImpl,
   ): HybridData
@@ -41,7 +42,16 @@ class AudioAPIModule(
     try {
       System.loadLibrary("react-native-audio-api")
       val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
-      mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
+
+      var workletsModule: Any? = null
+      if (BuildConfig.RN_AUDIO_API_ENABLE_WORKLETS) {
+        try {
+          workletsModule = reactContext.getNativeModule("WorkletsModule")
+        } catch (ex: Exception) {
+          throw RuntimeException("WorkletsModule not found - make sure react-native-worklets is properly installed")
+        }
+      }
+      mHybridData = initHybrid(workletsModule, reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
     } catch (exception: UnsatisfiedLinkError) {
       throw RuntimeException("Could not load native module AudioAPIModule", exception)
     }

package/android/src/main/java/com/swmansion/audioapi/core/NativeAudioRecorder.kt

@@ -0,0 +1,24 @@
+package com.swmansion.audioapi.core
+
+import com.facebook.common.internal.DoNotStrip
+import com.swmansion.audioapi.system.MediaSessionManager
+
+@DoNotStrip
+class NativeAudioRecorder {
+  private var inputNodeId: String? = null
+
+  @DoNotStrip
+  fun start() {
+    this.inputNodeId = MediaSessionManager.attachAudioRecorder(this)
+    MediaSessionManager.startForegroundServiceIfNecessary()
+  }
+
+  @DoNotStrip
+  fun stop() {
+    this.inputNodeId?.let {
+      MediaSessionManager.detachAudioRecorder(it)
+      this.inputNodeId = null
+    }
+    MediaSessionManager.stopForegroundServiceIfNecessary()
+  }
+}

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionManager.kt

@@ -21,6 +21,7 @@ import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
 import com.swmansion.audioapi.AudioAPIModule
 import com.swmansion.audioapi.core.NativeAudioPlayer
+import com.swmansion.audioapi.core.NativeAudioRecorder
 import com.swmansion.audioapi.system.PermissionRequestListener.Companion.RECORDING_REQUEST_CODE
 import java.lang.ref.WeakReference
 import java.util.UUID
@@ -42,6 +43,7 @@ object MediaSessionManager {
   private var isServiceRunning = false
   private val serviceStateLock = Any()
   private val nativeAudioPlayers = mutableMapOf<String, NativeAudioPlayer>()
+  private val nativeAudioRecorders = mutableMapOf<String, NativeAudioRecorder>()
 
   fun initialize(
     audioAPIModule: WeakReference<AudioAPIModule>,
@@ -95,14 +97,25 @@ object MediaSessionManager {
     nativeAudioPlayers.remove(uuid)
   }
 
+  fun attachAudioRecorder(recorder: NativeAudioRecorder): String {
+    val uuid = UUID.randomUUID().toString()
+    nativeAudioRecorders[uuid] = recorder
+
+    return uuid
+  }
+
+  fun detachAudioRecorder(uuid: String) {
+    nativeAudioRecorders.remove(uuid)
+  }
+
   fun startForegroundServiceIfNecessary() {
-    if (nativeAudioPlayers.isNotEmpty()) {
+    if (nativeAudioPlayers.isNotEmpty() || nativeAudioRecorders.isNotEmpty()) {
       startForegroundService()
     }
   }
 
   fun stopForegroundServiceIfNecessary() {
-    if (nativeAudioPlayers.isEmpty()) {
+    if (nativeAudioPlayers.isEmpty() && nativeAudioRecorders.isEmpty()) {
       stopForegroundService()
     }
   }

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -1,15 +1,18 @@
 #pragma once
 
-#include <audioapi/jsi/JsiPromise.h>
+#include <audioapi/HostObjects/AudioContextHostObject.h>
+#include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
+#include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
+#include <audioapi/HostObjects/utils/AudioDecoderHostObject.h>
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/HostObjects/AudioContextHostObject.h>
-#include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
-#include <audioapi/HostObjects/AudioRecorderHostObject.h>
+#include <audioapi/jsi/JsiPromise.h>
 
+#include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/events/AudioEventHandlerRegistryHostObject.h>
+
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
 
@@ -19,26 +22,52 @@ using namespace facebook;
 
 class AudioAPIModuleInstaller {
  public:
-  static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
-    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
-    auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
-    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
-
-    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
-    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
-    jsiRuntime->global().setProperty(*jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
-
-    auto audioEventHandlerRegistryHostObject = std::make_shared<AudioEventHandlerRegistryHostObject>(audioEventHandlerRegistry);
-    jsiRuntime->global().setProperty(*jsiRuntime, "AudioEventEmitter", jsi::Object::createFromHostObject(*jsiRuntime, audioEventHandlerRegistryHostObject));
+  static void injectJSIBindings(
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry,
+      std::shared_ptr<worklets::WorkletRuntime> uiRuntime = nullptr) {
+    auto createAudioContext = getCreateAudioContextFunction(
+        jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
+    auto createAudioRecorder =
+        getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(
+        jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
+    auto createAudioDecoder =
+        getCreateAudioDecoderFunction(jsiRuntime, jsCallInvoker);
+
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "createAudioContext", createAudioContext);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "createAudioRecorder", createAudioRecorder);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "createAudioDecoder", createAudioDecoder);
+
+    auto audioEventHandlerRegistryHostObject =
+        std::make_shared<AudioEventHandlerRegistryHostObject>(
+            audioEventHandlerRegistry);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime,
+        "AudioEventEmitter",
+        jsi::Object::createFromHostObject(
+            *jsiRuntime, audioEventHandlerRegistryHostObject));
   }
 
  private:
-  static jsi::Function getCreateAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateAudioContextFunction(
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry,
+      const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry](
+        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -46,40 +75,77 @@ class AudioAPIModuleInstaller {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
           auto initSuspended = args[1].getBool();
-          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry);
 
-          auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
-              audioContext, &runtime, jsCallInvoker);
+          #if RN_AUDIO_API_ENABLE_WORKLETS
+              auto runtimeRegistry = RuntimeRegistry{
+                  .uiRuntime = uiRuntime,
+                  .audioRuntime = worklets::extractWorkletRuntime(runtime, args[2])
+              };
+          #else
+              auto runtimeRegistry = RuntimeRegistry{};
+          #endif
+
+          audioContext = std::make_shared<AudioContext>(
+              sampleRate,
+              initSuspended,
+              audioEventHandlerRegistry,
+              runtimeRegistry);
+          auto audioContextHostObject =
+              std::make_shared<AudioContextHostObject>(
+                  audioContext, &runtime, jsCallInvoker);
 
           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) {
+  static jsi::Function getCreateOfflineAudioContextFunction(
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry,
+      const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry](
+        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
             size_t count) -> jsi::Value {
-            auto numberOfChannels = static_cast<int>(args[0].getNumber());
-            auto length = static_cast<size_t>(args[1].getNumber());
-            auto sampleRate = static_cast<float>(args[2].getNumber());
-
-          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry);
-          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
-              offlineAudioContext, &runtime, jsCallInvoker);
-
-          return jsi::Object::createFromHostObject(
-              runtime, audioContextHostObject);
+          auto numberOfChannels = static_cast<int>(args[0].getNumber());
+          auto length = static_cast<size_t>(args[1].getNumber());
+          auto sampleRate = static_cast<float>(args[2].getNumber());
+
+            #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) {
+  static jsi::Function getCreateAudioRecorderFunction(
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
@@ -91,12 +157,37 @@ 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>(&runtime, audioEventHandlerRegistry, sampleRate, bufferLength);
+          auto audioRecorderHostObject =
+              std::make_shared<AudioRecorderHostObject>(
+                  audioEventHandlerRegistry, sampleRate, bufferLength);
 
-          return jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
+          return jsi::Object::createFromHostObject(
+              runtime, audioRecorderHostObject);
+        });
+  }
+
+  static jsi::Function getCreateAudioDecoderFunction(
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "createAudioDecoder"),
+        0,
+        [jsCallInvoker](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto audioDecoderHostObject =
+              std::make_shared<AudioDecoderHostObject>(&runtime, jsCallInvoker);
+          return jsi::Object::createFromHostObject(
+              runtime, audioDecoderHostObject);
         });
   }
 };

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

@@ -0,0 +1,57 @@
+#include <audioapi/HostObjects/AudioContextHostObject.h>
+
+#include <audioapi/core/AudioContext.h>
+
+namespace audioapi {
+
+AudioContextHostObject::AudioContextHostObject(
+    const std::shared_ptr<AudioContext> &audioContext,
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker)
+    : BaseAudioContextHostObject(audioContext, runtime, callInvoker) {
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, close),
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, resume),
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, suspend));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
+  auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+  auto promise = promiseVendor_->createPromise(
+      [audioContext](const std::shared_ptr<Promise> &promise) {
+        audioContext->close();
+
+        promise->resolve(
+            [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+      });
+
+  return promise;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
+  auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+  auto promise = promiseVendor_->createPromise(
+      [audioContext](const std::shared_ptr<Promise> &promise) {
+        auto result = audioContext->resume();
+
+        promise->resolve(
+            [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_->createPromise(
+      [audioContext](const std::shared_ptr<Promise> &promise) {
+        auto result = audioContext->suspend();
+
+        promise->resolve(
+            [result](jsi::Runtime &runtime) { return jsi::Value(result); });
+      });
+
+  return promise;
+}
+
+} // namespace audioapi