react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.11

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

@@ -4,19 +4,19 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cassert>
 #include <chrono>
+#include <cstddef>
 #include <functional>
 #include <iostream>
 #include <limits>
 #include <memory>
 #include <thread>
-#include <cstddef>
-#include <cassert>
 #include <utility>
 
 namespace audioapi {
 
-class AudioEventHandlerRegistry;
+class IAudioEventHandlerRegistry;
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
@@ -28,7 +28,7 @@ class AudioScheduledSourceNode : public AudioNode {
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
 
-  void start(double when);
+  virtual void start(double when);
   virtual void stop(double when);
 
   bool isUnscheduled();
@@ -37,7 +37,6 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
-  void clearOnEndedCallback();
   void setOnEndedCallbackId(uint64_t callbackId);
 
   void disable() override;
@@ -49,9 +48,10 @@ class AudioScheduledSourceNode : public AudioNode {
   PlaybackState playbackState_;
 
   std::atomic<uint64_t> onEndedCallbackId_ = 0;
+  std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
   void updatePlaybackInfo(
-      const std::shared_ptr<AudioBus>& processingBus,
+      const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess,
       size_t &startOffset,
       size_t &nonSilentFramesToProcess);

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

@@ -3,6 +3,7 @@
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 
 namespace audioapi {
 ConstantSourceNode::ConstantSourceNode(BaseAudioContext *context)
@@ -29,13 +30,11 @@ std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
     return processingBus;
   }
 
-  auto offsetBus = offsetParam_->processARateParam(
-      framesToProcess, context_->getCurrentTime());
+  auto offsetBus = offsetParam_->processARateParam(framesToProcess, context_->getCurrentTime());
 
   auto offsetChannelData = offsetBus->getChannel(0)->getData();
 
-  for (int channel = 0; channel < processingBus->getNumberOfChannels();
-       ++channel) {
+  for (int channel = 0; channel < processingBus->getNumberOfChannels(); ++channel) {
     auto outputChannelData = processingBus->getChannel(channel)->getData();
 
     std::copy(

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

@@ -18,7 +18,9 @@ class ConstantSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
 
  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:
   std::shared_ptr<AudioParam> offsetParam_;

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

@@ -3,16 +3,14 @@
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
 
 namespace audioapi {
 
-OscillatorNode::OscillatorNode(BaseAudioContext *context)
-    : AudioScheduledSourceNode(context) {
+OscillatorNode::OscillatorNode(BaseAudioContext *context) : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      444.0,
-      -context_->getNyquistFrequency(),
-      context_->getNyquistFrequency(),
-      context);
+      444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
       0.0,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
@@ -21,8 +19,7 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   isInitialized_ = true;
 }
@@ -44,8 +41,7 @@ void OscillatorNode::setType(const std::string &type) {
   periodicWave_ = context_->getBasicWaveForm(type_);
 }
 
-void OscillatorNode::setPeriodicWave(
-    const std::shared_ptr<PeriodicWave> &periodicWave) {
+void OscillatorNode::setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave) {
   periodicWave_ = periodicWave;
   type_ = OscillatorType::CUSTOM;
 }
@@ -65,29 +61,22 @@ std::shared_ptr<AudioBus> OscillatorNode::processNode(
 
   auto time = context_->getCurrentTime() +
       static_cast<double>(startOffset) * 1.0 / context_->getSampleRate();
-  auto detuneParamValues =
-      detuneParam_->processARateParam(framesToProcess, time);
-  auto frequencyParamValues =
-      frequencyParam_->processARateParam(framesToProcess, time);
+  auto detuneParamValues = detuneParam_->processARateParam(framesToProcess, time);
+  auto frequencyParamValues = frequencyParam_->processARateParam(framesToProcess, time);
 
   for (size_t i = startOffset; i < offsetLength; i += 1) {
-    auto detuneRatio = std::pow(
-        2.0f, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
-    auto detunedFrequency =
-        frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
+    auto detuneRatio = std::pow(2.0f, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
+    auto detunedFrequency = frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
     auto phaseIncrement = detunedFrequency * periodicWave_->getScale();
 
-    float sample =
-        periodicWave_->getSample(detunedFrequency, phase_, phaseIncrement);
+    float sample = periodicWave_->getSample(detunedFrequency, phase_, phaseIncrement);
 
     for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
       (*processingBus->getChannel(j))[i] = sample;
     }
 
     phase_ += phaseIncrement;
-    phase_ -=
-        floor(
-            phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
+    phase_ -= floor(phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
         static_cast<float>(periodicWave_->getPeriodicWaveSize());
   }
 

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

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/effects/PeriodicWave.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/types/OscillatorType.h>
-#include <audioapi/core/effects/PeriodicWave.h>
 
+#include <algorithm>
 #include <cmath>
 #include <memory>
 #include <string>
@@ -24,7 +25,9 @@ class OscillatorNode : public AudioScheduledSourceNode {
   void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  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:
   std::shared_ptr<AudioParam> frequencyParam_;
@@ -35,8 +38,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
 
   static OscillatorType fromString(const std::string &type) {
     std::string lowerType = type;
-    std::transform(
-        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
 
     if (lowerType == "sine")
       return OscillatorType::SINE;

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

@@ -1,7 +1,10 @@
 
 #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>
 #include <type_traits>
 
 namespace audioapi {
@@ -14,36 +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

@@ -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