react-native-audio-api 0.10.0-nightly-dedc2a2-20251029 → 0.10.0-nightly-e16d7ff-20251031

package/RNAudioAPI.podspec

@@ -32,6 +32,13 @@ Pod::Spec.new do |s|
       sss.header_dir = "audioapi"
       sss.header_mappings_dir = "ios/audioapi"
     end
+
+    ss.subspec "audioapi_dsp" do |sss|
+      sss.source_files = "common/cpp/audioapi/dsp/**/*.{cpp}"
+      sss.header_dir = "audioapi/dsp"
+      sss.header_mappings_dir = "common/cpp/audioapi/dsp"
+      sss.compiler_flags = "-O3"
+    end
   end
 
   s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate', 'MediaPlayer', 'AVFoundation'

package/android/src/main/cpp/audioapi/CMakeLists.txt

@@ -3,6 +3,12 @@ cmake_minimum_required(VERSION 3.12.0)
 file(GLOB_RECURSE ANDROID_CPP_SOURCES CONFIGURE_DEPENDS "${ANDROID_CPP_DIR}/audioapi/*.cpp")
 file(GLOB_RECURSE COMMON_CPP_SOURCES CONFIGURE_DEPENDS "${COMMON_CPP_DIR}/audioapi/*.cpp" "${COMMON_CPP_DIR}/audioapi/*.c")
 
