react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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

@@ -1,11 +1,12 @@
 #pragma once
 
-#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/AudioNode.h>
-#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 #include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -18,26 +19,30 @@ class AudioBus;
 /// @note it will push silence if it is not connected to any Recorder
 class RecorderAdapterNode : public AudioNode {
  public:
-    explicit RecorderAdapterNode(BaseAudioContext *context);
+  explicit RecorderAdapterNode(BaseAudioContext *context);
+
+  /// @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.
+  /// @param bufferSize The size of the buffer to be used.
+  /// @param channelCount The number of channels.
+  void init(size_t bufferSize, int channelCount);
+  void cleanup();
 
-    /// @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);
+  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> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+  std::shared_ptr<AudioBus> adapterOutputBus_;
 
  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;
+  /// @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 framesToRead Number of frames to read.
+  void readFrames(size_t framesToRead);
 };
 
 } // namespace audioapi

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

@@ -15,8 +15,13 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <chrono>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <utility>
 
 namespace audioapi {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 StreamerNode::StreamerNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context),
       fmtCtx_(nullptr),
@@ -25,20 +30,24 @@ StreamerNode::StreamerNode(BaseAudioContext *context)
       codecpar_(nullptr),
       pkt_(nullptr),
       frame_(nullptr),
-      pendingFrame_(nullptr),
-      bufferedBus_(nullptr),
-      bufferedBusIndex_(0),
-      maxBufferSize_(0),
-      audio_stream_index_(-1),
       swrCtx_(nullptr),
       resampledData_(nullptr),
