react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-52d0b79-20251216

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

@@ -5,6 +5,7 @@
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #ifdef ANDROID
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #else
@@ -15,33 +16,121 @@
 namespace audioapi {
 
 AudioRecorderHostObject::AudioRecorderHostObject(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    float sampleRate,
-    int bufferLength) {
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
 #ifdef ANDROID
-  audioRecorder_ =
-      std::make_shared<AndroidAudioRecorder>(sampleRate, bufferLength, audioEventHandlerRegistry);
+  audioRecorder_ = std::make_shared<AndroidAudioRecorder>(audioEventHandlerRegistry);
 #else
-  audioRecorder_ =
-      std::make_shared<IOSAudioRecorder>(sampleRate, bufferLength, audioEventHandlerRegistry);
+  audioRecorder_ = std::make_shared<IOSAudioRecorder>(audioEventHandlerRegistry);
 #endif
 
-  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioRecorderHostObject, onAudioReady));
-
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, start),
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, isRecording),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, enableFileOutput),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disableFileOutput),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, pause),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, resume),
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, connect),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect));
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, setOnAudioReady),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, clearOnAudioReady),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, setOnError),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, clearOnError),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, getCurrentDuration));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
+  auto result = audioRecorder_->start();
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(runtime, result.is_ok() ? "success" : "error"));
+
+  if (result.is_ok()) {
+    jsResult.setProperty(runtime, "path", jsi::String::createFromUtf8(runtime, result.unwrap()));
+  } else {
+    jsResult.setProperty(
+        runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));
+  }
+
+  return jsResult;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
+  auto result = audioRecorder_->stop();
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(runtime, result.is_ok() ? "success" : "error"));
+
+  if (result.is_ok()) {
+    auto info = result.unwrap();
+
+    jsResult.setProperty(runtime, "path", jsi::String::createFromUtf8(runtime, std::get<0>(info)));
+    jsResult.setProperty(runtime, "size", std::get<1>(info));
+    jsResult.setProperty(runtime, "duration", std::get<2>(info));
+  } else {
+    jsResult.setProperty(
+        runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));
+  }
+
+  return jsResult;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, isRecording) {
+  return jsi::Value(audioRecorder_->isRecording());
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, isPaused) {
+  return jsi::Value(audioRecorder_->isPaused());
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, enableFileOutput) {
+  auto fileProperties = AudioFileProperties::CreateFromJSIValue(runtime, args[0]);
+
+  auto result = audioRecorder_->enableFileOutput(fileProperties);
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(runtime, result.is_ok() ? "success" : "error"));
+
+  if (result.is_ok()) {
+    jsResult.setProperty(runtime, "path", jsi::String::createFromUtf8(runtime, result.unwrap()));
+  } else {
+    jsResult.setProperty(
+        runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));
+  }
+
+  return jsResult;
 }
 
-JSI_PROPERTY_SETTER_IMPL(AudioRecorderHostObject, onAudioReady) {
-  audioRecorder_->setOnAudioReadyCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, disableFileOutput) {
+  audioRecorder_->disableFileOutput();
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, pause) {
+  audioRecorder_->pause();
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, resume) {
+  audioRecorder_->resume();
+  return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, connect) {
   auto adapterNodeHostObject =
       args[0].getObject(runtime).getHostObject<RecorderAdapterNodeHostObject>(runtime);
+
   audioRecorder_->connect(
       std::static_pointer_cast<RecorderAdapterNode>(adapterNodeHostObject->node_));
   return jsi::Value::undefined();
@@ -49,19 +138,59 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, connect) {
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, disconnect) {
   audioRecorder_->disconnect();
+
   return jsi::Value::undefined();
 }
 
-JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
-  audioRecorder_->start();
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, setOnAudioReady) {
+  auto options = args[0].getObject(runtime);
+
+  auto sampleRate = static_cast<float>(options.getProperty(runtime, "sampleRate").getNumber());
+  auto bufferLength = static_cast<size_t>(options.getProperty(runtime, "bufferLength").getNumber());
+  auto channelCount = static_cast<int>(options.getProperty(runtime, "channelCount").getNumber());
+  uint64_t callbackId =
+      std::stoull(options.getProperty(runtime, "callbackId").getString(runtime).utf8(runtime));
 
+  auto result =
+      audioRecorder_->setOnAudioReadyCallback(sampleRate, bufferLength, channelCount, callbackId);
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(runtime, result.is_ok() ? "success" : "error"));
+
+  if (result.is_err()) {
+    jsResult.setProperty(
+        runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));
+  }
+
+  return jsResult;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, clearOnAudioReady) {
+  audioRecorder_->clearOnAudioReadyCallback();
   return jsi::Value::undefined();
 }
 
-JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
-  audioRecorder_->stop();
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, setOnError) {
+  auto options = args[0].getObject(runtime);
 
+  uint64_t callbackId =
+      std::stoull(options.getProperty(runtime, "callbackId").getString(runtime).utf8(runtime));
+
+  audioRecorder_->setOnErrorCallback(callbackId);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, clearOnError) {
+  audioRecorder_->clearOnErrorCallback();
   return jsi::Value::undefined();
 }
 
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, getCurrentDuration) {
+  double duration = audioRecorder_->getCurrentDuration();
+  return jsi::Value(duration);
+}
+
 } // namespace audioapi

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

@@ -4,6 +4,7 @@
 
 #include <cstdio>
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -16,18 +17,32 @@ class AudioEventHandlerRegistry;
 class AudioRecorderHostObject : public JsiHostObject {
  public:
   explicit AudioRecorderHostObject(
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-      float sampleRate,
-      int bufferLength);
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
 
-  JSI_PROPERTY_SETTER_DECL(onAudioReady);
+  JSI_HOST_FUNCTION_DECL(start);
+  JSI_HOST_FUNCTION_DECL(stop);
+  JSI_HOST_FUNCTION_DECL(isRecording);
+  JSI_HOST_FUNCTION_DECL(isPaused);
+
+  JSI_HOST_FUNCTION_DECL(enableFileOutput);
+  JSI_HOST_FUNCTION_DECL(disableFileOutput);
+
+  JSI_HOST_FUNCTION_DECL(pause);
+  JSI_HOST_FUNCTION_DECL(resume);
 
   JSI_HOST_FUNCTION_DECL(connect);
   JSI_HOST_FUNCTION_DECL(disconnect);
-  JSI_HOST_FUNCTION_DECL(start);
-  JSI_HOST_FUNCTION_DECL(stop);
+
+  JSI_HOST_FUNCTION_DECL(setOnAudioReady);
+  JSI_HOST_FUNCTION_DECL(clearOnAudioReady);
+
+  JSI_HOST_FUNCTION_DECL(setOnError);
+  JSI_HOST_FUNCTION_DECL(clearOnError);
+
+  JSI_HOST_FUNCTION_DECL(getCurrentDuration);
 
  private:
   std::shared_ptr<AudioRecorder> audioRecorder_;
 };
+
 } // namespace audioapi

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

