react-native-audio-api 0.6.5-rc.1 → 0.7.0-nightly-fba4835-20250717

package/common/cpp/audioapi/core/AudioParam.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
@@ -17,10 +18,11 @@ AudioParam::AudioParam(
       minValue_(minValue),
       maxValue_(maxValue),
       context_(context),
-      audioBus_(std::make_shared<AudioBus>(
-          RENDER_QUANTUM_SIZE,
-          1,
-          context->getSampleRate())) {
+      audioBus_(
+          std::make_shared<AudioBus>(
+              RENDER_QUANTUM_SIZE,
+              1,
+              context->getSampleRate())) {
   startTime_ = 0;
   endTime_ = 0;
   startValue_ = value_;
@@ -46,11 +48,16 @@ float AudioParam::getMaxValue() const {
   return maxValue_;
 }
 
+std::mutex &AudioParam::getQueueLock() {
+  return queueLock_;
+}
+
 void AudioParam::setValue(float value) {
   value_ = std::clamp(value, minValue_, maxValue_);
 }
 
 float AudioParam::getValueAtTime(double time) {
+  Locker lock(getQueueLock());
   if (endTime_ < time && !eventsQueue_.empty()) {
     auto event = eventsQueue_.front();
     startTime_ = event.getStartTime();
@@ -83,6 +90,7 @@ void AudioParam::setValueAtTime(float value, double startTime) {
     return endValue;
   };
 
+  Locker lock(getQueueLock());
   auto event = ParamChangeEvent(
       startTime,
       startTime,
@@ -116,6 +124,7 @@ void AudioParam::linearRampToValueAtTime(float value, double endTime) {
     return endValue;
   };
 
+  Locker lock(getQueueLock());
   auto event = ParamChangeEvent(
       getQueueEndTime(),
       endTime,
@@ -150,6 +159,7 @@ void AudioParam::exponentialRampToValueAtTime(float value, double endTime) {
     return endValue;
   };
 
+  Locker lock(getQueueLock());
   auto event = ParamChangeEvent(
       getQueueEndTime(),
       endTime,
@@ -180,6 +190,7 @@ void AudioParam::setTargetAtTime(
             (startValue - target) * exp(-(time - startTime) / timeConstant));
       };
 
+  Locker lock(getQueueLock());
   auto event = ParamChangeEvent(
       startTime,
       startTime,
@@ -224,6 +235,7 @@ void AudioParam::setValueCurveAtTime(
     return endValue;
   };
 
+  Locker lock(getQueueLock());
   auto event = ParamChangeEvent(
       startTime,
       startTime + duration,
@@ -235,6 +247,7 @@ void AudioParam::setValueCurveAtTime(
 }
 
 void AudioParam::cancelScheduledValues(double cancelTime) {
+  Locker lock(getQueueLock());
   auto it = eventsQueue_.rbegin();
   while (it->getEndTime() >= cancelTime) {
     if (it->getStartTime() >= cancelTime ||
@@ -247,6 +260,7 @@ void AudioParam::cancelScheduledValues(double cancelTime) {
 }
 
 void AudioParam::cancelAndHoldAtTime(double cancelTime) {
+  Locker lock(getQueueLock());
   auto it = eventsQueue_.rbegin();
   while (it->getEndTime() >= cancelTime) {
     if (it->getStartTime() >= cancelTime) {

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

@@ -10,6 +10,7 @@
 #include <vector>
 #include <unordered_set>
 #include <cstddef>
+#include <mutex>
 
 namespace audioapi {
 
@@ -50,6 +51,7 @@ class AudioParam {
   std::deque<ParamChangeEvent> eventsQueue_;
   std::unordered_set<AudioNode *> inputNodes_;
   std::shared_ptr<AudioBus> audioBus_;
+  std::mutex queueLock_;
 
   double startTime_;
   double endTime_;
@@ -58,6 +60,7 @@ class AudioParam {
   std::function<float(double, double, float, float, double)> calculateValue_;
   std::vector<std::shared_ptr<AudioBus>> inputBuses_ = {};
 
+  std::mutex &getQueueLock();
   double getQueueEndTime();
   float getQueueEndValue();
   void updateQueue(ParamChangeEvent &event);

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

@@ -19,7 +19,7 @@
 namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
-    const std::shared_ptr<AudioEventHandlerRegistry>
+    const std::shared_ptr<IAudioEventHandlerRegistry>
         &audioEventHandlerRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
@@ -141,8 +141,8 @@ std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioData(
 }
 
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeWithPCMInBase64(
-    const std::string &data) {
-  auto audioBus = audioDecoder_->decodeWithPCMInBase64(data);
+    const std::string &data, float playbackSpeed) {
+  auto audioBus = audioDecoder_->decodeWithPCMInBase64(data, playbackSpeed);
 
   if (!audioBus) {
     return nullptr;

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

@@ -29,10 +29,11 @@ class AudioBufferQueueSourceNode;
 class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
+class IAudioEventHandlerRegistry;
 
 class BaseAudioContext {
  public:
-  explicit BaseAudioContext(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -58,7 +59,7 @@ class BaseAudioContext {
 
   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);
+  std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(const std::string &data, float playbackSpeed);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
@@ -86,7 +87,7 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
 
  public:
-    std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+    std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 
 } // namespace audioapi

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

@@ -22,7 +22,8 @@ OfflineAudioContext::OfflineAudioContext(
     int numberOfChannels,
     size_t length,
     float sampleRate,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    const std::shared_ptr<IAudioEventHandlerRegistry>
+        &audioEventHandlerRegistry)
     : BaseAudioContext(audioEventHandlerRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),

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

@@ -14,7 +14,7 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~OfflineAudioContext() override;
 
   void resume();

package/common/cpp/audioapi/core/effects/PeriodicWave.cpp

@@ -118,7 +118,7 @@ int PeriodicWave::getNumberOfPartialsPerRange(int rangeIndex) const {
   auto centsToCull = static_cast<float>(rangeIndex) * CentsPerRange;
 
   // A value from 0 -> 1 representing what fraction of the partials to keep.
-  auto cullingScale = std::powf(2, -centsToCull / 1200);
+  auto cullingScale = std::pow(2, -centsToCull / 1200);
 
   // The very top range will have all the partials culled.
   int numberOfPartials =

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <atomic>
 
 namespace audioapi {
 class AudioBus;

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

@@ -5,6 +5,7 @@
 #include <string>
 #include <vector>
 #include <cstddef>
+#include <cstring>
 
 namespace audioapi {
 

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

@@ -41,6 +41,17 @@ std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
   return playbackRateParam_;
 }
 
+void AudioBufferBaseSourceNode::clearOnPositionChangedCallback() {
+  if (onPositionChangedCallbackId_ == 0 || context_ == nullptr ||
+      context_->audioEventHandlerRegistry_ == nullptr) {
+    return;
+  }
+
+  context_->audioEventHandlerRegistry_->unregisterHandler(
+      "positionChanged", onPositionChangedCallbackId_);
+  onPositionChangedCallbackId_ = 0;
+}
+
 void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(
     uint64_t callbackId) {
   onPositionChangedCallbackId_ = callbackId;

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

@@ -4,6 +4,8 @@
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
 #include <memory>
+#include <mutex>
+#include <atomic>
 
 namespace audioapi {
 
@@ -18,6 +20,7 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
 
+  void clearOnPositionChangedCallback();
   void setOnPositionChangedCallbackId(uint64_t callbackId);
   void setOnPositionChangedInterval(int interval);
   [[nodiscard]] int getOnPositionChangedInterval();
@@ -36,7 +39,7 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
     // internal helper
     double vReadIndex_;
 
-    uint64_t onPositionChangedCallbackId_ = 0; // 0 means no callback
+    std::atomic<uint64_t> onPositionChangedCallbackId_ = 0; // 0 means no callback
     int onPositionChangedInterval_;
     int onPositionChangedTime_ = 0;
 

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

@@ -54,6 +54,17 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
+void AudioScheduledSourceNode::clearOnEndedCallback() {
+  if (onEndedCallbackId_ == 0 || context_ == nullptr ||
+      context_->audioEventHandlerRegistry_ == nullptr) {
+    return;
+  }
+
+  context_->audioEventHandlerRegistry_->unregisterHandler(
+      "ended", onEndedCallbackId_);
+  onEndedCallbackId_ = 0;
+}
+
 void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
   onEndedCallbackId_ = callbackId;
 }

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

@@ -38,6 +38,7 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
+  void clearOnEndedCallback();
   void setOnEndedCallbackId(uint64_t callbackId);
 
   void disable() override;
@@ -48,7 +49,7 @@ class AudioScheduledSourceNode : public AudioNode {
 
   PlaybackState playbackState_;
 
-  uint64_t onEndedCallbackId_ = 0;
+  std::atomic<uint64_t> onEndedCallbackId_ = 0;
 
   void updatePlaybackInfo(
       const std::shared_ptr<AudioBus>& processingBus,

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

@@ -1,7 +1,9 @@
 #pragma once
 
+#include <audioapi/libs/audio-stretch/stretch.h>
 #include <memory>
 #include <string>
+#include <vector>
 
 namespace audioapi {
 
@@ -13,10 +15,45 @@ class AudioDecoder {
 
   [[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) const;
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithPCMInBase64(const std::string &data, float playbackSpeed) const;
 
  private:
   float sampleRate_;
+  int numChannels_ = 2;
+
+  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);
+
+      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);
+  }
+
+  [[nodiscard]] static inline int16_t floatToInt16(float sample) {
+    return static_cast<int16_t>(sample * 32768.0f);
+  }
+
+  [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
+    return static_cast<float>(sample) / 32768.0f;
+  }
 };
 
 } // namespace audioapi

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

@@ -4,6 +4,7 @@
 #include <mutex>
 #include <thread>
 #include <atomic>
+#include <functional>
 #include <vector>
 #include <memory>
 

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

@@ -20,8 +20,6 @@ class AudioNodeManager {
   AudioNodeManager() = default;
   ~AudioNodeManager();
 
-  std::mutex &getGraphLock();
-
   void preProcessGraph();
 
   void addPendingNodeConnection(
@@ -62,6 +60,7 @@ class AudioNodeManager {
       ConnectionType>>
       audioParamToConnect_;
 
+  std::mutex &getGraphLock();
   void settlePendingConnections();
   void cleanupNode(const std::shared_ptr<AudioNode> &node);
   void prepareNodesForDestruction();

package/common/cpp/audioapi/dsp/AudioUtils.cpp

@@ -28,6 +28,6 @@ float linearToDecibels(float value) {
 }
 
 float decibelsToLinear(float value) {
-  return powf(10, value / 20);
+  return pow(10, value / 20);
 }
 } // namespace audioapi::dsp

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -4,7 +4,8 @@ namespace audioapi {
 
 AudioEventHandlerRegistry::AudioEventHandlerRegistry(
     jsi::Runtime *runtime,
-    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+    const std::shared_ptr<react::CallInvoker> &callInvoker)
+    : IAudioEventHandlerRegistry() {
   runtime_ = runtime;
   callInvoker_ = callInvoker;
 
@@ -91,8 +92,18 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
         continue;
       }
 
-      auto eventObject = createEventObject(body);
-      handler->call(*runtime_, eventObject);
+      try {
+        auto eventObject = createEventObject(body);
+        handler->call(*runtime_, eventObject);
+      } catch (const std::exception &e) {
+        // re-throw the exception to be handled by the caller
+        // std::exception is safe to parse by the rn bridge
+        throw;
+      } catch (...) {
+        printf(
+            "Unknown exception occurred while invoking handler for event: %s\n",
+            eventName.c_str());
+      }
     }
   });
 }
@@ -122,8 +133,26 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
       return;
     }
 
-    auto eventObject = createEventObject(body);
-    handlerIt->second->call(*runtime_, eventObject);
+    // Depending on how the AudioBufferSourceNode is handled on the JS side,
+    // it sometimes might enter race condition where the ABSN is deleted on JS
+    // side, but it is still processed on the audio thread, leading to a crash
+    // when f.e. `positionChanged` event is triggered.
+
+    // In case of debugging this, please increment the hours spent counter
+
+    // Hours spent on this: 5
+    try {
+      auto eventObject = createEventObject(body);
+      handlerIt->second->call(*runtime_, eventObject);
+    } catch (const std::exception &e) {
+      // re-throw the exception to be handled by the caller
+      // std::exception is safe to parse by the rn bridge
+      throw;
+    } catch (...) {
+      printf(
+          "Unknown exception occurred while invoking handler for event: %s\n",
+          eventName.c_str());
+    }
   });
 }
 
@@ -135,19 +164,20 @@ jsi::Object AudioEventHandlerRegistry::createEventObject(
     const auto name = pair.first.data();
     const auto &value = pair.second;
 
-    if (holds_alternative<int>(value)) {
-      eventObject.setProperty(*runtime_, name, get<int>(value));
-    } else if (holds_alternative<double>(value)) {
-      eventObject.setProperty(*runtime_, name, get<double>(value));
-    } else if (holds_alternative<float>(value)) {
-      eventObject.setProperty(*runtime_, name, get<float>(value));
-    } else if (holds_alternative<bool>(value)) {
-      eventObject.setProperty(*runtime_, name, get<bool>(value));
-    } else if (holds_alternative<std::string>(value)) {
-      eventObject.setProperty(*runtime_, name, get<std::string>(value));
-    } else if (holds_alternative<std::shared_ptr<jsi::HostObject>>(value)) {
+    if (std::holds_alternative<int>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<int>(value));
+    } else if (std::holds_alternative<double>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<double>(value));
+    } else if (std::holds_alternative<float>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<float>(value));
+    } else if (std::holds_alternative<bool>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<bool>(value));
+    } else if (std::holds_alternative<std::string>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<std::string>(value));
+    } else if (std::holds_alternative<std::shared_ptr<jsi::HostObject>>(
+                   value)) {
       auto hostObject = jsi::Object::createFromHostObject(
-          *runtime_, get<std::shared_ptr<jsi::HostObject>>(value));
+          *runtime_, std::get<std::shared_ptr<jsi::HostObject>>(value));
       eventObject.setProperty(*runtime_, name, hostObject);
     }
   }

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -2,6 +2,7 @@
 
 #include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
+#include <audioapi/events/IAudioEventHandlerRegistry.h>
 #include <memory>
 #include <unordered_map>
 #include <array>
@@ -14,18 +15,18 @@ using namespace facebook;
 
 using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
 
-class AudioEventHandlerRegistry {
+class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
  public:
   explicit AudioEventHandlerRegistry(
       jsi::Runtime *runtime,
       const std::shared_ptr<react::CallInvoker> &callInvoker);
   ~AudioEventHandlerRegistry();
 
-  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler);
-  void unregisterHandler(const std::string &eventName, uint64_t listenerId);
+  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler) override;
+  void unregisterHandler(const std::string &eventName, uint64_t listenerId) override;
 
-  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body);
-  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body);
+  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) override;
+  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) override;
 
  private:
     std::atomic<uint64_t> listenerIdCounter_{1}; // Atomic counter for listener IDs

package/common/cpp/audioapi/events/IAudioEventHandlerRegistry.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <unordered_map>
+#include <variant>
+#include <string>
+#include <memory>
+
+namespace audioapi {
+
+using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<facebook::jsi::HostObject>>;
+
+class IAudioEventHandlerRegistry {
+ public:
+  virtual ~IAudioEventHandlerRegistry() = default;
+
+  virtual uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler) = 0;
+  virtual void unregisterHandler(const std::string &eventName, uint64_t listenerId) = 0;
+
+  virtual void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) = 0;
+  virtual void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) = 0;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/jsi/JsiPromise.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/jsi/JsiPromise.h>
+#include <stdexcept>
 
 namespace audioapi {