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

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

@@ -1,4 +1,3 @@
-#include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/libs/base64/base64.h>
@@ -6,28 +5,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<float> AudioDecoder::readAllPcmFrames(
+std::vector<int16_t> AudioDecoder::readAllPcmFrames(
     ma_decoder &decoder,
-    int outputChannels) {
-  std::vector<float> buffer;
-  std::vector<float> temp(CHUNK_SIZE * outputChannels);
-  ma_uint64 outFramesRead = 0;
+    int numChannels,
+    ma_uint64 &outFramesRead) {
+  std::vector<int16_t> buffer;
+  std::vector<int16_t> temp(CHUNK_SIZE * numChannels);
+  outFramesRead = 0;
 
-#ifndef AUDIO_API_TEST_SUITE
   while (true) {
     ma_uint64 tempFramesDecoded = 0;
     ma_decoder_read_pcm_frames(
@@ -39,46 +38,38 @@ std::vector<float> AudioDecoder::readAllPcmFrames(
     buffer.insert(
         buffer.end(),
         temp.data(),
-        temp.data() + tempFramesDecoded * outputChannels);
+        temp.data() + tempFramesDecoded * numChannels);
     outFramesRead += tempFramesDecoded;
   }
 
-  if (outFramesRead == 0) {
-    __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
-  }
-#endif
   return buffer;
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
-    const std::vector<float> &buffer,
-    float outputSampleRate,
-    int outputChannels) {
-  if (buffer.empty()) {
-    return nullptr;
-  }
-
-  auto outputFrames = buffer.size() / outputChannels;
-  auto audioBus = std::make_shared<AudioBus>(
-      outputFrames, outputChannels, outputSampleRate);
+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);
 
-  for (int ch = 0; ch < outputChannels; ++ch) {
+  for (int ch = 0; ch < numChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();
     for (int i = 0; i < outputFrames; ++i) {
-      channelData[i] = buffer[i * outputChannels + ch];
+      channelData[i] = int16ToFloat(buffer[i * numChannels + ch]);
     }
   }
-  return std::make_shared<AudioBuffer>(audioBus);
+  return audioBus;
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
-    const std::string &path,
-    float sampleRate) {
+std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
+    const std::string &path) const {
 #ifndef AUDIO_API_TEST_SUITE
+  std::vector<int16_t> buffer;
   if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
-    auto buffer =
-        ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
-    if (buffer == nullptr) {
+    buffer = ffmpegdecoding::decodeWithFilePath(
+        path, numChannels_, static_cast<int>(sampleRate_));
+    if (buffer.empty()) {
       __android_log_print(
           ANDROID_LOG_ERROR,
           "AudioDecoder",
@@ -86,11 +77,11 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
           path.c_str());
       return nullptr;
     }
-    return buffer;
+    return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
   }
   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_s16, numChannels_, static_cast<int>(sampleRate_));
   ma_decoding_backend_vtable *customBackends[] = {
       ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
@@ -108,38 +99,41 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
     return nullptr;
   }
 
-  auto outputSampleRate = static_cast<float>(decoder.outputSampleRate);
-  auto outputChannels = static_cast<int>(decoder.outputChannels);
+  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;
+  }
 
-  std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(
-      buffer, outputSampleRate, outputChannels);
+  return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
 #else
   return nullptr;
 #endif
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
+std::shared_ptr<AudioBus> AudioDecoder::decodeWithMemoryBlock(
     const void *data,
-    size_t size,
-    float sampleRate) {
+    size_t size) const {
 #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) {
-    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(
-        data, size, static_cast<int>(sampleRate));
-    if (buffer == nullptr) {
+    buffer = ffmpegdecoding::decodeWithMemoryBlock(
+        data, size, numChannels_, sampleRate_);
+    if (buffer.empty()) {
       __android_log_print(
           ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg");
       return nullptr;
     }
-    return buffer;
+    return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
   }
   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_s16, numChannels_, static_cast<int>(sampleRate_));
 
   ma_decoding_backend_vtable *customBackends[] = {
       ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
@@ -157,48 +151,50 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
     return nullptr;
   }
 
-  auto outputSampleRate = static_cast<float>(decoder.outputSampleRate);
-  auto outputChannels = static_cast<int>(decoder.outputChannels);
+  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;
+  }
 
-  std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(
-      buffer, outputSampleRate, outputChannels);
+  return makeAudioBusFromInt16Buffer(buffer, numChannels_, sampleRate_);
 #else
   return nullptr;
 #endif
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(
+std::shared_ptr<AudioBus> AudioDecoder::decodeWithPCMInBase64(
     const std::string &data,
-    float inputSampleRate,
-    int inputChannelCount,
-    bool interleaved) {
+    float playbackSpeed) const {
   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 framesDecoded = decodedData.size() / 2;
 
-  auto audioBus = std::make_shared<AudioBus>(
-      numFramesDecoded, inputChannelCount, inputSampleRate);
+  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]);
+  }
 