@@ -1,83 +1,66 @@
-#include <audioapi/HostObjects/sources/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>
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <unordered_map>
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/core/utils/AudioRecorderCallback.h>
 
 namespace audioapi {
 
-AudioRecorder::AudioRecorder(
-    float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : sampleRate_(sampleRate),
-      bufferLength_(bufferLength),
-      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  constexpr int minRingBufferSize = 8192;
-  ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
-  circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
-  isRunning_.store(false);
-}
+/// @brief Sets the error callback to be invoked when an error occurs during recording.
+/// This method should be called from the JS thread only.
+/// @param callbackId Identifier for the JS callback to be invoked.
+void AudioRecorder::setOnErrorCallback(uint64_t callbackId) {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
+
+  if (usesFileOutput()) {
+    fileWriter_->setOnErrorCallback(callbackId);
+  }
+
+  if (usesCallback()) {
+    dataCallback_->setOnErrorCallback(callbackId);
+  }
 
-void AudioRecorder::setOnAudioReadyCallbackId(uint64_t callbackId) {
-  onAudioReadyCallbackId_ = callbackId;
+  errorCallbackId_.store(callbackId, std::memory_order_release);
 }
 
-void AudioRecorder::invokeOnAudioReadyCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+/// @brief Clears the error callback.
+/// If the recorder is currently active, it will stop invoking the callback immediately.
+/// This method should be called from the JS thread only.
+void AudioRecorder::clearOnErrorCallback() {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
 
-  std::unordered_map<std::string, EventValue> body = {};
-  body.insert({"buffer", audioBufferHostObject});
-  body.insert({"numFrames", numFrames});
+  if (usesFileOutput()) {
+    fileWriter_->clearOnErrorCallback();
+  }
 
-  if (audioEventHandlerRegistry_ != nullptr) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "audioReady", onAudioReadyCallbackId_, body);
+  if (usesCallback()) {
+    dataCallback_->clearOnErrorCallback();
   }
+
+  errorCallbackId_.store(0, std::memory_order_release);
 }
 
-void AudioRecorder::sendRemainingData() {
-  auto bus =
-      std::make_shared<AudioBus>(circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  auto *outputChannel = bus->getChannel(0)->getData();
-  auto availableFrames = static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
+/// @brief Gets the current duration of the recorded audio in seconds.
+/// @returns Duration in seconds.
+double AudioRecorder::getCurrentDuration() const {
+  double duration = 0.0;
 
-  circularBuffer_->pop_front(outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+  if (usesFileOutput()) {
+    duration = fileWriter_->getCurrentDuration();
+  }
 
-  invokeOnAudioReadyCallback(bus, availableFrames);
+  return duration;
 }
 
-void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
-  node->init(ringBufferSize_);
-  adapterNodeLock_.lock();
-  adapterNode_ = node;
-  adapterNodeLock_.unlock();
+bool AudioRecorder::usesCallback() const {
+  return callbackOutputEnabled_.load(std::memory_order_acquire);
 }
 
-void AudioRecorder::disconnect() {
-  adapterNodeLock_.lock();
-  adapterNode_ = nullptr;
-  adapterNodeLock_.unlock();
+bool AudioRecorder::usesFileOutput() const {
+  return fileOutputEnabled_.load(std::memory_order_acquire);
 }
 
-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);
+bool AudioRecorder::isConnected() const {
+  return isConnected_.load(std::memory_order_acquire);
 }
 
 } // namespace audioapi

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

@@ -1,62 +1,82 @@
 #pragma once
 
+#include <audioapi/utils/Result.hpp>
 #include <atomic>
 #include <memory>
 #include <mutex>
+#include <string>
+#include <tuple>
 
 namespace audioapi {
 
-class RecorderAdapterNode;
 class AudioBus;
+class AudioFileWriter;
 class CircularAudioArray;
-class CircularOverflowableAudioArray;
+class RecorderAdapterNode;
+class AudioFileProperties;
+class AudioRecorderCallback;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
+  enum class RecorderState { Idle = 0, Recording, Paused };
   explicit AudioRecorder(
-      float sampleRate,
-      int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
-
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+      : audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
   virtual ~AudioRecorder() = default;
 
-  void setOnAudioReadyCallbackId(uint64_t callbackId);
-  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
-  void sendRemainingData();
+  virtual Result<std::string, std::string> start() = 0;
+  virtual Result<std::tuple<std::string, double, double>, std::string> stop() = 0;
+
+  virtual Result<std::string, std::string> enableFileOutput(
+      std::shared_ptr<AudioFileProperties> properties) = 0;
+  virtual void disableFileOutput() = 0;
+
+  virtual void pause() = 0;
+  virtual void resume() = 0;
+
+  virtual void connect(const std::shared_ptr<RecorderAdapterNode> &node) = 0;
+  virtual void disconnect() = 0;
 
-  /// @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);
+  virtual Result<NoneType, std::string> setOnAudioReadyCallback(
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId) = 0;
+  virtual void clearOnAudioReadyCallback() = 0;
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
 
-  /// @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 double getCurrentDuration() const;
 
-  virtual void start() = 0;
-  virtual void stop() = 0;
+  bool usesCallback() const;
+  bool usesFileOutput() const;
+  bool isConnected() const;
+
+  virtual bool isRecording() const = 0;
+  virtual bool isPaused() const = 0;
+  virtual bool isIdle() const = 0;
 
  protected:
-  float sampleRate_;
-  int bufferLength_;
-  size_t ringBufferSize_;
+  std::atomic<RecorderState> state_{RecorderState::Idle};
 
-  std::atomic<bool> isRunning_;
-  std::shared_ptr<CircularAudioArray> circularBuffer_;
+  std::atomic<bool> isConnected_{false};
+  std::atomic<bool> fileOutputEnabled_{false};
+  std::atomic<bool> callbackOutputEnabled_{false};
 
-  mutable std::mutex adapterNodeLock_;
-  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::mutex callbackMutex_;
+  std::mutex fileWriterMutex_;
+  std::mutex errorCallbackMutex_;
+  mutable std::mutex adapterNodeMutex_;
 
-  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  uint64_t onAudioReadyCallbackId_ = 0;
+  std::atomic<uint64_t> errorCallbackId_{0};
 
-  void writeToBuffers(const float *data, int numFrames);
+  std::string filePath_{""};
+  std::shared_ptr<AudioFileWriter> fileWriter_ = nullptr;
+  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::shared_ptr<AudioRecorderCallback> dataCallback_ = nullptr;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 
 } // namespace audioapi

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

@@ -1,5 +1,7 @@
 
 #include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <memory>
@@ -15,34 +17,60 @@ RecorderAdapterNode::RecorderAdapterNode(BaseAudioContext *context) noexcept(
   isInitialized_ = false;
 }
 
-void RecorderAdapterNode::init(size_t bufferSize) {
+void RecorderAdapterNode::init(size_t bufferSize, int channelCount) {
   if (isInitialized_) {
-    throw std::runtime_error(
-        "RecorderAdapterNode should not be initialized more than once. Just create a new instance.");
+    return;
   }
+
+  channelCount_ = channelCount;
+
+  buff_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    buff_[i] = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
+  }
+
+  // This assumes that the sample rate is the same in audio context and recorder.
+  // (recorder is not enforcing any sample rate on the system*). This means that only
+  // channel mixing might be required. To do so, we create an output bus with
+  // the desired channel count and will take advantage of the AudioBus sum method.
+  //
+  // * any allocations required by the recorder (including this method) are during recording start
+  // or after, which means that audio context has already setup the system in 99% of sane cases.
+  // But if we would like to support cases when context is created on the fly during recording,
+  // we would need to add sample rate conversion as well or other weird bullshit like resampling
+  // context output and not enforcing anything on the system output/input configuration.
+  // A lot of words for a couple of lines of implementation :shrug:
+  adapterOutputBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
   isInitialized_ = true;
-  buff_ = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
+}
+
+void RecorderAdapterNode::cleanup() {
+  isInitialized_ = false;
+  buff_.clear();
+  adapterOutputBus_.reset();
 }
 
 std::shared_ptr<AudioBus> 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);
+  if (!isInitialized_) {
+    processingBus->zero();
+    return processingBus;
   }
 
+  readFrames(framesToProcess);
+
+  processingBus->sum(adapterOutputBus_.get(), ChannelInterpretation::SPEAKERS);
   return processingBus;
 }
 
-void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {
-  size_t readFrames = buff_->read(output, framesToRead);
+void RecorderAdapterNode::readFrames(const size_t framesToRead) {
+  adapterOutputBus_->zero();
 
-  if (readFrames < framesToRead) {
-    // Fill the rest with silence
-    std::memset(output + readFrames, 0, (framesToRead - readFrames) * sizeof(float));
+  for (size_t channel = 0; channel < channelCount_; ++channel) {
+    buff_[channel]->read(adapterOutputBus_->getChannel(channel)->getData(), framesToRead);
   }
 }
 

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

@@ -6,6 +6,7 @@
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 #include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -20,26 +21,28 @@ class RecorderAdapterNode : public AudioNode {
  public:
   explicit RecorderAdapterNode(BaseAudioContext *context);
 
-  /// @brief Initialize the RecorderAdapterNode with a buffer size.
+  /// @brief Initialize the RecorderAdapterNode with a buffer size and channel count.
   /// @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);
+  /// @param channelCount The number of channels.
+  void init(size_t bufferSize, int channelCount);
+  void cleanup();
+
+  int channelCount_;
+  // TODO: CircularOverflowableAudioBus
+  std::vector<std::shared_ptr<CircularOverflowableAudioArray>> buff_;
 
  protected:
   std::shared_ptr<AudioBus> processNode(
       const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess) override;
-  std::shared_ptr<CircularOverflowableAudioArray> buff_;
+  std::shared_ptr<AudioBus> adapterOutputBus_;
 
  private:
-  /// @brief Read audio frames from the recorder's internal adapterBuffer.
+  /// @brief Read audio frames from the recorder's internal circular buffer into output buss.
   /// @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;
+  void readFrames(size_t framesToRead);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioFileWriter.cpp

@@ -0,0 +1,41 @@
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+AudioFileWriter::AudioFileWriter(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : audioEventHandlerRegistry_(audioEventHandlerRegistry), fileProperties_(fileProperties) {}
+
+void AudioFileWriter::setOnErrorCallback(uint64_t callbackId) {
+  errorCallbackId_.store(callbackId, std::memory_order_release);
+}
+
+void AudioFileWriter::clearOnErrorCallback() {
+  errorCallbackId_.store(0, std::memory_order_release);
+}
+
+void AudioFileWriter::invokeOnErrorCallback(const std::string &message) {
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
+
+  // TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,
+  // the callback could be cleared. We need to ensure that the callback is still valid when invoking it.
+  // TL;DR: atomic szpont
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+bool AudioFileWriter::isFileOpen() {
+  return isFileOpen_.load(std::memory_order_acquire);
+}
+
+} // namespace audioapi