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

package/common/cpp/audioapi/HostObjects/utils/AudioDecoderHostObject.cpp

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/AudioDecoderHostObject.h>
+#include <audioapi/core/utils/AudioDecoder.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+AudioDecoderHostObject::AudioDecoderHostObject(
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+  promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithPCMInBase64),
+      JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithFilePath),
+      JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithMemoryBlock));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithMemoryBlock) {
+  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 sampleRate = args[1].getNumber();
+
+  auto promise = promiseVendor_->createPromise(
+      [data, size, sampleRate](std::shared_ptr<Promise> promise) {
+        std::thread([data, size, sampleRate, promise = std::move(promise)]() {
+          auto result =
+              AudioDecoder::decodeWithMemoryBlock(data, size, sampleRate);
+
+          if (!result) {
+            promise->reject("Failed to decode audio data.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          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(AudioDecoderHostObject, decodeWithFilePath) {
+  auto sourcePath = args[0].getString(runtime).utf8(runtime);
+  auto sampleRate = args[1].getNumber();
+
+  auto promise = promiseVendor_->createPromise(
+      [sourcePath, sampleRate](std::shared_ptr<Promise> promise) {
+        std::thread([sourcePath, sampleRate, promise = std::move(promise)]() {
+          auto result =
+              AudioDecoder::decodeWithFilePath(sourcePath, sampleRate);
+
+          if (!result) {
+            promise->reject("Failed to decode audio data source.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          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(AudioDecoderHostObject, decodeWithPCMInBase64) {
+  auto b64 = args[0].getString(runtime).utf8(runtime);
+  auto inputSampleRate = args[1].getNumber();
+  auto inputChannelCount = args[2].getNumber();
+  auto interleaved = args[3].getBool();
+
+  auto promise = promiseVendor_->createPromise(
+      [b64, inputSampleRate, inputChannelCount, interleaved](
+          std::shared_ptr<Promise> promise) {
+        std::thread([b64,
+                     inputSampleRate,
+                     inputChannelCount,
+                     interleaved,
+                     promise = std::move(promise)]() {
+          auto result = AudioDecoder::decodeWithPCMInBase64(
+              b64, inputSampleRate, inputChannelCount, interleaved);
+
+          if (!result) {
+            promise->reject("Failed to decode audio data source.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          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/utils/AudioDecoderHostObject.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/utils/AudioDecoder.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioDecoderHostObject : public JsiHostObject {
+ public:
+  explicit AudioDecoderHostObject(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
+  JSI_HOST_FUNCTION_DECL(decodeWithMemoryBlock);
+  JSI_HOST_FUNCTION_DECL(decodeWithFilePath);
+  JSI_HOST_FUNCTION_DECL(decodeWithPCMInBase64);
+
+ private:
+  std::shared_ptr<PromiseVendor> promiseVendor_;
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/utils/AudioStretcherHostObject.cpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/AudioStretcherHostObject.h>
+#include <audioapi/core/utils/AudioStretcher.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+
+AudioStretcherHostObject::AudioStretcherHostObject(
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+  promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioStretcherHostObject, changePlaybackSpeed));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioStretcherHostObject, changePlaybackSpeed) {
+  auto audioBuffer =
+      args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  auto playbackSpeed = static_cast<float>(args[1].asNumber());
+
+  auto promise = promiseVendor_->createPromise(
+      [audioBuffer, playbackSpeed](std::shared_ptr<Promise> promise) {
+        std::thread([audioBuffer,
+                     playbackSpeed,
+                     promise = std::move(promise)]() {
+          auto result = AudioStretcher::changePlaybackSpeed(
+              *audioBuffer->audioBuffer_, playbackSpeed);
+
+          if (!result) {
+            promise->reject("Failed to change audio playback speed.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          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/utils/AudioStretcherHostObject.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/utils/AudioStretcher.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioStretcherHostObject : public JsiHostObject {
+ public:
+  explicit AudioStretcherHostObject(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
+  JSI_HOST_FUNCTION_DECL(changePlaybackSpeed);
+
+ private:
+  std::shared_ptr<PromiseVendor> promiseVendor_;
+};
+} // namespace audioapi

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

@@ -6,7 +6,6 @@
 
 #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 {
@@ -26,7 +25,6 @@ AudioContext::AudioContext(
 #endif
 
   sampleRate_ = sampleRate;
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate);
 
   if (initSuspended) {
     playerHasBeenStarted_ = false;

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

@@ -176,41 +176,6 @@ 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();
 }

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

@@ -3,15 +3,14 @@
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
-
+#include <cassert>
+#include <complex>
+#include <cstddef>
 #include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
-#include <complex>
-#include <cstddef>
-#include <cassert>
 
 namespace audioapi {
 
@@ -27,7 +26,6 @@ class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
-class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
@@ -68,10 +66,6 @@ class BaseAudioContext {
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
 
-  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
-  std::shared_ptr<AudioBuffer> decodeAudioData(const void *data, size_t size);
-  std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(const std::string &data, float playbackSpeed);
-
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
   AudioNodeManager *getNodeManager();
@@ -85,9 +79,7 @@ class BaseAudioContext {
 
   std::shared_ptr<AudioDestinationNode> destination_;
   // init in AudioContext or OfflineContext constructor
-  std::shared_ptr<AudioDecoder> audioDecoder_ {};
-  // init in AudioContext or OfflineContext constructor
-  float sampleRate_ {};
+  float sampleRate_{};
   ContextState state_ = ContextState::RUNNING;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -3,7 +3,6 @@
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
@@ -30,7 +29,6 @@ OfflineAudioContext::OfflineAudioContext(
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {
   sampleRate_ = sampleRate;
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
   resultBus_ = std::make_shared<AudioBus>(
       static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp

@@ -27,10 +27,6 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
       std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
 }
 
-AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
-  clearOnPositionChangedCallback();
-}
-
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h

@@ -15,7 +15,6 @@ class AudioParam;
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferBaseSourceNode(BaseAudioContext *context, bool pitchCorrection);
-  ~AudioBufferBaseSourceNode() override;
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -29,8 +29,6 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
-
-  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -16,10 +16,6 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
   numberOfInputs_ = 0;
 }
 
-AudioScheduledSourceNode::~AudioScheduledSourceNode() {
-  clearOnEndedCallback();
-}
-
 void AudioScheduledSourceNode::start(double when) {
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -27,7 +27,6 @@ class AudioScheduledSourceNode : public AudioNode {
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
-  ~AudioScheduledSourceNode() override;
 
   void start(double when);
   virtual void stop(double when);

package/common/cpp/audioapi/core/types/AudioFormat.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace audioapi {
+
+enum class AudioFormat {
+  UNKNOWN,
+  WAV,
+  OGG,
+  FLAC,
+  AAC,
+  MP3,
+  M4A,
+  MP4,
+  MOV
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioDecoder.h

@@ -1,124 +1,67 @@
 #pragma once
 
-#include <audioapi/libs/audio-stretch/stretch.h>
+#include <audioapi/core/types/AudioFormat.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
+#include <algorithm>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <vector>
-#include <cstring>
-#include <algorithm>
 
 namespace audioapi {
 
-enum class AudioFormat {
-  UNKNOWN,
-  WAV,
-  OGG,
-  FLAC,
-  AAC,
-  MP3,
-  M4A,
-  MP4,
-  MOV
-};
-
-class AudioBus;
+class AudioBuffer;
 
 static constexpr int CHUNK_SIZE = 4096;
 
 class AudioDecoder {
  public:
-  explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
+  AudioDecoder() = delete;
 
-  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithFilePath(
-      const std::string &path) const;
-  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithMemoryBlock(
-      const void *data,
-      size_t size) const;
-  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithPCMInBase64(
-      const std::string &data,
-      float playbackSpeed) const;
+  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, float sampleRate);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer>
+  decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer>
+  decodeWithPCMInBase64(const std::string &data, float inputSampleRate, int inputChannelCount, bool interleaved);
 
  private:
-  float sampleRate_;
-  int numChannels_ = 2;
-
-  static std::vector<int16_t> readAllPcmFrames(
-      ma_decoder &decoder,
-      int numChannels,
-      ma_uint64 &outFramesRead);
-  static std::shared_ptr<AudioBus> makeAudioBusFromInt16Buffer(
-      const std::vector<int16_t> &buffer,
-      int numChannels,
-      float sampleRate);
-
-  void changePlaybackSpeedIfNeeded(
-      std::vector<int16_t> &buffer,
-      size_t framesDecoded,
-      int numChannels,
-      float playbackSpeed) const {
-    if (playbackSpeed == 1.0f) {
-      return;
-    }
-
-    auto stretcher = stretch_init(
-        static_cast<int>(sampleRate_ / 333.0f),
-        static_cast<int>(sampleRate_ / 55.0f),
-        numChannels,
-        0x1);
+  static std::vector<float> readAllPcmFrames(ma_decoder &decoder, int outputChannels);
+  static std::shared_ptr<AudioBuffer>
+  makeAudioBufferFromFloatBuffer(const std::vector<float> &buffer, float outputSampleRate, int outputChannels);
 
-    int maxOutputFrames = stretch_output_capacity(
-        stretcher, static_cast<int>(framesDecoded), 1 / playbackSpeed);
-    std::vector<int16_t> stretchedBuffer(maxOutputFrames);
-
-    int outputFrames = stretch_samples(
-        stretcher,
-        buffer.data(),
-        static_cast<int>(framesDecoded),
-        stretchedBuffer.data(),
-        1 / playbackSpeed);
-
-    outputFrames +=
-        stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
-    stretchedBuffer.resize(outputFrames);
-
-    buffer = stretchedBuffer;
-
-    stretch_deinit(stretcher);
-  }
-
-  static AudioFormat detectAudioFormat(const void* data, size_t size) {
-    if (size < 12) return AudioFormat::UNKNOWN;
-    const auto* bytes = static_cast<const unsigned char*>(data);
+  static AudioFormat detectAudioFormat(const void *data, size_t size) {
+    if (size < 12)
+      return AudioFormat::UNKNOWN;
+    const auto *bytes = static_cast<const unsigned char *>(data);
 
     // WAV/RIFF
     if (std::memcmp(bytes, "RIFF", 4) == 0 && std::memcmp(bytes + 8, "WAVE", 4) == 0)
-        return AudioFormat::WAV;
+      return AudioFormat::WAV;
 
     // OGG
     if (std::memcmp(bytes, "OggS", 4) == 0)
-        return AudioFormat::OGG;
+      return AudioFormat::OGG;
 
     // FLAC
     if (std::memcmp(bytes, "fLaC", 4) == 0)
-        return AudioFormat::FLAC;
+      return AudioFormat::FLAC;
 
     // AAC starts with 0xFF 0xF1 or 0xFF 0xF9
     if (bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0)
-        return AudioFormat::AAC;
+      return AudioFormat::AAC;
 
     // MP3: "ID3" or 11-bit frame sync (0xFF 0xE0)
     if (std::memcmp(bytes, "ID3", 3) == 0)
-        return AudioFormat::MP3;
+      return AudioFormat::MP3;
     if (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0)
-        return AudioFormat::MP3;
+      return AudioFormat::MP3;
 
     if (std::memcmp(bytes + 4, "ftyp", 4) == 0) {
-        if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
-            return AudioFormat::M4A;
-        else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
-            return AudioFormat::MOV;
-        return AudioFormat::MP4;
+      if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
+        return AudioFormat::M4A;
+      else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
+        return AudioFormat::MOV;
+      return AudioFormat::MP4;
     }
     return AudioFormat::UNKNOWN;
   }
@@ -126,19 +69,21 @@ class AudioDecoder {
   static inline bool pathHasExtension(const std::string &path, const std::vector<std::string> &extensions) {
     std::string pathLower = path;
     std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), ::tolower);
-    for (const auto& ext : extensions) {
-        if (pathLower.ends_with(ext))
-            return true;
+    for (const auto &ext : extensions) {
+      if (pathLower.ends_with(ext))
+        return true;
     }
     return false;
   }
 
-
   [[nodiscard]] static inline int16_t floatToInt16(float sample) {
-    return static_cast<int16_t>(sample * 32768.0f);
+    return static_cast<int16_t>(sample * INT16_MAX);
   }
   [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
-    return static_cast<float>(sample) / 32768.0f;
+    return static_cast<float>(sample) / INT16_MAX;
+  }
+  [[nodiscard]] static inline float uint8ToFloat(uint8_t byte1, uint8_t byte2) {
+    return static_cast<float>(static_cast<int16_t>((byte2 << 8) | byte1)) / INT16_MAX;
   }
 };