react-native-audio-api 0.4.13 → 0.5.0

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

@@ -2,18 +2,18 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
-#include <android/log.h>
-
 #define MINIAUDIO_IMPLEMENTATION
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
+#include <android/log.h>
+
 namespace audioapi {
 
 std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
     const std::string &path) const {
   ma_decoder decoder;
   ma_decoder_config config =
-      ma_decoder_config_init(ma_format_f32, 2, sampleRate_);
+      ma_decoder_config_init(ma_format_f32, 2, static_cast<int>(sampleRate_));
   ma_result result = ma_decoder_init_file(path.c_str(), &config, &decoder);
   if (result != MA_SUCCESS) {
     __android_log_print(
@@ -37,11 +37,57 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
   ma_uint64 framesDecoded;
   ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
   if (framesDecoded == 0) {
+    __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
+
+    delete[] buffer;
+    ma_decoder_uninit(&decoder);
+
+    return nullptr;
+  }
+
+  for (int i = 0; i < decoder.outputChannels; ++i) {
+    auto channelData = audioBus->getChannel(i)->getData();
+
+    for (ma_uint64 j = 0; j < framesDecoded; ++j) {
+      channelData[j] = buffer[j * decoder.outputChannels + i];
+    }
+  }
+
+  delete[] buffer;
+  ma_decoder_uninit(&decoder);
+
+  return audioBus;
+}
+
+std::shared_ptr<AudioBus> AudioDecoder::decodeWithMemoryBlock(
+    const void *data,
+    size_t size) const {
+  ma_decoder decoder;
+  ma_decoder_config config =
+      ma_decoder_config_init(ma_format_f32, 2, static_cast<int>(sampleRate_));
+  ma_result result = ma_decoder_init_memory(data, size, &config, &decoder);
+  if (result != MA_SUCCESS) {
     __android_log_print(
         ANDROID_LOG_ERROR,
         "AudioDecoder",
-        "Failed to decode audio file: %s",
-        path.c_str());
+        "Failed to initialize decoder for memory block");
+
+    ma_decoder_uninit(&decoder);
+
+    return nullptr;
+  }
+
+  ma_uint64 totalFrameCount;
+  ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
+
+  auto audioBus = std::make_shared<AudioBus>(
+      static_cast<int>(totalFrameCount), 2, sampleRate_);
+  auto *buffer = new float[totalFrameCount * 2];
+
+  ma_uint64 framesDecoded;
+  ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
+  if (framesDecoded == 0) {
+    __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
 
     delete[] buffer;
     ma_decoder_uninit(&decoder);
@@ -62,4 +108,40 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
 
   return audioBus;
 }
+
+// std::shared_ptr<AudioBus> AudioDecoder::decode(ma_decoder &decoder) const {
+// ma_uint64 totalFrameCount;
+// ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
+//
+// auto audioBus = std::make_shared<AudioBus>(
+//         static_cast<int>(totalFrameCount), 2, sampleRate_);
+// auto *buffer = new float[totalFrameCount * 2];
+//
+// ma_uint64 framesDecoded;
+// ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount,
+// &framesDecoded); if (framesDecoded == 0) {
+//     __android_log_print(
+//             ANDROID_LOG_ERROR,
+//             "AudioDecoder",
+//             "Failed to decode");
+//
+//     delete[] buffer;
+//     ma_decoder_uninit(&decoder);
+//
+//     return nullptr;
+// }
+//
+// for (int i = 0; i < decoder.outputChannels; ++i) {
+//     auto channelData = audioBus->getChannel(i)->getData();
+//
+//     for (ma_uint64 j = 0; j < framesDecoded; ++j) {
+//         channelData[j] = buffer[j * decoder.outputChannels + i];
+//     }
+// }
+//
+// delete[] buffer;
+// ma_decoder_uninit(&decoder);
+//
+// return audioBus;
+// }
 } // namespace audioapi

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

@@ -13,10 +13,6 @@ class AudioAPIModule(
   reactContext: ReactApplicationContext,
 ) : NativeAudioAPIModuleSpec(reactContext) {
   companion object {
-    init {
-      System.loadLibrary("react-native-audio-api")
-    }
-
     const val NAME = NativeAudioAPIModuleSpec.NAME
   }
 
@@ -30,8 +26,13 @@ class AudioAPIModule(
   private external fun injectJSIBindings()
 
   init {
-    val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
-    mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
+    try {
+      System.loadLibrary("react-native-audio-api")
+      val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
+      mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
+    } catch (exception: UnsatisfiedLinkError) {
+      throw RuntimeException("Could not load native module AudioAPIModule", exception)
+    }
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)

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

@@ -1,41 +1,42 @@
 package com.swmansion.audioapi
 
 import com.facebook.react.BaseReactPackage
-import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.module.annotations.ReactModuleList
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 
-@ReactModuleList(nativeModules = [AudioAPIModule::class])
-class AudioAPIPackage :
-  BaseReactPackage(),
-  ReactPackage {
-  @UnstableReactNativeAPI
+@ReactModuleList(
+  nativeModules = [
+    AudioAPIModule::class,
+  ],
+)
+class AudioAPIPackage : BaseReactPackage() {
   override fun getModule(
     name: String,
     reactContext: ReactApplicationContext,
-  ): NativeModule? =
+  ): NativeModule? {
     when (name) {
-      AudioAPIModule.NAME -> AudioAPIModule(reactContext)
-      else -> null
+      AudioAPIModule.NAME -> return AudioAPIModule(reactContext)
     }
+    return null
+  }
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
-    ReactModuleInfoProvider(
-      fun (): Map<String, ReactModuleInfo> =
-        mapOf(
-          AudioAPIModule.NAME to
-            ReactModuleInfo(
-              AudioAPIModule.NAME,
-              AudioAPIModule::class.java.simpleName,
-              _canOverrideExistingModule = true,
-              _needsEagerInit = false,
-              isCxxModule = false,
-              isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
-            ),
-        ),
-    )
+    ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      moduleInfos[AudioAPIModule.NAME] =
+        ReactModuleInfo(
+          AudioAPIModule.NAME,
+          AudioAPIModule.NAME,
+          canOverrideExistingModule = true,
+          needsEagerInit = false,
+          hasConstants = true,
+          isCxxModule = false,
+          isTurboModule = isTurboModule,
+        )
+      moduleInfos
+    }
 }

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

@@ -73,71 +73,47 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
   }
 
   JSI_HOST_FUNCTION(getFloatFrequencyData) {
-    auto destination = args[0].getObject(runtime).asArray(runtime);
-    auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
-    auto data = new float[length];
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
 
     auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
     analyserNode->getFloatFrequencyData(data, length);
 
-    for (int i = 0; i < length; i++) {
-      destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
-    }
-
-    delete[] data;
-
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(getByteFrequencyData) {
-    auto destination = args[0].getObject(runtime).asArray(runtime);
-    auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
-    auto data = new uint8_t[length];
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = arrayBuffer.data(runtime);
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
 
     auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
     analyserNode->getByteFrequencyData(data, length);
 
-    for (int i = 0; i < length; i++) {
-      destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
-    }
-
-    delete[] data;
-
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(getFloatTimeDomainData) {
-      auto destination = args[0].getObject(runtime).asArray(runtime);
-      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
-      auto data = new float[length];
-
-      auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-      analyserNode->getFloatTimeDomainData(data, length);
-
-    for (int i = 0; i < length; i++) {
-        destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
-    }
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
 
-    delete[] data;
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getFloatTimeDomainData(data, length);
 
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(getByteTimeDomainData) {
-      auto destination = args[0].getObject(runtime).asArray(runtime);
-      auto length = static_cast<int>(destination.getProperty(runtime, "length").asNumber());
-      auto data = new uint8_t[length];
-
-      auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-      analyserNode->getByteTimeDomainData(data, length);
-
-      for (int i = 0; i < length; i++) {
-          destination.setValueAtIndex(runtime, i, jsi::Value(data[i]));
-      }
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = arrayBuffer.data(runtime);
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
 
-      delete[] data;
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getByteTimeDomainData(data, length);
 
-      return jsi::Value::undefined();
+    return jsi::Value::undefined();
   }
 
   JSI_PROPERTY_SETTER(fftSize) {

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 
 #include <jsi/jsi.h>
@@ -47,56 +48,46 @@ class AudioBufferHostObject : public JsiHostObject {
   }
 
   JSI_HOST_FUNCTION(getChannelData) {
-    int channel = static_cast<int>(args[0].getNumber());
-    float *channelData = audioBuffer_->getChannelData(channel);
-
-    auto array = jsi::Array(runtime, audioBuffer_->getLength());
-    for (int i = 0; i < audioBuffer_->getLength(); i++) {
-      array.setValueAtIndex(runtime, i, jsi::Value(channelData[i]));
-    }
-
-    return array;
+    // this method could cause a crash if channelData is already deallocated,
+    // but we handle deallocation internally so it should be safe
+    auto channel = static_cast<int>(args[0].getNumber());
+    auto channelData = reinterpret_cast<uint8_t *>(audioBuffer_->getChannelData(channel));
+    auto length = static_cast<int>(audioBuffer_->getLength());
+    auto size = static_cast<int>(length * sizeof(float));
+
+    // reading or writing from this ArrayBuffer could cause a crash
+    // if underlying channelData is deallocated
+    auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(channelData, size);
+    auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer);
+
+    auto float32ArrayCtor = runtime.global().getPropertyAsFunction(runtime, "Float32Array");
+    auto float32Array = float32ArrayCtor.callAsConstructor(runtime, arrayBuffer).getObject(runtime);
+
+    return float32Array;
   }
 
   JSI_HOST_FUNCTION(copyFromChannel) {
-    auto destination = args[0].getObject(runtime).asArray(runtime);
-    auto destinationLength =
-        static_cast<size_t>(destination.getProperty(runtime, "length").asNumber());
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto destination = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
     auto channelNumber = static_cast<int>(args[1].getNumber());
     auto startInChannel = static_cast<size_t>(args[2].getNumber());
 
-    auto *destinationData = new float[destinationLength];
-
     audioBuffer_->copyFromChannel(
-        destinationData, destinationLength, channelNumber, startInChannel);
-
-    for (int i = 0; i < destinationLength; i++) {
-      destination.setValueAtIndex(runtime, i, jsi::Value(destinationData[i]));
-    }
-
-    delete[] destinationData;
+        destination, length, channelNumber, startInChannel);
 
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(copyToChannel) {
-    auto source = args[0].getObject(runtime).asArray(runtime);
-    auto sourceLength =
-        static_cast<size_t>(source.getProperty(runtime, "length").asNumber());
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto source = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
     auto channelNumber = static_cast<int>(args[1].getNumber());
     auto startInChannel = static_cast<size_t>(args[2].getNumber());
 
-    auto *sourceData = new float[sourceLength];
-
-    for (int i = 0; i < sourceLength; i++) {
-      sourceData[i] =
-          static_cast<float>(source.getValueAtIndex(runtime, i).getNumber());
-    }
-
     audioBuffer_->copyToChannel(
-        sourceData, sourceLength, channelNumber, startInChannel);
-
-    delete[] sourceData;
+        source, length, channelNumber, startInChannel);
 
     return jsi::Value::undefined();
   }

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

@@ -24,15 +24,13 @@ class AudioBufferSourceNodeHostObject
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopStart),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopEnd),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, detune),
-        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, playbackRate),
-        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, timeStretch));
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, playbackRate));
 
     addSetters(
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loop),
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, buffer),
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopStart),
-        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopEnd),
-        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, timeStretch));
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopEnd));
 
     // start method is overridden in this class
     functions_->erase("start");
@@ -92,13 +90,6 @@ class AudioBufferSourceNodeHostObject
     return jsi::Object::createFromHostObject(runtime, playbackRateHostObject);
   }
 
-  JSI_PROPERTY_GETTER(timeStretch) {
-    auto audioBufferSourceNode =
-            std::static_pointer_cast<AudioBufferSourceNode>(node_);
-    auto timeStretch = audioBufferSourceNode->getTimeStretchType();
-    return jsi::String::createFromUtf8(runtime, timeStretch);
-  }
-
   JSI_PROPERTY_SETTER(loop) {
     auto audioBufferSourceNode =
         std::static_pointer_cast<AudioBufferSourceNode>(node_);
@@ -130,12 +121,6 @@ class AudioBufferSourceNodeHostObject
     audioBufferSourceNode->setLoopEnd(value.getNumber());
   }
 
-  JSI_PROPERTY_SETTER(timeStretch) {
-    auto audioBufferSourceNode =
-        std::static_pointer_cast<AudioBufferSourceNode>(node_);
-    audioBufferSourceNode->setTimeStretchType(value.getString(runtime).utf8(runtime));
-  }
-
   JSI_HOST_FUNCTION(start) {
     auto when = args[0].getNumber();
     auto offset = args[1].getNumber();

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

@@ -43,10 +43,15 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
     auto promise = promiseVendor_->createPromise([this](std::shared_ptr<Promise> promise) {
       std::thread([this, promise = std::move(promise)]() {
           auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-          audioContext->resume();
+          auto result = audioContext->resume();
+
+          if (!result) {
+            promise->reject("Failed to resume audio context, because it is already closed.");
+            return;
+          }
 
           promise->resolve([](jsi::Runtime &runtime) {
-              return jsi::Value::undefined();
+            return jsi::Value::undefined();
           });
       }).detach();
     });
@@ -58,10 +63,15 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
     auto promise = promiseVendor_->createPromise([this](std::shared_ptr<Promise> promise) {
       std::thread([this, promise = std::move(promise)]() {
           auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-          audioContext->suspend();
+          auto result = audioContext->suspend();
+
+          if (!result) {
+            promise->reject("Failed to resume audio context, because it is already closed.");
+            return;
+          }
 
           promise->resolve([](jsi::Runtime &runtime) {
-              return jsi::Value::undefined();
+            return jsi::Value::undefined();
           });
       }).detach();
     });

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

@@ -79,16 +79,13 @@ class AudioParamHostObject : public JsiHostObject {
   }
 
   JSI_HOST_FUNCTION(setValueCurveAtTime) {
-    auto values = args[0].getObject(runtime).asArray(runtime);
-    auto length = static_cast<size_t>(values.length(runtime));
-    auto valuesData = new float[length];
-    for (size_t i = 0; i < values.length(runtime); i++) {
-      valuesData[i] =
-          static_cast<float>(values.getValueAtIndex(runtime, i).getNumber());
-    }
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto values = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
+
     double startTime = args[1].getNumber();
     double duration = args[2].getNumber();
-    param_->setValueCurveAtTime(valuesData, length, startTime, duration);
+    param_->setValueCurveAtTime(values, length, startTime, duration);
     return jsi::Value::undefined();
   }
 

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

@@ -46,6 +46,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioData),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource));
   }
 
@@ -95,7 +96,8 @@ class BaseAudioContextHostObject : public JsiHostObject {
   }
 
   JSI_HOST_FUNCTION(createBufferSource) {
-    auto bufferSource = context_->createBufferSource();
+    auto pitchCorrection = args[0].asBool();
+    auto bufferSource = context_->createBufferSource(pitchCorrection);
     auto bufferSourceHostObject =
         std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource, callInvoker_);
     return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
@@ -111,18 +113,21 @@ class BaseAudioContextHostObject : public JsiHostObject {
   }
 
   JSI_HOST_FUNCTION(createPeriodicWave) {
-    auto real = args[0].getObject(runtime).getArray(runtime);
-    auto imag = args[1].getObject(runtime).getArray(runtime);
+    auto arrayBufferReal = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto real = reinterpret_cast<float *>(arrayBufferReal.data(runtime));
+    auto length = static_cast<int>(arrayBufferReal.size(runtime));
+
+    auto arrayBufferImag = args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto imag = reinterpret_cast<float *>(arrayBufferReal.data(runtime));
+
     auto disableNormalization = args[2].getBool();
-    auto length =
-        static_cast<int>(real.getProperty(runtime, "length").asNumber());
 
     auto complexData = std::vector<std::complex<float>>(length);
 
-    for (size_t i = 0; i < real.length(runtime); i++) {
+    for (size_t i = 0; i < length; i++) {
         complexData[i] = std::complex<float>(
-            static_cast<float>(real.getValueAtIndex(runtime, i).getNumber()),
-            static_cast<float>(imag.getValueAtIndex(runtime, i).getNumber()));
+            static_cast<float>(real[i]),
+            static_cast<float>(imag[i]));
     }
 
     auto periodicWave = context_->createPeriodicWave(
@@ -148,7 +153,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
         auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
 
         if (!results) {
-          promise->reject("Failed to decode audio data source");
+          promise->reject("Failed to decode audio data source.");
           return;
         }
 
@@ -161,6 +166,30 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return promise;
   }
 
+    JSI_HOST_FUNCTION(decodeAudioData) {
+      auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+      auto data = arrayBuffer.data(runtime);
+      auto size = static_cast<int>(arrayBuffer.size(runtime));
+
+      auto promise = promiseVendor_->createPromise([this, data, size](std::shared_ptr<Promise> promise) {
+        std::thread([this, data, size, promise = std::move(promise)]() {
+          auto results = context_->decodeAudioData(data, size);
+          auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
+
+          if (!results) {
+            promise->reject("Failed to decode audio data source.");
+            return;
+          }
+
+          promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
+            return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+          });
+        }).detach();
+      });
+
+      return promise;
+    }
+
  protected:
   std::shared_ptr<BaseAudioContext> context_;
   std::shared_ptr<PromiseVendor> promiseVendor_;

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