-  for (int ch = 0; ch < inputChannelCount; ++ch) {
-    auto channelData = audioBus->getChannel(ch)->getData();
+  changePlaybackSpeedIfNeeded(buffer, framesDecoded, 1, playbackSpeed);
+  auto outputFrames = buffer.size();
 
-    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]);
-    }
+  auto audioBus =
+      std::make_shared<AudioBus>(outputFrames, numChannels_, sampleRate_);
+  auto leftChannelData = audioBus->getChannel(0)->getData();
+  auto rightChannelData = audioBus->getChannel(1)->getData();
+
+  for (size_t i = 0; i < outputFrames; ++i) {
+    auto sample = int16ToFloat(buffer[i]);
+    leftChannelData[i] = sample;
+    rightChannelData[i] = sample;
   }
-  return std::make_shared<AudioBuffer>(audioBus);
+
+  return audioBus;
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -1,16 +1,15 @@
 #pragma once
 
-#include <audioapi/HostObjects/AudioContextHostObject.h>
-#include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
-#include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
-#include <audioapi/HostObjects/utils/AudioDecoderHostObject.h>
+#include <audioapi/jsi/JsiPromise.h>
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/jsi/JsiPromise.h>
+#include <audioapi/HostObjects/AudioContextHostObject.h>
+#include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
+#include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
 
-#include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
 
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
@@ -23,46 +22,29 @@ 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);
-    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));
+    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));
   }
 
  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"),
@@ -85,14 +67,9 @@ 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);
@@ -100,11 +77,10 @@ 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"),
@@ -114,9 +90,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{
@@ -127,15 +103,9 @@ 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);
@@ -143,9 +113,8 @@ 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"),
@@ -157,37 +126,12 @@ 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);
-        });
-  }
-
-  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);
+          return jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
         });
   }
 };

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

@@ -49,7 +49,11 @@ 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, createAnalyser),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioData),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource),
+      JSI_EXPORT_FUNCTION(
+          BaseAudioContextHostObject, decodePCMAudioDataInBase64));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
@@ -262,4 +266,100 @@ 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,6 +41,9 @@ 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_;
 

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

@@ -6,6 +6,7 @@
 
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 
 namespace audioapi {
@@ -25,6 +26,7 @@ AudioContext::AudioContext(
 #endif
 
   sampleRate_ = sampleRate;
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate);
 
   if (initSuspended) {
     playerHasBeenStarted_ = false;

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

@@ -176,6 +176,41 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   return analyser;
 }
 
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
+
+  if (!audioBus) {
+    return nullptr;
+  }
+
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioData(
+    const void *data,
+    size_t size) {
+  auto audioBus = audioDecoder_->decodeWithMemoryBlock(data, size);
+
+  if (!audioBus) {
+    return nullptr;
+  }
+
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeWithPCMInBase64(
+    const std::string &data,
+    float playbackSpeed) {
+  auto audioBus = audioDecoder_->decodeWithPCMInBase64(data, playbackSpeed);
+
+  if (!audioBus) {
+    return nullptr;
+  }
+
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }