react-native-audio-api 0.12.1 → 0.12.2

package/common/cpp/audioapi/libs/miniaudio/MiniAudioDecoding.cpp

@@ -7,20 +7,31 @@
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
+#include <string>
 #include <vector>
 
 namespace audioapi::miniaudio_decoder {
 
 namespace {
 
+std::string parseMiniAudioError(ma_result result) {
+  const char *description = ma_result_description(result);
+  if (description == nullptr) {
+    return "Unknown MiniAudio error (" + std::to_string(result) + ")";
+  }
+  return std::string(description) + " (" + std::to_string(result) + ")";
+}
+
 ma_decoder_config makeDecoderConfig(const int outputSampleRate) {
   const ma_uint32 outRate =
       outputSampleRate > 0 ? static_cast<ma_uint32>(outputSampleRate) : 0;
   ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, outRate);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays)
   static ma_decoding_backend_vtable *customBackends[] = {
       ma_decoding_backend_libvorbis,
       ma_decoding_backend_libopus,
   };
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
   config.ppCustomBackendVTables = customBackends;
   config.customBackendCount =
       sizeof(customBackends) / sizeof(customBackends[0]);
@@ -79,12 +90,12 @@ float MiniAudioDecoder::getCurrentPositionInSeconds() const {
       static_cast<double>(outputSampleRate_));
 }
 
-bool MiniAudioDecoder::openFile(
+decoding::DecoderResult MiniAudioDecoder::openFile(
     int outputSampleRate,
     const std::string &path) {
   close();
   if (path.empty()) {
-    return false;
+    return Err("MiniAudioDecoder::openFile failed: path is empty");
   }
 
   ma_decoder_config config = makeDecoderConfig(outputSampleRate);
@@ -93,7 +104,7 @@ bool MiniAudioDecoder::openFile(
       ma_decoder_init_file(path.c_str(), &config, decoder_.get());
   if (result != MA_SUCCESS) {
     teardownDecoder();
-    return false;
+    return Err("MiniAudioDecoder::openFile failed: " + parseMiniAudioError(result));
   }
 
   outputChannels_ = static_cast<int>(decoder_->outputChannels);
@@ -106,16 +117,16 @@ bool MiniAudioDecoder::openFile(
     totalLengthFrames_ = 0;
   }
   totalOutputFrames_ = 0;
-  return true;
+  return Ok(None);
 }
 
-bool MiniAudioDecoder::openMemory(
+decoding::DecoderResult MiniAudioDecoder::openMemory(
     int outputSampleRate,
     const void *data,
     size_t size) {
   close();
   if (data == nullptr || size == 0) {
-    return false;
+    return Err("MiniAudioDecoder::openMemory failed: input data is empty");
   }
   memoryCopy_.assign(
       static_cast<const uint8_t *>(data),
@@ -130,7 +141,7 @@ bool MiniAudioDecoder::openMemory(
       decoder_.get());
   if (result != MA_SUCCESS) {
     teardownDecoder();
-    return false;
+    return Err("MiniAudioDecoder::openMemory failed: " + parseMiniAudioError(result));
   }
 
   outputChannels_ = static_cast<int>(decoder_->outputChannels);
@@ -143,7 +154,7 @@ bool MiniAudioDecoder::openMemory(
     totalLengthFrames_ = 0;
   }
   totalOutputFrames_ = 0;
-  return true;
+  return Ok(None);
 }
 
 size_t MiniAudioDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
@@ -160,9 +171,9 @@ size_t MiniAudioDecoder::readPcmFrames(float *outInterleaved, size_t frameCount)
   return static_cast<size_t>(framesRead);
 }
 
-bool MiniAudioDecoder::seekToTime(double seconds) {
+decoding::DecoderResult MiniAudioDecoder::seekToTime(double seconds) {
   if (!isOpen() || outputSampleRate_ <= 0) {
-    return false;
+    return Err("MiniAudioDecoder::seekToTime failed: decoder is not open");
   }
   const float dur = getDurationInSeconds();
   if (dur > 0 && std::isfinite(dur)) {
@@ -170,17 +181,18 @@ bool MiniAudioDecoder::seekToTime(double seconds) {
   } else {
     seconds = std::max(0.0, seconds);
     if (!std::isfinite(seconds)) {
-      return false;
+      return Err("MiniAudioDecoder::seekToTime failed: seconds is not finite");
     }
   }
 
   const ma_uint64 frame =
       static_cast<ma_uint64>(std::llround(seconds * static_cast<double>(outputSampleRate_)));
-  if (ma_decoder_seek_to_pcm_frame(decoder_.get(), frame) != MA_SUCCESS) {
-    return false;
+  const ma_result result = ma_decoder_seek_to_pcm_frame(decoder_.get(), frame);
+  if (result != MA_SUCCESS) {
+    return Err("MiniAudioDecoder::seekToTime failed: " + parseMiniAudioError(result));
   }
   totalOutputFrames_ = static_cast<size_t>(frame);
-  return true;
+  return Ok(None);
 }
 
 namespace {
@@ -203,14 +215,15 @@ std::shared_ptr<AudioBuffer> buildAudioBufferFromInterleaved(
 
 std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, int sample_rate) {
   MiniAudioDecoder dec;
-  if (!dec.openFile(sample_rate, path)) {
+  const auto openResult = dec.openFile(sample_rate, path);
+  if (openResult.is_err()) {
     return nullptr;
   }
   const int ch = std::max(1, dec.outputChannels());
   std::vector<float> acc;
-  std::vector<float> tmp(decoding::IIncrementalAudioDecoder::CHUNK_SIZE * static_cast<size_t>(ch));
+  std::vector<float> tmp(decoding::IncrementalAudioDecoder::CHUNK_SIZE * static_cast<size_t>(ch));
   while (true) {
-    const size_t n = dec.readPcmFrames(tmp.data(), decoding::IIncrementalAudioDecoder::CHUNK_SIZE);
+    const size_t n = dec.readPcmFrames(tmp.data(), decoding::IncrementalAudioDecoder::CHUNK_SIZE);
     if (n == 0) {
       break;
     }
@@ -224,14 +237,15 @@ std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, int sam
 
 std::shared_ptr<AudioBuffer> decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   MiniAudioDecoder dec;
-  if (!dec.openMemory(sample_rate, data, size)) {
+  const auto openResult = dec.openMemory(sample_rate, data, size);
+  if (openResult.is_err()) {
     return nullptr;
   }
   const int ch = std::max(1, dec.outputChannels());
   std::vector<float> acc;
-  std::vector<float> tmp(decoding::IIncrementalAudioDecoder::CHUNK_SIZE * static_cast<size_t>(ch));
+  std::vector<float> tmp(decoding::IncrementalAudioDecoder::CHUNK_SIZE * static_cast<size_t>(ch));
   while (true) {
-    const size_t n = dec.readPcmFrames(tmp.data(), decoding::IIncrementalAudioDecoder::CHUNK_SIZE);
+    const size_t n = dec.readPcmFrames(tmp.data(), decoding::IncrementalAudioDecoder::CHUNK_SIZE);
     if (n == 0) {
       break;
     }

package/common/cpp/audioapi/libs/miniaudio/MiniAudioDecoding.h

@@ -17,16 +17,16 @@ namespace audioapi::miniaudio_decoder {
  * MiniAudio-backed incremental decoder (Vorbis/Opus/WAV, etc. via ma_decoder + custom backends).
  * Same usage contract as ffmpegdecoder::FFmpegDecoder.
  */
-class MiniAudioDecoder : public decoding::IIncrementalAudioDecoder {
+class MiniAudioDecoder : public decoding::IncrementalAudioDecoder {
  public:
   MiniAudioDecoder();
   ~MiniAudioDecoder() override;
   DELETE_COPY_AND_MOVE(MiniAudioDecoder);
 
-  [[nodiscard]] bool openFile(
+  [[nodiscard]] decoding::DecoderResult openFile(
       int outputSampleRate,
       const std::string &path) override;
-  [[nodiscard]] bool openMemory(
+  [[nodiscard]] decoding::DecoderResult openMemory(
       int outputSampleRate,
       const void *data,
       size_t size) override;
@@ -37,7 +37,7 @@ class MiniAudioDecoder : public decoding::IIncrementalAudioDecoder {
   [[nodiscard]] int outputSampleRate() const override;
   [[nodiscard]] float getDurationInSeconds() const override;
   [[nodiscard]] float getCurrentPositionInSeconds() const override;
-  [[nodiscard]] bool seekToTime(double seconds) override;
+  [[nodiscard]] decoding::DecoderResult seekToTime(double seconds) override;
 
  private:
   void teardownDecoder();

package/common/cpp/audioapi/utils/AudioArray.hpp

@@ -195,13 +195,18 @@ class AlignedAudioArray {
 
   /// @brief Copies source array in reverse order into this array.
   /// @note Assumes source and this are in distinct, non-overlapping memory locations.
+  /// @note Precondition: length > 0. Reads source[sourceStart .. sourceStart-length+1].
   template <size_t OtherAlignment>
   void copyReverse(
       const AlignedAudioArray<OtherAlignment> &source,
       size_t sourceStart,
       size_t destinationStart,
       size_t length) {
-    if (size_ - destinationStart < length || source.size_ - sourceStart < length) [[unlikely]] {
+    // Reverse read walks from sourceStart down to sourceStart-length+1, so the source
+    // precondition is sourceStart < source.size_ on the high end and sourceStart+1 >= length
+    // on the low end. Caller must also pass length > 0.
+    if (size_ - destinationStart < length || sourceStart + 1 < length ||
+        sourceStart >= source.size_) [[unlikely]] {
       throw std::out_of_range("Not enough space to copy to destination or from source.");
     }
 

package/common/cpp/audioapi/utils/CrossThreadEventScheduler.hpp

@@ -23,7 +23,7 @@ using namespace channels::spsc;
 /// In this setup no locking happens and modifications can be seen by Audio thread.
 /// @note it is intended to be used for two threads one which schedules events and one which processes them
 /// @note it is not safe to be copied across two threads use std::shared_ptr if you need to share data
-template <typename T, int FunctionSize = 64>
+template <typename T, int FunctionSize = 72>
 class CrossThreadEventScheduler {
   using EventType = FatFunction<FunctionSize, void(T &)>;
 

package/common/cpp/audioapi/utils/TaskOffloader.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/utils/Macros.h>
 #include <audioapi/utils/SpscChannel.hpp>
 #include <cassert>
 #include <concepts>
@@ -16,7 +17,7 @@ namespace audioapi::task_offloader {
 template <std::default_initializable T, OverflowStrategy Strategy, WaitStrategy Wait>
 class TaskOffloader {
  public:
-  template <typename Func>
+  template <std::invocable<T> Func>
   explicit TaskOffloader(size_t capacity, Func &&task) : shouldRun_(true) {
     auto [sender, receiver] = channels::spsc::channel<T, Strategy, Wait>(capacity);
     sender_ = std::move(sender);
@@ -33,10 +34,7 @@ class TaskOffloader {
   }
 
   // delete other functions
-  TaskOffloader(const TaskOffloader &) = delete;
-  TaskOffloader &operator=(const TaskOffloader &) = delete;
-  TaskOffloader(TaskOffloader &&other) = delete;
-  TaskOffloader &operator=(TaskOffloader &&other) = delete;
+  DELETE_COPY_AND_MOVE(TaskOffloader);
 
   ~TaskOffloader() {
     shouldRun_.store(false, std::memory_order_release);

package/ios/audioapi/ios/AudioAPIModule.h

@@ -8,6 +8,7 @@
 
 #import <React/RCTEventEmitter.h>
 #import <audioapi/events/AudioEvent.h>
+#include <audioapi/events/AudioEventPayload.h>
 
 @class AudioEngine;
 @class SystemNotificationManager;
@@ -27,6 +28,6 @@
 @property (nonatomic, strong) NotificationRegistry *notificationRegistry;
 
 - (void)invokeHandlerWithEventName:(audioapi::AudioEvent)eventName
-                         eventBody:(NSDictionary *)eventBody;
+                           payload:(audioapi::AudioEventPayload)payload;
 
 @end

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -318,34 +318,13 @@ RCT_EXPORT_METHOD(
 #endif // RCT_NEW_ARCH_ENABLED
 
 - (void)invokeHandlerWithEventName:(audioapi::AudioEvent)eventName
-                         eventBody:(NSDictionary *)eventBody
+                           payload:(audioapi::AudioEventPayload)payload
 {
-  std::unordered_map<std::string, EventValue> body = {};
-
-  for (NSString *key in eventBody) {
-    id value = eventBody[key];
-    std::string stdKey = [key UTF8String];
-
-    if ([value isKindOfClass:[NSString class]]) {
-      std::string stdValue = [value UTF8String];
-      body[stdKey] = EventValue(stdValue);
-    } else if ([value isKindOfClass:[NSNumber class]]) {
-      const char *type = [value objCType];
-      if (strcmp(type, @encode(int)) == 0) {
-        body[stdKey] = EventValue([value intValue]);
-      } else if (strcmp(type, @encode(double)) == 0) {
-        body[stdKey] = EventValue([value doubleValue]);
-      } else if (strcmp(type, @encode(float)) == 0) {
-        body[stdKey] = EventValue([value floatValue]);
-      } else {
-        body[stdKey] = EventValue([value boolValue]);
-      }
-    }
+  if (_eventHandler == nullptr) {
+    return;
   }
 
-  if (_eventHandler != nullptr) {
-    _eventHandler->invokeHandlerWithEventBody(eventName, body);
-  }
+  _eventHandler->dispatchEvent(eventName, audioapi::kBroadcastListenerId, std::move(payload));
 }
 
 @end

package/ios/audioapi/ios/core/IOSAudioPlayer.h

@@ -4,11 +4,14 @@
 #import <NativeAudioPlayer.h>
 #else  // when compiled as C++
 typedef struct objc_object NativeAudioPlayer;
+typedef struct objc_object AudioBufferList;
 #endif // __OBJC__
 
 #include <audioapi/utils/AudioBuffer.hpp>
-#include <functional>
 
+#include <atomic>
+#include <cstddef>
+#include <functional>
 namespace audioapi {
 
 class AudioContext;
@@ -29,12 +32,23 @@ class IOSAudioPlayer {
 
   bool isRunning() const;
 
- protected:
+ private:
+  void clearPendingSaved();
+  /// Audio-thread only. Always pulls the graph in steps of RENDER_QUANTUM_SIZE; if the system
+  /// buffer size is not a multiple of 128, the unused tail of the last quantum is kept (max 128
+  /// frames) and played at the start of the next callback.
+  void deliverOutputBuffers(AudioBufferList *outputData, int numFrames);
+
   std::shared_ptr<DSPAudioBuffer> audioBuffer_;
   NativeAudioPlayer *audioPlayer_;
   std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> renderAudio_;
   int channelCount_;
   std::atomic<bool> isRunning_;
+  /// Set from main thread on start/resume; consumed on audio thread to drop stale pending audio.
+  std::atomic<bool> flushOverflowNextPull_{false};
+  /// Frames valid at the front of each `pendingSaved_[ch]` (0 … RENDER_QUANTUM_SIZE).
+  int pendingSavedCount_{0};
+  DSPAudioBuffer pendingSaved_;
 };
 
 } // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioPlayer.mm

@@ -1,10 +1,11 @@
 #import <AVFoundation/AVFoundation.h>
 
+#include <algorithm>
+#include <cstring>
+
 #include <audioapi/core/utils/Constants.h>
-#include <audioapi/dsp/VectorMath.h>
 #include <audioapi/ios/core/IOSAudioPlayer.h>
 #include <audioapi/ios/system/AudioEngine.h>
-#include <audioapi/utils/AudioArray.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 
 namespace audioapi {
@@ -13,35 +14,20 @@ IOSAudioPlayer::IOSAudioPlayer(
     const std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio), channelCount_(channelCount), audioBuffer_(0), isRunning_(false)
+    : audioBuffer_(nullptr),
+      audioPlayer_(nullptr),
+      renderAudio_(renderAudio),
+      channelCount_(channelCount),
+      isRunning_(false),
+      pendingSaved_(RENDER_QUANTUM_SIZE, channelCount_, sampleRate)
 {
   RenderAudioBlock renderAudioBlock = ^(AudioBufferList *outputData, int numFrames) {
-    int processedFrames = 0;
-
-    while (processedFrames < numFrames) {
-      int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
-
-      if (isRunning_.load(std::memory_order_acquire)) {
-        renderAudio_(audioBuffer_, framesToProcess);
-      } else {
-        audioBuffer_->zero();
-      }
-
-      for (size_t channel = 0; channel < channelCount_; channel += 1) {
-        float *outputChannel = (float *)outputData->mBuffers[channel].mData;
-
-        audioBuffer_->getChannel(channel)->copyTo(
-            outputChannel, 0, processedFrames, framesToProcess);
-      }
-
-      processedFrames += framesToProcess;
-    }
+    deliverOutputBuffers(outputData, numFrames);
   };
 
   audioPlayer_ = [[NativeAudioPlayer alloc] initWithRenderAudio:renderAudioBlock
                                                      sampleRate:sampleRate
                                                    channelCount:channelCount_];
-
   audioBuffer_ = std::make_shared<DSPAudioBuffer>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate);
 }
 
@@ -50,6 +36,80 @@ IOSAudioPlayer::~IOSAudioPlayer()
   cleanup();
 }
 
+void IOSAudioPlayer::clearPendingSaved()
+{
+  pendingSavedCount_ = 0;
+  pendingSaved_.zero();
+}
+
+void IOSAudioPlayer::deliverOutputBuffers(AudioBufferList *outputData, int numFrames)
+{
+  // If requested, clear any saved overflow before continuing normal rendering.
+  if (flushOverflowNextPull_.exchange(false, std::memory_order_acq_rel)) {
+    clearPendingSaved();
+  }
+
+  // if not running, set output to 0
+  if (!isRunning_.load(std::memory_order_acquire)) {
+    for (int channel = 0; channel < channelCount_; ++channel) {
+      auto *outputChannel = static_cast<float *>(outputData->mBuffers[channel].mData);
+      std::memset(outputChannel, 0, static_cast<size_t>(numFrames) * sizeof(float));
+    }
+    return;
+  }
+
+  int outPos = 0;
+  while (outPos < numFrames) {
+    const int need = numFrames - outPos;
+
+    if (pendingSavedCount_ > 0) {
+      const int fromPending = std::min(need, pendingSavedCount_);
+
+      // populate output with pendingSaved
+      for (int ch = 0; ch < channelCount_; ++ch) {
+        float *dst = static_cast<float *>(outputData->mBuffers[ch].mData) + outPos;
+        const float *src = pendingSaved_[ch].begin();
+        std::memcpy(dst, src, fromPending * sizeof(float));
+
+        // move the remaining samples to the beginning of the pendingSaved buffer
+        const int remain = pendingSavedCount_ - fromPending;
+        if (remain > 0) {
+          float *buf = pendingSaved_[ch].begin();
+          std::memmove(buf, buf + fromPending, remain * sizeof(float));
+        }
+      }
+
+      pendingSavedCount_ -= fromPending;
+      outPos += fromPending;
+      continue;
+    }
+
+    renderAudio_(audioBuffer_, RENDER_QUANTUM_SIZE);
+
+    // normal rendering - take RENDER_QUANTUM_SIZE frames from the graph and copy to output
+    const int stillNeed = numFrames - outPos;
+    if (stillNeed >= RENDER_QUANTUM_SIZE) {
+      for (int ch = 0; ch < channelCount_; ++ch) {
+        auto *src = (*audioBuffer_)[ch].begin();
+        float *dst = static_cast<float *>(outputData->mBuffers[ch].mData) + outPos;
+        std::memcpy(dst, src, RENDER_QUANTUM_SIZE * sizeof(float));
+      }
+      outPos += RENDER_QUANTUM_SIZE;
+    } else {
+      // when output will be sliced, copy the remaining frames to pendingSaved
+      const int tail = RENDER_QUANTUM_SIZE - stillNeed;
+      for (int ch = 0; ch < channelCount_; ++ch) {
+        auto *src = (*audioBuffer_)[ch].begin();
+        float *dst = static_cast<float *>(outputData->mBuffers[ch].mData) + outPos;
+        std::memcpy(dst, src, stillNeed * sizeof(float));
+      }
+      pendingSaved_.copy(*audioBuffer_, stillNeed, 0, tail);
+      pendingSavedCount_ = tail;
+      outPos += stillNeed;
+    }
+  }
+}
+
 bool IOSAudioPlayer::start()
 {
   if (isRunning()) {
@@ -57,6 +117,9 @@ bool IOSAudioPlayer::start()
   }
 
   bool success = [audioPlayer_ start];
+  if (success) {
+    flushOverflowNextPull_.store(true, std::memory_order_release);
+  }
   isRunning_.store(success, std::memory_order_release);
   return success;
 }
@@ -74,6 +137,9 @@ bool IOSAudioPlayer::resume()
   }
 
   bool success = [audioPlayer_ resume];
+  if (success) {
+    flushOverflowNextPull_.store(true, std::memory_order_release);
+  }
   isRunning_.store(success, std::memory_order_release);
   return success;
 }

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

@@ -322,7 +322,7 @@ Result<std::tuple<std::vector<std::string>, double, double>, std::string> IOSAud
 
     if (hadCallback) {
       callbackOutputConfigured_.store(false, std::memory_order_release);
-      dataCallback = std::move(dataCallback_);
+      dataCallback = dataCallback_;
     }
 
     if (hadConnection) {

package/ios/audioapi/ios/core/utils/IOSRecorderCallback.mm

@@ -11,6 +11,9 @@
 #include <audioapi/utils/CircularArray.hpp>
 #include <audioapi/utils/Result.hpp>
 #include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
 #include <utility>
 
 namespace audioapi {
@@ -32,17 +35,7 @@ IOSRecorderCallback::IOSRecorderCallback(
 
 IOSRecorderCallback::~IOSRecorderCallback()
 {
-  @autoreleasepool {
-    converter_ = nil;
-    bufferFormat_ = nil;
-    callbackFormat_ = nil;
-    converterInputBuffer_ = nil;
-    converterOutputBuffer_ = nil;
-
-    for (size_t i = 0; i < channelCount_; ++i) {
-      circularBuffer_[i]->zero();
-    }
-  }
+  cleanup();
 }
 
 /// @brief Prepares the IOSRecorderCallback for receiving audio data.
@@ -101,10 +94,14 @@ Result<NoneType, std::string> IOSRecorderCallback::prepare(
 }
 
 /// @brief Cleans up resources used by the IOSRecorderCallback.
-/// This method should be called from the JS thread only.
+/// This method should be called from the JS GC thread only.
 void IOSRecorderCallback::cleanup()
 {
+  std::scoped_lock audioLock(destructionAudioGuard_);
   @autoreleasepool {
+    // join the worker
+    offloader_.reset();
+
     if (circularBuffer_[0]->getNumberOfAvailableFrames() > 0) {
       emitAudioData(true);
     }
@@ -115,43 +112,89 @@ void IOSRecorderCallback::cleanup()
     converterInputBuffer_ = nil;
     converterOutputBuffer_ = nil;
 
-    for (size_t i = 0; i < channelCount_; ++i) {
+    for (int i = 0; i < channelCount_; ++i) {
       circularBuffer_[i]->zero();
     }
-    offloader_.reset();
   }
 }
 
+static inline void freeOwnedAudioBufferList(const AudioBufferList *bufferList)
+{
+  if (bufferList == nullptr) {
+    return;
+  }
+  for (UInt32 i = 0; i < bufferList->mNumberBuffers; ++i) {
+    std::free(bufferList->mBuffers[i].mData);
+  }
+  std::free(const_cast<AudioBufferList *>(bufferList));
+}
+
 /// @brief Receives audio data from the recorder, processes it, and stores it in the circular buffer.
 /// The data is converted using AVAudioConverter if the input format differs from the user desired callback format.
 /// This method runs on the audio thread.
 /// @param inputBuffer Pointer to the AudioBufferList containing the incoming audio data.
 /// @param numFrames Number of frames in the input buffer.
-void IOSRecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)
+void IOSRecorderCallback::receiveAudioData(const AudioBufferList *audioBufferList, int numFrames)
 {
+  // if we wait here, we are in the middle of the destruction
+  std::scoped_lock lock(destructionAudioGuard_);
+  if (offloader_ == nullptr) {
+    return;
+  }
   if (!isInitialized_.load(std::memory_order_acquire)) {
     return;
   }
-  offloader_->getSender()->send({inputBuffer, numFrames});
+
+  // CoreAudio owns `audioBufferList` only for the duration of this synchronous
+  // callback. Copy into an owned AudioBufferList before handing off to the
+  // worker thread; the consumer in taskOffloaderFunction frees it.
+  UInt32 bufferCount = audioBufferList->mNumberBuffers;
+  size_t headerSize = offsetof(AudioBufferList, mBuffers) + sizeof(AudioBuffer) * bufferCount;
+  AudioBufferList *owned = static_cast<AudioBufferList *>(std::malloc(headerSize));
+  if (owned == nullptr) {
+    return;
+  }
+  owned->mNumberBuffers = bufferCount;
+  for (UInt32 i = 0; i < bufferCount; ++i) {
+    UInt32 byteSize = audioBufferList->mBuffers[i].mDataByteSize;
+    owned->mBuffers[i].mNumberChannels = audioBufferList->mBuffers[i].mNumberChannels;
+    owned->mBuffers[i].mDataByteSize = byteSize;
+    void *channelData = std::malloc(byteSize);
+    if (channelData == nullptr) {
+      for (UInt32 j = 0; j < i; ++j) {
+        std::free(owned->mBuffers[j].mData);
+      }
+      std::free(owned);
+      return;
+    }
+    std::memcpy(channelData, audioBufferList->mBuffers[i].mData, byteSize);
+    owned->mBuffers[i].mData = channelData;
+  }
+  offloader_->getSender()->send({.audioBufferList = owned, .numFrames = numFrames});
 }
 
 void IOSRecorderCallback::taskOffloaderFunction(CallbackData data)
 {
   auto [inputBuffer, numFrames] = data;
-  // dummy data to wake up thread after cleanup, skip processing it
-  if (inputBuffer == nullptr)
+
+  // The TaskOffloader destructor sends a default-constructed CallbackData
+  // (audioBufferList == nullptr) to unblock the receiver; ignore it here.
+  if (inputBuffer == nullptr) {
     return;
+  }
+
   @autoreleasepool {
     NSError *error = nil;
 
     if (bufferFormat_.sampleRate == sampleRate_ && bufferFormat_.channelCount == channelCount_ &&
         !bufferFormat_.isInterleaved) {
       // Directly write to circular buffer
-      for (size_t i = 0; i < channelCount_; ++i) {
+      for (int i = 0; i < channelCount_; ++i) {
         auto *data = static_cast<float *>(inputBuffer->mBuffers[i].mData);
         circularBuffer_[i]->push_back(data, numFrames);
       }
 
+      freeOwnedAudioBufferList(inputBuffer);
       inputBuffer = nullptr;
       if (circularBuffer_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
         emitAudioData();
@@ -168,6 +211,7 @@ void IOSRecorderCallback::taskOffloaderFunction(CallbackData data)
           inputBuffer->mBuffers[i].mDataByteSize);
     }
 
+    freeOwnedAudioBufferList(inputBuffer);
     inputBuffer = nullptr;
     converterInputBuffer_.frameLength = numFrames;
 
@@ -195,7 +239,7 @@ void IOSRecorderCallback::taskOffloaderFunction(CallbackData data)
       return;
     }
 
-    for (size_t i = 0; i < channelCount_; ++i) {
+    for (int i = 0; i < channelCount_; ++i) {
       auto *data = static_cast<float *>(converterOutputBuffer_.audioBufferList->mBuffers[i].mData);
       circularBuffer_[i]->push_back(data, outputFrameCount);
     }