react-native-audio-api 0.9.0 → 0.10.0-nightly-971a6b4-20251010

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/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -1,15 +1,17 @@
 #pragma once
 
-#include <audioapi/jsi/JsiPromise.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/inputs/AudioRecorderHostObject.h>
+#include <audioapi/HostObjects/utils/AudioDecoderHostObject.h>
+#include <audioapi/HostObjects/utils/AudioStretcherHostObject.h>
+#include <audioapi/core/AudioContext.h>
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/jsi/JsiPromise.h>
 
-#include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
@@ -22,29 +24,50 @@ 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,
-    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);
-
-    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));
+      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);
+    auto createAudioStretcher =
+        getCreateAudioStretcherFunction(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);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "createAudioStretcher", createAudioStretcher);
+
+    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,
-    const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
+      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"),
@@ -67,9 +90,14 @@ class AudioAPIModuleInstaller {
               auto runtimeRegistry = RuntimeRegistry{};
           #endif
 
-          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry, runtimeRegistry);
-          auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
-              audioContext, &runtime, jsCallInvoker);
+          audioContext = std::make_shared<AudioContext>(
+              sampleRate,
+              initSuspended,
+              audioEventHandlerRegistry,
+              runtimeRegistry);
+          auto audioContextHostObject =
+              std::make_shared<AudioContextHostObject>(
+                  audioContext, &runtime, jsCallInvoker);
 
           return jsi::Object::createFromHostObject(
               runtime, audioContextHostObject);
@@ -77,10 +105,11 @@ class AudioAPIModuleInstaller {
   }
 
   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) {
+      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"),
@@ -90,9 +119,9 @@ class AudioAPIModuleInstaller {
             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 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{
@@ -103,9 +132,15 @@ class AudioAPIModuleInstaller {
             auto runtimeRegistry = RuntimeRegistry{};
             #endif
 
-            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
-            auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
-                offlineAudioContext, &runtime, jsCallInvoker);
+            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);
@@ -113,8 +148,9 @@ class AudioAPIModuleInstaller {
   }
 
   static jsi::Function getCreateAudioRecorderFunction(
-    jsi::Runtime *jsiRuntime,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
@@ -126,12 +162,57 @@ 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);
 
-          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);
+        });
+  }
+
+  static jsi::Function getCreateAudioStretcherFunction(
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "createAudioStretcher"),
+        0,
+        [jsCallInvoker](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto audioStretcherHostObject =
+              std::make_shared<AudioStretcherHostObject>(
+                  &runtime, jsCallInvoker);
+          return jsi::Object::createFromHostObject(
+              runtime, audioStretcherHostObject);
         });
   }
 };

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

@@ -49,11 +49,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
       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),
-      JSI_EXPORT_FUNCTION(
-          BaseAudioContextHostObject, decodePCMAudioDataInBase64));
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
@@ -266,100 +262,4 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
   auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
   return jsi::Object::createFromHostObject(runtime, analyserHostObject);
 }
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, decodeAudioDataSource) {
-  auto sourcePath = args[0].getString(runtime).utf8(runtime);
-
-  auto promise = promiseVendor_->createPromise(
-      [this, sourcePath](std::shared_ptr<Promise> promise) {
-        std::thread([this, sourcePath, promise = std::move(promise)]() {
-          auto results = context_->decodeAudioDataSource(sourcePath);
-
-          if (!results) {
-            promise->reject("Failed to decode audio data source.");
-            return;
-          }
-
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(results);
-
-          promise->resolve([audioBufferHostObject = std::move(
-                                audioBufferHostObject)](jsi::Runtime &runtime) {
-            auto jsiObject = jsi::Object::createFromHostObject(
-                runtime, audioBufferHostObject);
-            jsiObject.setExternalMemoryPressure(
-                runtime, audioBufferHostObject->getSizeInBytes());
-            return jsiObject;
-          });
-        }).detach();
-      });
-
-  return promise;
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, 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);
-
-          if (!results) {
-            promise->reject("Failed to decode audio data source.");
-            return;
-          }
-
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(results);
-
-          promise->resolve([audioBufferHostObject = std::move(
-                                audioBufferHostObject)](jsi::Runtime &runtime) {
-            auto jsiObject = jsi::Object::createFromHostObject(
-                runtime, audioBufferHostObject);
-            jsiObject.setExternalMemoryPressure(
-                runtime, audioBufferHostObject->getSizeInBytes());
-            return jsiObject;
-          });
-        }).detach();
-      });
-
-  return promise;
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, decodePCMAudioDataInBase64) {
-  auto b64 = args[0].getString(runtime).utf8(runtime);
-  auto playbackSpeed = static_cast<float>(args[1].getNumber());
-
-  auto promise = promiseVendor_->createPromise(
-      [this, b64, playbackSpeed](std::shared_ptr<Promise> promise) {
-        std::thread([this, b64, playbackSpeed, promise = std::move(promise)]() {
-          auto results = context_->decodeWithPCMInBase64(b64, playbackSpeed);
-
-          if (!results) {
-            promise->reject("Failed to decode audio data source.");
-            return;
-          }
-
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(results);
-
-          promise->resolve([audioBufferHostObject = std::move(
-                                audioBufferHostObject)](jsi::Runtime &runtime) {
-            auto jsiObject = jsi::Object::createFromHostObject(
-                runtime, audioBufferHostObject);
-            jsiObject.setExternalMemoryPressure(
-                runtime, audioBufferHostObject->getSizeInBytes());
-            return jsiObject;
-          });
-        }).detach();
-      });
-
-  return promise;
-}
 } // namespace audioapi

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

@@ -41,9 +41,6 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createBuffer);
   JSI_HOST_FUNCTION_DECL(createPeriodicWave);
   JSI_HOST_FUNCTION_DECL(createAnalyser);
-  JSI_HOST_FUNCTION_DECL(decodeAudioDataSource);
-  JSI_HOST_FUNCTION_DECL(decodeAudioData);
-  JSI_HOST_FUNCTION_DECL(decodePCMAudioDataInBase64);
 
   std::shared_ptr<BaseAudioContext> context_;