react-native-audio-api 0.7.0-nightly-4fc09d1-20250727 → 0.7.0-nightly-a914864-20250729

package/README.md

@@ -3,7 +3,6 @@
 ### High-performance audio engine for React Native based on web audio api specification
 
 [![NPM latest](https://img.shields.io/npm/v/react-native-audio-api/latest)](https://www.npmjs.com/package/react-native-audio-api)
-[![NPM next](https://img.shields.io/npm/v/react-native-audio-api/next)](https://www.npmjs.com/package/react-native-audio-api?activeTab=versions)
 [![NPM nightly](https://img.shields.io/npm/v/react-native-audio-api/audio-api-nightly)](https://www.npmjs.com/package/react-native-audio-api?activeTab=versions)
 [![github ci](https://github.com/software-mansion/react-native-audio-api/actions/workflows/ci.yml/badge.svg)](https://github.com/software-mansion/react-native-audio-api/actions/workflows/ci.yml)
 [![NPM Audio Api publish nightly](https://github.com/software-mansion/react-native-audio-api/actions/workflows/npm-publish-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-audio-api/actions/workflows/npm-publish-nightly.yml)
@@ -40,12 +39,12 @@ check out the [Getting Started](https://docs.swmansion.com/react-native-audio-ap
 - <sub>[![Released in 0.6.0](https://img.shields.io/badge/Released_in-0.6.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.6.0)</sub> **System configuration** 🛠️ <br />
   Full control of system audio settings, remote controls, lock screen integration and most importantly configurable background modes <br />
 
+- <sub>[![Released in 0.6.0](https://img.shields.io/badge/Released_in-0.6.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.6.0)</sub> **Connect audio param** 🤞  <br />
+  Ability to connect Audio nodes to audio params, which will allow for powerful and efficient modulation of audio parameters, creating effects like tremolo, vibrato or complex envelope followers. <br />
+
 - **Microphone support** 🎙️ <br />
   Grab audio data from device microphone or connected device, connect it to the audio graph or stream through the internet <br />
 
-- **Connect audio param** 🤞 <br />
-  Ability to connect Audio nodes to audio params, which will allow for powerful and efficient modulation of audio parameters, creating effects like tremolo, vibrato or complex envelope followers. <br />
-
 - **JS Audio Worklets** 🐎 <br />
   Ability to run JS functions connected to the audio graph running on audio thread allowing for full customization of what happens to the audio signal.
   <br />

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

@@ -1,9 +1,11 @@
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #include <audioapi/core/Constants.h>
+#include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/CircularOverflowableAudioArray.h>
 
 namespace audioapi {
 
@@ -65,7 +67,7 @@ DataCallbackResult AndroidAudioRecorder::onAudioReady(
     int32_t numFrames) {
   if (isRunning_.load()) {
     auto *inputChannel = static_cast<float *>(audioData);
-    circularBuffer_->push_back(inputChannel, numFrames);
+    writeToBuffers(inputChannel, numFrames);
   }
 
   while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {

package/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp

@@ -0,0 +1,9 @@
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+// Explicitly define destructors here, as they to exist in order to act as a
+// "key function" for the audio classes - this allow for RTTI to work
+// properly across dynamic library boundaries (i.e. dynamic_cast that is used by
+// isHostObject method), android specific issue
+namespace audioapi {
+AudioNodeHostObject::~AudioNodeHostObject() = default;
+}

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

@@ -26,6 +26,8 @@ class AudioNodeHostObject : public JsiHostObject {
         JSI_EXPORT_FUNCTION(AudioNodeHostObject, disconnect));
   }
 
+  ~AudioNodeHostObject() override;
+
   JSI_PROPERTY_GETTER(numberOfInputs) {
     return {node_->getNumberOfInputs()};
   }

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

@@ -5,6 +5,7 @@
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/HostObjects/AudioBufferHostObject.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/HostObjects/RecorderAdapterNodeHostObject.h>
 
 #ifdef ANDROID
 #include <audioapi/android/core/AndroidAudioRecorder.h>
@@ -45,7 +46,22 @@ class AudioRecorderHostObject : public JsiHostObject {
 
     addFunctions(
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, start),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop));
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, connect),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect)
+    );
+  }
+
+  JSI_HOST_FUNCTION(connect) {
+    auto adapterNodeHostObject = args[0].getObject(runtime).getHostObject<RecorderAdapterNodeHostObject>(runtime);
+    audioRecorder_->connect(
+        std::static_pointer_cast<RecorderAdapterNode>(adapterNodeHostObject->node_));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(disconnect) {
+    audioRecorder_->disconnect();
+    return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(start) {

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

@@ -0,0 +1,9 @@
+#include <audioapi/HostObjects/BaseAudioContextHostObject.h>
+
+// Explicitly define destructors here, as they to exist in order to act as a
+// "key function" for the audio classes - this allow for RTTI to work
+// properly across dynamic library boundaries (i.e. dynamic_cast that is used by
+// isHostObject method), android specific issue
+namespace audioapi {
+BaseAudioContextHostObject::~BaseAudioContextHostObject() = default;
+}

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

@@ -8,12 +8,12 @@
 #include <audioapi/HostObjects/AudioDestinationNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/HostObjects/BiquadFilterNodeHostObject.h>
-#include <audioapi/HostObjects/CustomProcessorNodeHostObject.h>
 #include <audioapi/HostObjects/GainNodeHostObject.h>
 #include <audioapi/HostObjects/OscillatorNodeHostObject.h>
 #include <audioapi/HostObjects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/StereoPannerNodeHostObject.h>
 #include <audioapi/HostObjects/AnalyserNodeHostObject.h>
+#include <audioapi/HostObjects/RecorderAdapterNodeHostObject.h>
 
 #include <jsi/jsi.h>
 #include <memory>
@@ -40,8 +40,8 @@ class BaseAudioContextHostObject : public JsiHostObject {
         JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, currentTime));
 
     addFunctions(
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createRecorderAdapter),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createOscillator),
-        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createCustomProcessor),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
@@ -55,6 +55,8 @@ class BaseAudioContextHostObject : public JsiHostObject {
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodePCMAudioDataInBase64));
   }
 
+  ~BaseAudioContextHostObject() override;
+
   JSI_PROPERTY_GETTER(destination) {
     auto destination = std::make_shared<AudioDestinationNodeHostObject>(
         context_->getDestination());
@@ -73,6 +75,12 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return {context_->getCurrentTime()};
   }
 
+  JSI_HOST_FUNCTION(createRecorderAdapter) {
+    auto recorderAdapter = context_->createRecorderAdapter();
+    auto recorderAdapterHostObject = std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
+    return jsi::Object::createFromHostObject(runtime, recorderAdapterHostObject);
+  }
+
   JSI_HOST_FUNCTION(createOscillator) {
     auto oscillator = context_->createOscillator();
     auto oscillatorHostObject =
@@ -80,13 +88,6 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
   }
 
-  JSI_HOST_FUNCTION(createCustomProcessor) {
-    auto identifier = args[0].getString(runtime).utf8(runtime);
-    auto customProcessor = context_->createCustomProcessor(identifier);
-    auto customProcessorHostObject = std::make_shared<CustomProcessorNodeHostObject>(customProcessor);
-    return jsi::Object::createFromHostObject(runtime, customProcessorHostObject);
-  }
-
   JSI_HOST_FUNCTION(createGain) {
     auto gain = context_->createGain();
     auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);
@@ -115,12 +116,12 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
   }
 
-JSI_HOST_FUNCTION(createBufferQueueSource) {
-    auto bufferSource = context_->createBufferQueueSource();
-    auto bufferStreamSourceHostObject =
-            std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
-    return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
-}
+  JSI_HOST_FUNCTION(createBufferQueueSource) {
+      auto bufferSource = context_->createBufferQueueSource();
+      auto bufferStreamSourceHostObject =
+              std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
+      return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
+  }
 
   JSI_HOST_FUNCTION(createBuffer) {
     auto numberOfChannels = static_cast<int>(args[0].getNumber());
@@ -245,8 +246,9 @@ JSI_HOST_FUNCTION(createBufferQueueSource) {
         return promise;
     }
 
+    std::shared_ptr<BaseAudioContext> context_;
+
  protected:
-  std::shared_ptr<BaseAudioContext> context_;
   std::shared_ptr<PromiseVendor> promiseVendor_;
   std::shared_ptr<react::CallInvoker> callInvoker_;
 };

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioRecorderHostObject;
+
+class RecorderAdapterNodeHostObject : public AudioNodeHostObject {
+ public:
+    explicit RecorderAdapterNodeHostObject(
+        const std::shared_ptr<RecorderAdapterNode> &node)
+        : AudioNodeHostObject(node) {
+        }
+
+ private:
+    friend class AudioRecorderHostObject;
+};
+
+} // namespace audioapi

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

@@ -2,13 +2,13 @@
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
-#include <audioapi/core/effects/CustomProcessorNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
 #include <audioapi/core/sources/OscillatorNode.h>
+#include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
@@ -49,20 +49,18 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
   return destination_;
 }
 
+std::shared_ptr<RecorderAdapterNode> BaseAudioContext::createRecorderAdapter() {
+  auto recorderAdapter = std::make_shared<RecorderAdapterNode>(this);
+  nodeManager_->addProcessingNode(recorderAdapter);
+  return recorderAdapter;
+}
+
 std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
   auto oscillator = std::make_shared<OscillatorNode>(this);
   nodeManager_->addSourceNode(oscillator);
   return oscillator;
 }
 
-std::shared_ptr<CustomProcessorNode> BaseAudioContext::createCustomProcessor(
-    const std::string &identifier) {
-  auto customProcessor =
-      std::make_shared<CustomProcessorNode>(this, identifier);
-  nodeManager_->addProcessingNode(customProcessor);
-  return customProcessor;
-}
-
 std::shared_ptr<GainNode> BaseAudioContext::createGain() {
   auto gain = std::make_shared<GainNode>(this);
   nodeManager_->addProcessingNode(gain);
@@ -141,7 +139,8 @@ std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioData(
 }
 
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeWithPCMInBase64(
-    const std::string &data, float playbackSpeed) {
+    const std::string &data,
+    float playbackSpeed) {
   auto audioBus = audioDecoder_->decodeWithPCMInBase64(data, playbackSpeed);
 
   if (!audioBus) {

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

@@ -3,6 +3,7 @@
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
 
+
 #include <functional>
 #include <memory>
 #include <string>
@@ -15,7 +16,6 @@
 namespace audioapi {
 
 class AudioBus;
-class CustomProcessorNode;
 class GainNode;
 class AudioBuffer;
 class PeriodicWave;
@@ -30,6 +30,7 @@ class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
+class RecorderAdapterNode;
 
 class BaseAudioContext {
  public:
@@ -42,8 +43,8 @@ class BaseAudioContext {
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
   std::shared_ptr<AudioDestinationNode> getDestination();
 
+  std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
   std::shared_ptr<OscillatorNode> createOscillator();
-  std::shared_ptr<CustomProcessorNode> createCustomProcessor(const std::string& identifier);
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();

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

@@ -1,9 +1,11 @@
 #include <audioapi/HostObjects/AudioBufferHostObject.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/CircularOverflowableAudioArray.h>
 
 namespace audioapi {
 
@@ -14,8 +16,9 @@ AudioRecorder::AudioRecorder(
     : sampleRate_(sampleRate),
       bufferLength_(bufferLength),
       audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  circularBuffer_ =
-      std::make_shared<CircularAudioArray>(std::max(2 * bufferLength, 2048));
+  constexpr int minRingBufferSize = 8192;
+  ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
+  circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
   isRunning_.store(false);
 }
 
@@ -55,4 +58,27 @@ void AudioRecorder::sendRemainingData() {
   invokeOnAudioReadyCallback(bus, availableFrames, 0);
 }
 
+void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
+  node->init(ringBufferSize_);
+  adapterNodeLock_.lock();
+  adapterNode_ = node;
+  adapterNodeLock_.unlock();
+}
+
+void AudioRecorder::disconnect() {
+  adapterNodeLock_.lock();
+  adapterNode_ = nullptr;
+  adapterNodeLock_.unlock();
+}
+
+void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
+  if (adapterNodeLock_.try_lock()) {
+    if (adapterNode_ != nullptr) {
+      adapterNode_->buff_->write(data, numFrames);
+    }
+    adapterNodeLock_.unlock();
+  }
+  circularBuffer_->push_back(data, numFrames);
+}
+
 } // namespace audioapi

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

@@ -1,11 +1,15 @@
 #pragma once
 
+
 #include <memory>
+#include <mutex>
 #include <atomic>
 
 namespace audioapi {
+class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;
+class CircularOverflowableAudioArray;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
@@ -22,18 +26,38 @@ class AudioRecorder {
   void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames, double when);
   void sendRemainingData();
 
+  /// @brief
+  /// # Connects the recorder to the adapter node.
+  ///
+  /// The adapter node will be used to read audio data from the recorder.
+  /// @note Few frames of audio might not yet be written to the buffer when connecting.
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
+
+  /// @brief
+  /// # Disconnects the recorder from the adapter node.
+  ///
+  /// The adapter node will no longer be used to read audio data from the recorder.
+  /// @note Last few frames of audio might be written to the buffer after disconnecting.
+  void disconnect();
+
   virtual void start() = 0;
   virtual void stop() = 0;
 
  protected:
   float sampleRate_;
   int bufferLength_;
+  size_t ringBufferSize_;
 
   std::atomic<bool> isRunning_;
   std::shared_ptr<CircularAudioArray> circularBuffer_;
 
+  mutable std::mutex adapterNodeLock_;
+  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
   uint64_t onAudioReadyCallbackId_ = 0;
+
+  void writeToBuffers(const float *data, int numFrames);
 };
 
 } // namespace audioapi

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

@@ -0,0 +1,48 @@
+
+#include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <type_traits>
+
+namespace audioapi {
+
+RecorderAdapterNode::RecorderAdapterNode(BaseAudioContext *context) noexcept(
+    std::is_nothrow_constructible<AudioNode, BaseAudioContext *>::value)
+    : AudioNode(context) {
+  // It should be marked as initialized only after it is connected to the
+  // recorder. Internall buffer size is based on the recorder's buffer length.
+  isInitialized_ = false;
+}
+
+void RecorderAdapterNode::init(size_t bufferSize) {
+  if (isInitialized_) {
+    throw std::runtime_error(
+        "RecorderAdapterNode should not be initialized more than once. Just create a new instance.");
+  }
+  isInitialized_ = true;
+  buff_ = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
+}
+
+void RecorderAdapterNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  float *outputChannel = processingBus->getChannel(0)->getData();
+  readFrames(outputChannel, framesToProcess);
+
+  for (int i = 1; i < processingBus->getNumberOfChannels(); i++) {
+    processingBus->getChannel(i)->copy(
+        processingBus->getChannel(0), 0, framesToProcess);
+  }
+}
+
+void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {
+  size_t readFrames = buff_->read(output, framesToRead);
+
+  if (readFrames < framesToRead) {
+    // Fill the rest with silence
+    std::memset(
+        output + readFrames, 0, (framesToRead - readFrames) * sizeof(float));
+  }
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <memory>
+
+namespace audioapi {
+
+class AudioBus;
+
+/// @brief RecorderAdapterNode is an AudioNode which adapts push Recorder into pull graph.
+/// It uses RingBuffer to store audio data and AudioParam to provide audio data in pull mode.
+/// It is used to connect native audio recording APIs with Audio API.
+///
+/// @note it will push silence if it is not connected to any Recorder
+class RecorderAdapterNode : public AudioNode {
+ public:
+    explicit RecorderAdapterNode(BaseAudioContext *context);
+
+    /// @brief Initialize the RecorderAdapterNode with a buffer size.
+    /// @note This method should be called ONLY ONCE when the buffer size is known.
+    /// @throws std::runtime_error if the node is already initialized.
+    /// @param bufferSize The size of the buffer to be used.
+    void init(size_t bufferSize);
+
+ protected:
+    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+    std::shared_ptr<CircularOverflowableAudioArray> buff_;
+
+ private:
+    /// @brief Read audio frames from the recorder's internal adapterBuffer.
+    /// @note If `framesToRead` is greater than the number of available frames, it will fill empty space with silence.
+    /// @param output Pointer to the output buffer.
+    /// @param framesToRead Number of frames to read.
+    void readFrames(float *output, size_t framesToRead);
+
+    friend class AudioRecorder;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/jsi/AudioArrayBuffer.h

@@ -8,7 +8,7 @@ using namespace facebook;
 
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
-  AudioArrayBuffer(uint8_t *data, const size_t size): data_(data), size_(size) {}
+  AudioArrayBuffer(uint8_t *data, size_t size): data_(data), size_(size) {}
   ~AudioArrayBuffer() override = default;
 
   [[nodiscard]] size_t size() const override;

package/common/cpp/audioapi/utils/CircularOverflowableAudioArray.cpp

@@ -0,0 +1,61 @@
+#include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <type_traits>
+
+namespace audioapi {
+
+CircularOverflowableAudioArray::CircularOverflowableAudioArray(
+    size_t
+        size) noexcept(std::is_nothrow_constructible<AudioArray, size_t>::value)
+    : AudioArray(size) {}
+
+void CircularOverflowableAudioArray::write(
+    const float *data,
+    const size_t size) {
+  size_t writeIndex = vWriteIndex_.load(std::memory_order_relaxed);
+
+  if (size > size_) {
+    return; // Ignore write if size exceeds buffer size
+  }
+
+  /// Advances the read index if there is not enough space
+  readLock_.lock();
+  size_t availableSpace = (size_ + vReadIndex_ - writeIndex - 1) % size_;
+  if (size > availableSpace) {
+    vReadIndex_ = (writeIndex + size + 1) % size_;
+  }
+  readLock_.unlock();
+
+  size_t partSize = size_ - writeIndex;
+  if (size > partSize) {
+    std::memcpy(data_ + writeIndex, data, partSize * sizeof(float));
+    std::memcpy(data_, data + partSize, (size - partSize) * sizeof(float));
+  } else {
+    std::memcpy(data_ + writeIndex, data, size * sizeof(float));
+  }
+  vWriteIndex_.store((writeIndex + size) % size_, std::memory_order_relaxed);
+}
+
+size_t CircularOverflowableAudioArray::read(float *output, size_t size) const {
+  readLock_.lock();
+  size_t availableSpace = getAvailableSpace();
+  size_t readSize = std::min(size, availableSpace);
+
+  size_t partSize = size_ - vReadIndex_;
+  if (readSize > partSize) {
+    std::memcpy(output, data_ + vReadIndex_, partSize * sizeof(float));
+    std::memcpy(
+        output + partSize, data_, (readSize - partSize) * sizeof(float));
+  } else {
+    std::memcpy(output, data_ + vReadIndex_, readSize * sizeof(float));
+  }
+  vReadIndex_ = (vReadIndex_ + readSize) % size_;
+  readLock_.unlock();
+  return readSize;
+}
+
+size_t CircularOverflowableAudioArray::getAvailableSpace() const {
+  return (size_ + vWriteIndex_.load(std::memory_order_relaxed) - vReadIndex_) %
+      size_;
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/utils/CircularOverflowableAudioArray.h

@@ -0,0 +1,42 @@
+
+#pragma once
+
+#include <audioapi/utils/AudioArray.h>
+#include <stdexcept>
+#include <atomic>
+#include <mutex>
+
+namespace audioapi {
+
+/// @brief CircularOverflowableAudioArray is a circular audio array that allows for overflow.
+/// It provides a way to push data safely from one thread while reading from another.
+/// It is designed to handle cases where the write index may be updated while the read index is being read.
+/// It has read precedence, meaning that read locks are acquired before write locks.
+/// @note read can fail when there are a lot of writes and buffer is small.
+class CircularOverflowableAudioArray : public AudioArray {
+ public:
+  explicit CircularOverflowableAudioArray(size_t size);
+  CircularOverflowableAudioArray(const CircularOverflowableAudioArray &other) = default;
+  ~CircularOverflowableAudioArray() = default;
+
+  /// @brief Writes data to the circular buffer.
+  /// @note Might wait for read operation to finish if it is in progress. It ignores writes that exceed the buffer size.
+  /// @param data Pointer to the input buffer.
+  /// @param size Number of frames to write.
+  void write(const float *data, size_t size);
+
+  /// @brief Reads data from the circular buffer.
+  /// @param output Pointer to the output buffer.
+  /// @param size Number of frames to read.
+  /// @return The number of frames actually read.
+  size_t read(float *output, size_t size) const;
+
+ private:
+  std::atomic<size_t> vWriteIndex_ = { 0 };
+  mutable size_t vReadIndex_ = 0; // it is only used after acquiring readLock_
+  mutable std::mutex readLock_;
+
+  [[nodiscard]] size_t getAvailableSpace() const;
+};
+
+} // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -7,6 +7,7 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/CircularOverflowableAudioArray.h>
 #include <unordered_map>
 
 namespace audioapi {
@@ -20,7 +21,7 @@ IOSAudioRecorder::IOSAudioRecorder(
   AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames, AVAudioTime *when) {
     if (isRunning_.load()) {
       auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
-      circularBuffer_->push_back(inputChannel, numFrames);
+      writeToBuffers(inputChannel, numFrames);
     }
 
     while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {

package/ios/audioapi/ios/core/NativeAudioRecorder.m

@@ -16,6 +16,13 @@
 
     float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
 
+    if (!devicePrefferedSampleRate) {
+      NSError *error;
+      devicePrefferedSampleRate = sampleRate;
+
+      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate error:&error];
+    }
+
     self.inputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
                                                         sampleRate:devicePrefferedSampleRate
                                                           channels:1