+set_source_files_properties(
+  ${COMMON_CPP_SOURCES}/dsp/*.cpp
+  PROPERTIES
+  COMPILE_FLAGS "-O3"
+)
+
 set(INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/include)
 set(FFMPEG_INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/ffmpeg_include)
 set(EXTERNAL_DIR ${COMMON_CPP_DIR}/audioapi/external)

package/android/src/main/java/com/swmansion/audioapi/system/MediaNotificationManager.kt

@@ -258,5 +258,16 @@ class MediaNotificationManager(
       }
       super.onDestroy()
     }
+
+    override fun onTimeout(startId: Int) {
+      stopForegroundService()
+    }
+
+    override fun onTimeout(
+      startId: Int,
+      fgsType: Int,
+    ) {
+      stopForegroundService()
+    }
   }
 }

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

@@ -5,6 +5,7 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
+#include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
 #include <audioapi/HostObjects/effects/GainNodeHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
@@ -49,6 +50,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConvolver),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser));
 }
 
@@ -269,4 +271,20 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
   auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
   return jsi::Object::createFromHostObject(runtime, analyserHostObject);
 }
+
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
+  auto disableNormalization = args[1].getBool();
+  std::shared_ptr<ConvolverNode> convolver;
+  if (args[0].isUndefined()) {
+    convolver = context_->createConvolver(nullptr, disableNormalization);
+  } else {
+    auto bufferHostObject =
+        args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    convolver = context_->createConvolver(
+        bufferHostObject->audioBuffer_, disableNormalization);
+  }
+  auto convolverHostObject =
+      std::make_shared<ConvolverNodeHostObject>(convolver);
+  return jsi::Object::createFromHostObject(runtime, convolverHostObject);
+}
 } // namespace audioapi

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

@@ -41,6 +41,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createBuffer);
   JSI_HOST_FUNCTION_DECL(createPeriodicWave);
   JSI_HOST_FUNCTION_DECL(createAnalyser);
+  JSI_HOST_FUNCTION_DECL(createConvolver);
 
   std::shared_ptr<BaseAudioContext> context_;
 

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp

@@ -0,0 +1,47 @@
+#include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+
+namespace audioapi {
+
+ConvolverNodeHostObject::ConvolverNodeHostObject(
+    const std::shared_ptr<ConvolverNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, normalize),
+      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, buffer));
+  addSetters(
+      JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, normalize),
+      JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, buffer));
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, normalize) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  return {convolverNode->getNormalize_()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, buffer) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  auto buffer = convolverNode->getBuffer();
+  auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+  return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+}
+
+JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, normalize) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  convolverNode->setNormalize(value.getBool());
+}
+
+JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, buffer) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  if (value.isNull()) {
+    convolverNode->setBuffer(nullptr);
+    return;
+  }
+
+  auto bufferHostObject =
+      value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  convolverNode->setBuffer(bufferHostObject->audioBuffer_);
+}
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+
+namespace audioapi {
+using namespace facebook;
+
+class ConvolverNode;
+
+class ConvolverNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node);
+  JSI_PROPERTY_GETTER_DECL(normalize);
+  JSI_PROPERTY_GETTER_DECL(buffer);
+  JSI_PROPERTY_SETTER_DECL(normalize);
+  JSI_PROPERTY_SETTER_DECL(buffer);
+};
+} // namespace audioapi

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

@@ -41,6 +41,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
  protected:
   friend class AudioNodeManager;
   friend class AudioDestinationNode;
+  friend class ConvolverNode;
 
   BaseAudioContext *context_;
   std::shared_ptr<AudioBus> audioBus_;
@@ -68,10 +69,10 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
 
+  virtual std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   virtual std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>&, int) = 0;
 
   bool isAlreadyProcessed();
-  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   std::shared_ptr<AudioBus> applyChannelCountMode(const std::shared_ptr<AudioBus> &processingBus);
   void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
 
@@ -81,7 +82,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   void disconnectParam(const std::shared_ptr<AudioParam> &param);
 
   void onInputEnabled();
-  void onInputDisabled();
+  virtual void onInputDisabled();
   void onInputConnected(AudioNode *node);
   void onInputDisconnected(AudioNode *node);
 

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

@@ -2,6 +2,7 @@
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/effects/WorkletNode.h>
@@ -182,6 +183,15 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   return analyser;
 }
 
+std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(
+    std::shared_ptr<AudioBuffer> buffer,
+    bool disableNormalization) {
+  auto convolver =
+      std::make_shared<ConvolverNode>(this, buffer, disableNormalization);
+  nodeManager_->addProcessingNode(convolver);
+  return convolver;
+}
+
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }

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

@@ -28,6 +28,7 @@ class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
+class ConvolverNode;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
 class WorkletSourceNode;
@@ -76,6 +77,7 @@ class BaseAudioContext {
       bool disableNormalization,
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
+  std::shared_ptr<ConvolverNode> createConvolver(std::shared_ptr<AudioBuffer> buffer, bool disableNormalization);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;

package/common/cpp/audioapi/core/effects/ConvolverNode.cpp

@@ -0,0 +1,210 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/dsp/FFT.h>
+#include <audioapi/utils/AudioArray.h>
+#include <iostream>
+#include <thread>
+
+namespace audioapi {
+ConvolverNode::ConvolverNode(
+    BaseAudioContext *context,
+    std::shared_ptr<AudioBuffer> buffer,
+    bool disableNormalization)
+    : AudioNode(context),
+      buffer_(nullptr),
+      internalBuffer_(nullptr),
+      signalledToStop_(false),
+      remainingSegments_(0),
+      internalBufferIndex_(0),
+      scaleFactor_(1.0f),
+      intermediateBus_(nullptr) {
+  channelCount_ = 2;
+  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+  normalize_ = !disableNormalization;
+  gainCalibrationSampleRate_ = context->getSampleRate();
+  setBuffer(buffer);
+  audioBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  isInitialized_ = true;
+}
+
+bool ConvolverNode::getNormalize_() const {
+  return normalize_;
+}
+
+const std::shared_ptr<AudioBuffer> &ConvolverNode::getBuffer() const {
+  return buffer_;
+}
+
+void ConvolverNode::setNormalize(bool normalize) {
+  if (normalize_ != normalize) {
+    normalize_ = normalize;
+    if (normalize_ && buffer_)
+      calculateNormalizationScale();
+  }
+  if (!normalize_) {
+    scaleFactor_ = 1.0f;
+  }
+}
+
+void ConvolverNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
+  if (buffer_ != buffer && buffer != nullptr) {
+    buffer_ = buffer;
+    if (normalize_)
+      calculateNormalizationScale();
+    threadPool_ = std::make_shared<ThreadPool>(4);
+    convolvers_.clear();
+    for (int i = 0; i < buffer->getNumberOfChannels(); ++i) {
+      convolvers_.emplace_back();
+      AudioArray channelData(buffer->getLength());
+      memcpy(
+          channelData.getData(),
+          buffer->getChannelData(i),
+          buffer->getLength() * sizeof(float));
+      convolvers_.back().init(
+          RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
+    }
+    if (buffer->getNumberOfChannels() == 1) {
+      // add one more convolver, because right now input is always stereo
+      convolvers_.emplace_back();
+      AudioArray channelData(buffer->getLength());
+      memcpy(
+          channelData.getData(),
+          buffer->getChannelData(0),
+          buffer->getLength() * sizeof(float));
+      convolvers_.back().init(
+          RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
+    }
+    internalBuffer_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE * 2, channelCount_, buffer->getSampleRate());
+    intermediateBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, convolvers_.size(), buffer->getSampleRate());
+    internalBufferIndex_ = 0;
+  }
+}
+
+void ConvolverNode::onInputDisabled() {
+  numberOfEnabledInputNodes_ -= 1;
+  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
+    signalledToStop_ = true;
+    remainingSegments_ = convolvers_.at(0).getSegCount();
+  }
+}
+
+std::shared_ptr<AudioBus> ConvolverNode::processInputs(
+    const std::shared_ptr<AudioBus> &outputBus,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  if (internalBufferIndex_ < framesToProcess) {
+    return AudioNode::processInputs(outputBus, RENDER_QUANTUM_SIZE, false);
+  }
+  return AudioNode::processInputs(outputBus, 0, false);
+}
+
+// processing pipeline: processingBus -> intermediateBus_ -> audioBus_ (mixing
+// with intermediateBus_)
+std::shared_ptr<AudioBus> ConvolverNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (signalledToStop_) {
+    if (remainingSegments_ > 0) {
+      remainingSegments_--;
+    } else {
+      disable();
+      signalledToStop_ = false;
+      internalBufferIndex_ = 0;
+      return processingBus;
+    }
+  }
+  if (internalBufferIndex_ < framesToProcess) {
+    performConvolution(processingBus); // result returned to intermediateBus_
+    audioBus_->sum(intermediateBus_.get());
+
+    internalBuffer_->copy(
+        audioBus_.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
+    internalBufferIndex_ += RENDER_QUANTUM_SIZE;
+  }
+  audioBus_->zero();
+  audioBus_->copy(internalBuffer_.get(), 0, 0, framesToProcess);
+  int remainingFrames = internalBufferIndex_ - framesToProcess;
+  if (remainingFrames > 0) {
+    for (int i = 0; i < internalBuffer_->getNumberOfChannels(); ++i) {
+      memmove(
+          internalBuffer_->getChannel(i)->getData(),
+          internalBuffer_->getChannel(i)->getData() + framesToProcess,
+          remainingFrames * sizeof(float));
+    }
+  }
+  internalBufferIndex_ -= framesToProcess;
+
+  for (int i = 0; i < audioBus_->getNumberOfChannels(); ++i) {
+    dsp::multiplyByScalar(
+        audioBus_->getChannel(i)->getData(),
+        scaleFactor_,
+        audioBus_->getChannel(i)->getData(),
+        framesToProcess);
+  }
+
+  return audioBus_;
+}
+
+void ConvolverNode::calculateNormalizationScale() {
+  int numberOfChannels = buffer_->getNumberOfChannels();
+  int length = buffer_->getLength();
+
+  float power = 0;
+
+  for (int channel = 0; channel < numberOfChannels; ++channel) {
+    float channelPower = 0;
+    auto channelData = buffer_->getChannelData(channel);
+    for (int i = 0; i < length; ++i) {
+      float sample = channelData[i];
+      channelPower += sample * sample;
+    }
+    power += channelPower;
+  }
+
+  power = std::sqrt(power / (numberOfChannels * length));
+  if (power < MIN_IR_POWER) {
+    power = MIN_IR_POWER;
+  }
+  scaleFactor_ = 1 / power;
+  scaleFactor_ *= std::pow(10, GAIN_CALIBRATION * 0.05f);
+  scaleFactor_ *= gainCalibrationSampleRate_ / buffer_->getSampleRate();
+}
+
+void ConvolverNode::performConvolution(
+    const std::shared_ptr<AudioBus> &processingBus) {
+  if (processingBus->getNumberOfChannels() == 1) {
+    for (int i = 0; i < convolvers_.size(); ++i) {
+      threadPool_->schedule([&, i] {
+        convolvers_[i].process(
+            processingBus->getChannel(0)->getData(),
+            intermediateBus_->getChannel(i)->getData());
+      });
+    }
+  } else if (processingBus->getNumberOfChannels() == 2) {
+    std::vector<int> inputChannelMap;
+    std::vector<int> outputChannelMap;
+    if (convolvers_.size() == 2) {
+      inputChannelMap = {0, 1};
+      outputChannelMap = {0, 1};
+    } else { // 4 channel IR
+      inputChannelMap = {0, 0, 1, 1};
+      outputChannelMap = {0, 3, 2, 1};
+    }
+    for (int i = 0; i < convolvers_.size(); ++i) {
+      threadPool_->schedule(
+          [this, i, inputChannelMap, outputChannelMap, &processingBus] {
+            convolvers_[i].process(
+                processingBus->getChannel(inputChannelMap[i])->getData(),
+                intermediateBus_->getChannel(outputChannelMap[i])->getData());
+          });
+    }
+  }
+  threadPool_->wait();
+}
+} // namespace audioapi

package/common/cpp/audioapi/core/effects/ConvolverNode.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/dsp/Convolver.h>
+
+#include <memory>
+#include <vector>
+
+#include <audioapi/utils/ThreadPool.hpp>
+
+static constexpr int GAIN_CALIBRATION = -58; // magic number so that processed signal and dry signal have roughly the same volume
+static constexpr double MIN_IR_POWER = 0.000125;
+
+namespace audioapi {
+
+class AudioBus;
+class AudioBuffer;
+
+class ConvolverNode : public AudioNode {
+ public:
+    explicit ConvolverNode(BaseAudioContext *context, std::shared_ptr<AudioBuffer> buffer, bool disableNormalization);
+
+    [[nodiscard]] bool getNormalize_() const;
+    [[nodiscard]] const std::shared_ptr<AudioBuffer> &getBuffer() const;
+    void setNormalize(bool normalize);
+    void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
+  void onInputDisabled() override;
+  float gainCalibrationSampleRate_;
+  size_t remainingSegments_;
+  size_t internalBufferIndex_;
+  bool normalize_;
+  bool signalledToStop_;
+  float scaleFactor_;
+  std::shared_ptr<AudioBus>intermediateBus_;
+
+  // impulse response buffer
+  std::shared_ptr<AudioBuffer> buffer_;
+  // buffer to hold internal processed data
+  std::shared_ptr<AudioBus> internalBuffer_;
+  // vectors of convolvers, one per channel
+  std::vector<Convolver> convolvers_;
+  std::shared_ptr<ThreadPool> threadPool_;
+
+  void calculateNormalizationScale();
+  void performConvolution(const std::shared_ptr<AudioBus>& processingBus);
+};
+
+} // namespace audioapi

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

@@ -25,14 +25,12 @@ 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) {}
+      maxResampledSamples_(0),
+      processedSamples_(0) {}
 
 StreamerNode::~StreamerNode() {
   cleanup();
@@ -66,24 +64,30 @@ 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());
 
+  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);
+  streamFlag.store(true, std::memory_order_release);
   isInitialized_ = true;
   return true;
 }
 
 void StreamerNode::stop(double when) {
   AudioScheduledSourceNode::stop(when);
-  streamFlag.store(false);
+  streamFlag.store(false, std::memory_order_release);
+  StreamingData dummy;
+  while (receiver_.try_receive(dummy) ==
+         channels::spsc::ResponseStatus::SUCCESS)
+    ; // clear the receiver
 }
 
 bool StreamerNode::setupResampler() {
@@ -122,29 +126,22 @@ bool StreamerNode::setupResampler() {
 }
 
 void StreamerNode::streamAudio() {
-  while (streamFlag.load()) {
-    if (pendingFrame_ != nullptr) {
-      if (!processFrameWithResampler(pendingFrame_)) {
+  while (streamFlag.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));
+    av_packet_unref(pkt_);
   }
 }
 
@@ -160,28 +157,33 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
     return processingBus;
   }
 
-  // If we have enough buffered data, copy to output bus
-  if (bufferedBusIndex_ >= framesToProcess) {
-    Locker locker(mutex_);
+  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;
+    receiver_.try_receive(data);
+    bufferedBus_ = std::make_shared<AudioBus>(std::move(data.bus));
+    bufferedBusSize_ = data.size;
+    processedSamples_ = 0;
+  }
+  if (bufferedBus_ != nullptr) {
     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));
+          processingBus->getChannel(ch)->getData() + alreadyProcessed,
+          bufferedBus_->getChannel(ch)->getData() + processedSamples_,
+          framesToProcess * sizeof(float));
     }
-    bufferedBusIndex_ -= offsetLength;
-  } else {
-    if (VERBOSE)
-      printf(
-          "Buffer underrun: have %zu, need %zu\n",
-          bufferedBusIndex_,
-          (size_t)framesToProcess);
-    processingBus->zero();
+    processedSamples_ += framesToProcess;
   }
 
   return processingBus;
@@ -220,22 +222,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 (!streamFlag.load(std::memory_order_acquire)) {
     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,7 +281,7 @@ bool StreamerNode::setupDecoder() {
 }
 
 void StreamerNode::cleanup() {
-  streamFlag.store(false);
+  streamFlag.store(false, std::memory_order_release);
   // cleanup cannot be called from the streaming thread so there is no need to
   // check if we are in the same thread
   streamingThread_.join();