@@ -64,30 +64,19 @@ class BiquadFilterNodeHostObject : public AudioNodeHostObject {
   }
 
   JSI_HOST_FUNCTION(getFrequencyResponse) {
-    auto frequencyArray = args[0].getObject(runtime).asArray(runtime);
-    auto magResponseOut = args[1].getObject(runtime).asArray(runtime);
-    auto phaseResponseOut = args[2].getObject(runtime).asArray(runtime);
+    auto arrayBufferFrequency = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto frequencyArray = reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
+    auto length = static_cast<int>(arrayBufferFrequency.size(runtime));
 
-    std::vector<float> frequencyArrayVector(frequencyArray.length(runtime));
-    for (size_t i = 0; i < frequencyArray.length(runtime); i++) {
-      frequencyArrayVector[i] = static_cast<float>(
-          frequencyArray.getValueAtIndex(runtime, i).getNumber());
-    }
+    auto arrayBufferMag = args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto magResponseOut = reinterpret_cast<float *>(arrayBufferMag.data(runtime));
 
-    std::vector<float> magResponseOutVector(magResponseOut.length(runtime));
-    std::vector<float> phaseResponseOutVector(phaseResponseOut.length(runtime));
+    auto arrayBufferPhase = args[2].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto phaseResponseOut = reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
 
     auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
     biquadFilterNode->getFrequencyResponse(
-        frequencyArrayVector, magResponseOutVector, phaseResponseOutVector);
-
-    for (size_t i = 0; i < magResponseOutVector.size(); i++) {
-      magResponseOut.setValueAtIndex(runtime, i, magResponseOutVector[i]);
-    }
-
-    for (size_t i = 0; i < phaseResponseOutVector.size(); i++) {
-      phaseResponseOut.setValueAtIndex(runtime, i, phaseResponseOutVector[i]);
-    }
+        frequencyArray, magResponseOut, phaseResponseOut, length);
 
     return jsi::Value::undefined();
   }

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

@@ -39,23 +39,33 @@ AudioContext::~AudioContext() {
   if (!isClosed()) {
     close();
   }
-
-  nodeManager_->cleanup();
 }
 
 void AudioContext::close() {
   state_ = ContextState::CLOSED;
   audioPlayer_->stop();
+
+  nodeManager_->cleanup();
 }
 
-void AudioContext::resume() {
+bool AudioContext::resume() {
+  if (isClosed()) {
+    return false;
+  }
+
   state_ = ContextState::RUNNING;
   audioPlayer_->resume();
+  return true;
 }
 
-void AudioContext::suspend() {
+bool AudioContext::suspend() {
+  if (isClosed()) {
+    return false;
+  }
+
   state_ = ContextState::SUSPENDED;
   audioPlayer_->suspend();
+  return true;
 }
 
 std::function<void(std::shared_ptr<AudioBus>, int)>