-      maxResampledSamples_(0) {}
+      bufferedBus_(nullptr),
+      audio_stream_index_(-1),
+      maxResampledSamples_(0),
+      processedSamples_(0) {}
+#else
+StreamerNode::StreamerNode(BaseAudioContext *context) : AudioScheduledSourceNode(context) {}
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 
 StreamerNode::~StreamerNode() {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   cleanup();
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
 
 bool StreamerNode::initialize(const std::string &input_url) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   if (isInitialized_) {
     cleanup();
   }
@@ -66,26 +75,77 @@ bool StreamerNode::initialize(const std::string &input_url) {
     return false;
   }
 
-  maxBufferSize_ = BUFFER_LENGTH_SECONDS * codecCtx_->sample_rate;
-  // If decoding is faster than playing, we buffer few seconds of audio
-  bufferedBus_ = std::make_shared<AudioBus>(
-      maxBufferSize_, codecpar_->ch_layout.nb_channels, codecCtx_->sample_rate);
-
   channelCount_ = codecpar_->ch_layout.nb_channels;
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+
+  auto [sender, receiver] = channels::spsc::channel<
+      StreamingData,
+      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+      channels::spsc::WaitStrategy::ATOMIC_WAIT>(CHANNEL_CAPACITY);
+  sender_ = std::move(sender);
+  receiver_ = std::move(receiver);
 
   streamingThread_ = std::thread(&StreamerNode::streamAudio, this);
-  streamFlag.store(true);
   isInitialized_ = true;
   return true;
+#else
+  return false;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
 
-void StreamerNode::stop(double when) {
-  AudioScheduledSourceNode::stop(when);
-  streamFlag.store(false);
+std::shared_ptr<AudioBus> StreamerNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+  isNodeFinished_.store(isFinished(), std::memory_order_release);
+
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
+  int bufferRemaining = bufferedBusSize_ - processedSamples_;
+  int alreadyProcessed = 0;
+  if (bufferRemaining < framesToProcess) {
+    if (bufferedBus_ != nullptr) {
+      for (int ch = 0; ch < processingBus->getNumberOfChannels(); ch++) {
+        memcpy(
+            processingBus->getChannel(ch)->getData(),
+            bufferedBus_->getChannel(ch)->getData() + processedSamples_,
+            bufferRemaining * sizeof(float));
+      }
+      framesToProcess -= bufferRemaining;
+      alreadyProcessed += bufferRemaining;
+    }
+    StreamingData data;
+    auto res = receiver_.try_receive(data);
+    if (res == channels::spsc::ResponseStatus::SUCCESS) {
+      bufferedBus_ = std::make_shared<AudioBus>(std::move(data.bus));
+      bufferedBusSize_ = data.size;
+      processedSamples_ = 0;
+    } else {
+      bufferedBus_ = nullptr;
+    }
+  }
+  if (bufferedBus_ != nullptr) {
+    for (int ch = 0; ch < processingBus->getNumberOfChannels(); ch++) {
+      memcpy(
+          processingBus->getChannel(ch)->getData() + alreadyProcessed,
+          bufferedBus_->getChannel(ch)->getData() + processedSamples_,
+          framesToProcess * sizeof(float));
+    }
+    processedSamples_ += framesToProcess;
+  }
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+
+  return processingBus;
 }
 
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 bool StreamerNode::setupResampler() {
   // Allocate resampler context
   swrCtx_ = swr_alloc();
@@ -122,69 +182,23 @@ bool StreamerNode::setupResampler() {
 }
 
 void StreamerNode::streamAudio() {
-  while (streamFlag.load()) {
-    if (pendingFrame_ != nullptr) {
-      if (!processFrameWithResampler(pendingFrame_)) {
+  while (!isNodeFinished_.load(std::memory_order_acquire)) {
+    if (av_read_frame(fmtCtx_, pkt_) < 0) {
+      return;
+    }
+    if (pkt_->stream_index == audio_stream_index_) {
+      if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
         return;
       }
-    } else {
-      if (av_read_frame(fmtCtx_, pkt_) < 0) {
+      if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
         return;
       }
-      if (pkt_->stream_index == audio_stream_index_) {
-        if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
-          return;
-        }
-        if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
-          return;
-        }
-        if (!processFrameWithResampler(frame_)) {
-          return;
-        }
+      if (!processFrameWithResampler(frame_)) {
+        return;
       }
-      av_packet_unref(pkt_);
-    }
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-  }
-}
-
-std::shared_ptr<AudioBus> StreamerNode::processNode(
-    const std::shared_ptr<AudioBus> &processingBus,
-    int framesToProcess) {
-  size_t startOffset = 0;
-  size_t offsetLength = 0;
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
-
-  if (!isPlaying() && !isStopScheduled()) {
-    processingBus->zero();
-    return processingBus;
-  }
-
-  // If we have enough buffered data, copy to output bus
-  if (bufferedBusIndex_ >= framesToProcess) {
-    Locker locker(mutex_);
-    for (int ch = 0; ch < processingBus->getNumberOfChannels(); ch++) {
-      memcpy(
-          processingBus->getChannel(ch)->getData(),
-          bufferedBus_->getChannel(ch)->getData(),
-          offsetLength * sizeof(float));
-
-      memmove(
-          bufferedBus_->getChannel(ch)->getData(),
-          bufferedBus_->getChannel(ch)->getData() + offsetLength,
-          (maxBufferSize_ - offsetLength) * sizeof(float));
     }
-    bufferedBusIndex_ -= offsetLength;
-  } else {
-    if (VERBOSE)
-      printf(
-          "Buffer underrun: have %zu, need %zu\n",
-          bufferedBusIndex_,
-          (size_t)framesToProcess);
-    processingBus->zero();
+    av_packet_unref(pkt_);
   }
-
-  return processingBus;
 }
 
 bool StreamerNode::processFrameWithResampler(AVFrame *frame) {
@@ -220,22 +234,21 @@ bool StreamerNode::processFrameWithResampler(AVFrame *frame) {
     return false;
   }
 
-  // Check if converted data fits in buffer
-  if (bufferedBusIndex_ + converted_samples > maxBufferSize_) {
-    pendingFrame_ = frame;
+  // if we would like to finish dont copy anything
+  if (this->isFinished()) {
     return true;
-  } else {
-    pendingFrame_ = nullptr;
   }
-
-  // Copy converted data to our buffer
-  Locker locker(mutex_);
+  auto bus = AudioBus(
+      static_cast<size_t>(converted_samples),
+      codecCtx_->ch_layout.nb_channels,
+      context_->getSampleRate());
   for (int ch = 0; ch < codecCtx_->ch_layout.nb_channels; ch++) {
     auto *src = reinterpret_cast<float *>(resampledData_[ch]);
-    float *dst = bufferedBus_->getChannel(ch)->getData() + bufferedBusIndex_;
+    float *dst = bus.getChannel(ch)->getData();
     memcpy(dst, src, converted_samples * sizeof(float));
   }
-  bufferedBusIndex_ += converted_samples;
+  StreamingData data{std::move(bus), static_cast<size_t>(converted_samples)};
+  sender_.send(std::move(data));
   return true;
 }
 
@@ -280,10 +293,14 @@ bool StreamerNode::setupDecoder() {
 }
 
 void StreamerNode::cleanup() {
-  streamFlag.store(false);
-  // cleanup cannot be called from the streaming thread so there is no need to
-  // check if we are in the same thread
-  streamingThread_.join();
+  this->playbackState_ = PlaybackState::FINISHED;
+  isNodeFinished_.store(true, std::memory_order_release);
+  if (streamingThread_.joinable()) {
+    StreamingData dummy;
+    while (receiver_.try_receive(dummy) == channels::spsc::ResponseStatus::SUCCESS)
+      ; // clear the receiver
+    streamingThread_.join();
+  }
   if (swrCtx_ != nullptr) {
     swr_free(&swrCtx_);
   }
@@ -315,4 +332,5 @@ void StreamerNode::cleanup() {
   codecpar_ = nullptr;
   maxResampledSamples_ = 0;
 }
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 } // namespace audioapi

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

@@ -11,24 +11,50 @@
 #pragma once
 
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/utils/AudioBus.h>
 
-#ifndef AUDIO_API_TEST_SUITE
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 extern "C" {
-  #include <libavformat/avformat.h>
-  #include <libavcodec/avcodec.h>
-  #include <libavutil/samplefmt.h>
-  #include <libavutil/channel_layout.h>
-  #include <libavutil/opt.h>
-  #include <libswresample/swresample.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/opt.h>
+#include <libavutil/samplefmt.h>
+#include <libswresample/swresample.h>
 }
-#endif
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 
+#include <audioapi/utils/SpscChannel.hpp>
+#include <atomic>
 #include <cmath>
 #include <memory>
 #include <string>
-#include <atomic>
-
-static bool constexpr VERBOSE = false;
+#include <utility>
+
+static constexpr audioapi::channels::spsc::OverflowStrategy STREAMER_NODE_SPSC_OVERFLOW_STRATEGY =
+    audioapi::channels::spsc::OverflowStrategy::WAIT_ON_FULL;
+static constexpr audioapi::channels::spsc::WaitStrategy STREAMER_NODE_SPSC_WAIT_STRATEGY =
+    audioapi::channels::spsc::WaitStrategy::ATOMIC_WAIT;
+
+static constexpr bool VERBOSE = false;
+static constexpr int CHANNEL_CAPACITY = 32;
+
+struct StreamingData {
+  audioapi::AudioBus bus;
+  size_t size;
+  StreamingData() = default;
+  StreamingData(audioapi::AudioBus b, size_t s) : bus(b), size(s) {}
+  StreamingData(const StreamingData &data) : bus(data.bus), size(data.size) {}
+  StreamingData(StreamingData &&data) noexcept : bus(std::move(data.bus)), size(data.size) {}
+  StreamingData &operator=(const StreamingData &data) {
+    if (this == &data) {
+      return *this;
+    }
+    bus = data.bus;
+    size = data.size;
+    return *this;
+  }
+};
 
 namespace audioapi {
 
@@ -42,33 +68,41 @@ class StreamerNode : public AudioScheduledSourceNode {
   /**
    * @brief Initialize all necessary ffmpeg components for streaming audio
   */
-  bool initialize(const std::string& inputUrl);
-  void stop(double when) override;
+  bool initialize(const std::string &inputUrl);
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
-  #ifndef AUDIO_API_TEST_SUITE
-  AVFormatContext* fmtCtx_;
-  AVCodecContext* codecCtx_;
-  const AVCodec* decoder_;
-  AVCodecParameters* codecpar_;
-  AVPacket* pkt_;
-  AVFrame* frame_; // Frame that is currently being processed
-  AVFrame* pendingFrame_; // Frame that is saved if bufferedBus is full
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+  AVFormatContext *fmtCtx_;
+  AVCodecContext *codecCtx_;
+  const AVCodec *decoder_;
+  AVCodecParameters *codecpar_;
+  AVPacket *pkt_;
+  AVFrame *frame_; // Frame that is currently being processed
+  SwrContext *swrCtx_;
+  uint8_t **resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
+
   std::shared_ptr<AudioBus> bufferedBus_; // audio bus for buffering hls frames
-  size_t bufferedBusIndex_; // index in the buffered bus where we write the next frame
-  size_t maxBufferSize_; // maximum size of the buffered bus
-  int audio_stream_index_; // index of the audio stream channel in the input
-  SwrContext* swrCtx_;
-  uint8_t** resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
+  size_t bufferedBusSize_;                // size of currently buffered bus
+  int audio_stream_index_;                // index of the audio stream channel in the input
   int maxResampledSamples_;
-  std::mutex mutex_;
+  size_t processedSamples_;
+
   std::thread streamingThread_;
-  std::atomic<bool> streamFlag; // Flag to control the streaming thread
-  static constexpr float BUFFER_LENGTH_SECONDS = 5.0f; // Length of the buffer in seconds
+  std::atomic<bool> isNodeFinished_;                         // Flag to control the streaming thread
   static constexpr int INITIAL_MAX_RESAMPLED_SAMPLES = 8192; // Initial size for resampled data
+  channels::spsc::
+      Sender<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY>
+          sender_;
+  channels::spsc::Receiver<
+      StreamingData,
+      STREAMER_NODE_SPSC_OVERFLOW_STRATEGY,
+      STREAMER_NODE_SPSC_WAIT_STRATEGY>
+      receiver_;
 
   /**
    * @brief Setting up the resampler
@@ -81,7 +115,7 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @param frame The AVFrame to resample
    * @return true if successful, false otherwise
    */
-  bool processFrameWithResampler(AVFrame* frame);
+  bool processFrameWithResampler(AVFrame *frame);
 
   /**
    * @brief Thread function to continuously read and process audio frames
@@ -100,7 +134,7 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @return true if successful, false otherwise
    * @note This function initializes the FFmpeg libraries and opens the input stream
    */
-  bool openInput(const std::string& inputUrl);
+  bool openInput(const std::string &inputUrl);
 
   /**
    * @brief Find the audio stream channel in the input
@@ -113,6 +147,6 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @return true if successful, false otherwise
    */
   bool setupDecoder();
-  #endif // AUDIO_API_TEST_SUITE
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 };
 } // namespace audioapi

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

@@ -1,13 +1,12 @@
 #include <audioapi/core/sources/WorkletSourceNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
-WorkletSourceNode::WorkletSourceNode(
-    BaseAudioContext *context,
-    WorkletsRunner &&workletRunner)
-    : AudioScheduledSourceNode(context),
-      workletRunner_(std::move(workletRunner)) {
+WorkletSourceNode::WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+    : AudioScheduledSourceNode(context), workletRunner_(std::move(workletRunner)) {
   isInitialized_ = true;
 
   // Prepare buffers for audio processing
@@ -30,8 +29,7 @@ std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
   size_t startOffset = 0;
   size_t nonSilentFramesToProcess = framesToProcess;
 
-  updatePlaybackInfo(
-      processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
 
   if (nonSilentFramesToProcess == 0) {
     processingBus->zero();

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

@@ -1,40 +1,42 @@
 #pragma once
-#include <jsi/jsi.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/utils/AudioBus.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
 #include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <jsi/jsi.h>
 
-#include <vector>
 #include <memory>
+#include <vector>
 
 namespace audioapi {
 
 #if RN_AUDIO_API_TEST
 class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit WorkletSourceNode(
-    BaseAudioContext *context,
-    WorkletsRunner &&workletRunner
-  ) : AudioScheduledSourceNode(context) {}
+  explicit WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+      : AudioScheduledSourceNode(context) {}
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return processingBus;
+  }
 };
 #else
 
 class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit WorkletSourceNode(
-    BaseAudioContext *context,
-    WorkletsRunner &&workletRunner
-  );
+  explicit WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner);
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
  private:
   WorkletsRunner workletRunner_;
   std::vector<std::shared_ptr<AudioArrayBuffer>> outputBuffsHandles_;

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

@@ -2,15 +2,5 @@
 
 namespace audioapi {
 
-enum class AudioFormat {
-  UNKNOWN,
-  WAV,
-  OGG,
-  FLAC,
-  AAC,
-  MP3,
-  M4A,
-  MP4,
-  MOV
-};
+enum class AudioFormat { UNKNOWN, WAV, OGG, FLAC, AAC, MP3, M4A, MP4, MOV };
 } // namespace audioapi

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

@@ -18,16 +18,23 @@ class AudioDecoder {
  public:
   AudioDecoder() = delete;
 
-  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, float sampleRate);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(
+      const std::string &path,
+      float sampleRate);
   [[nodiscard]] static std::shared_ptr<AudioBuffer>
   decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
-  [[nodiscard]] static std::shared_ptr<AudioBuffer>
-  decodeWithPCMInBase64(const std::string &data, float inputSampleRate, int inputChannelCount, bool interleaved);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(
+      const std::string &data,
+      float inputSampleRate,
+      int inputChannelCount,
+      bool interleaved);
 
  private:
   static std::vector<float> readAllPcmFrames(ma_decoder &decoder, int outputChannels);
-  static std::shared_ptr<AudioBuffer>
-  makeAudioBufferFromFloatBuffer(const std::vector<float> &buffer, float outputSampleRate, int outputChannels);
+  static std::shared_ptr<AudioBuffer> makeAudioBufferFromFloatBuffer(
+      const std::vector<float> &buffer,
+      float outputSampleRate,
+      int outputChannels);
 
   static AudioFormat detectAudioFormat(const void *data, size_t size) {
     if (size < 12)
@@ -66,7 +73,9 @@ class AudioDecoder {
     return AudioFormat::UNKNOWN;
   }
 
-  static inline bool pathHasExtension(const std::string &path, const std::vector<std::string> &extensions) {
+  static inline bool pathHasExtension(
+      const std::string &path,
+      const std::vector<std::string> &extensions) {
     std::string pathLower = path;
     std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), ::tolower);
     for (const auto &ext : extensions) {

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