react-native-audio-api 0.4.12-beta.4 → 0.4.12

package/common/cpp/audioapi/dsp/Windows.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <cmath>
+#include <algorithm>
+
+namespace audioapi::dsp {
+
+// https://en.wikipedia.org/wiki/Window_function
+// https://personalpages.hs-kempten.de/~vollratj/InEl/pdf/Window%20function%20-%20Wikipedia.pdf
+class WindowFunction {
+ public:
+  explicit WindowFunction(float amplitude = 1.0f): amplitude_(amplitude) {}
+
+  virtual void apply(float *data, int size) const = 0;
+  // forces STFT perfect-reconstruction (WOLA) on an existing window, for a given STFT interval.
+  static void forcePerfectReconstruction(float *data, int windowLength, int interval);
+
+ protected:
+  // 1/L = amplitude
+  float amplitude_;
+};
+
+//https://en.wikipedia.org/wiki/Hann_function
+// https://www.sciencedirect.com/topics/engineering/hanning-window
+// https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.hann.html#scipy.signal.windows.hann
+class Hann: public WindowFunction {
+ public:
+  explicit Hann(float amplitude = 1.0f): WindowFunction(amplitude) {}
+
+  void apply(float *data, int size) const override;
+};
+
+// https://www.sciencedirect.com/topics/engineering/blackman-window
+// https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.blackman.html#scipy.signal.windows.blackman
+class Blackman: public WindowFunction {
+ public:
+  explicit Blackman(float amplitude = 1.0f): WindowFunction(amplitude) {}
+
+  void apply(float *data, int size) const override;
+};
+
+
+// https://en.wikipedia.org/wiki/Kaiser_window
+class Kaiser: public WindowFunction {
+ public:
+  explicit Kaiser(float beta, float amplitude = 1.0f): WindowFunction(amplitude), beta_(beta), invB0_(1.0f / bessel0(beta)) {}
+
+  static Kaiser withBandwidth(float bandwidth, bool heuristicOptimal = false, float amplitude = 1.0f) {
+    return Kaiser(bandwidthToBeta(bandwidth, heuristicOptimal), amplitude);
+  }
+
+  void apply(float *data, int size) const override;
+
+ private:
+  // beta = pi * alpha
+  // invB0 = 1 / I0(beta)
+  float beta_;
+  float invB0_;
+
+  // https://en.wikipedia.org/wiki/Bessel_function#Modified_Bessel_functions:_I%CE%B1,_K%CE%B1
+  static inline float bessel0(float x) {
+      const double significanceLimit = 1e-4;
+      auto result = 0.0f;
+      auto term = 1.0f;
+      auto m = 1.0f;
+      while (term > significanceLimit) {
+          result += term;
+          ++m;
+          term *= (x * x) / (4 * m * m);
+      }
+
+      return result;
+  }
+  static float bandwidthToBeta(float bandwidth, bool heuristicOptimal = false);
+};
+
+// https://www.recordingblogs.com/wiki/gaussian-window
+class ApproximateConfinedGaussian: public WindowFunction {
+ public:
+  explicit ApproximateConfinedGaussian(float sigma, float amplitude = 1.0f): WindowFunction(amplitude), gaussianFactor_(0.0625f/(sigma*sigma)) {}
+
+  static ApproximateConfinedGaussian withBandwidth(float bandwidth, float amplitude = 1.0f) {
+    return ApproximateConfinedGaussian(bandwidthToSigma(bandwidth), amplitude);
+  }
+
+  void apply(float *data, int size) const override;
+
+ private:
+  float gaussianFactor_;
+
+  static float bandwidthToSigma(float bandwidth);
+
+  [[nodiscard]] float getGaussian(float x) const;
+};
+} // namespace audioapi::dsp

package/{android/src/main/cpp/audioapi/android/libs → common/cpp/audioapi/libs/pffft}/pffft.c

@@ -61,7 +61,7 @@
 #  define _USE_MATH_DEFINES // ask gently MSVC to define M_PI, M_SQRT2 etc.
 #endif
 
-#include <audioapi/android/libs/pffft.h>
+#include <audioapi/libs/pffft/pffft.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>

package/common/cpp/audioapi/libs/{dsp → signalsmith-stretch}/delay.h

@@ -1,5 +1,3 @@
-#include <audioapi/libs/dsp/common.h>
-
 #ifndef SIGNALSMITH_DSP_DELAY_H
 #define SIGNALSMITH_DSP_DELAY_H
 
@@ -7,10 +5,10 @@
 #include <array>
 #include <cmath> // for std::ceil()
 #include <type_traits>
-
 #include <complex>
-#include <audioapi/libs/dsp/fft.h>
-#include <audioapi/libs/dsp/windows.h>
+
+#include <audioapi/libs/signalsmith-stretch/fft.h>
+#include <audioapi/dsp/Windows.h>
 
 namespace signalsmith {
 namespace delay {
@@ -482,14 +480,14 @@ namespace delay {
 		InterpolatorKaiserSincN(double passFreq) : InterpolatorKaiserSincN(passFreq, 1 - passFreq) {}
 		InterpolatorKaiserSincN(double passFreq, double stopFreq) {
 			subSampleSteps = 2*n; // Heuristic again.  Really it depends on the bandwidth as well.
-			double kaiserBandwidth = (stopFreq - passFreq)*(n + 1.0/subSampleSteps);
-			kaiserBandwidth += 1.25/kaiserBandwidth; // We want to place the first zero, but (because using this to window a sinc essentially integrates it in the freq-domain), our ripples (and therefore zeroes) are out of phase.  This is a heuristic fix.
-			double sincScale = M_PI*(passFreq + stopFreq);
+			float kaiserBandwidth = (stopFreq - passFreq)*(n + 1.0/subSampleSteps);
+			kaiserBandwidth += 1.25f / kaiserBandwidth; // We want to place the first zero, but (because using this to window a sinc essentially integrates it in the freq-domain), our ripples (and therefore zeroes) are out of phase.  This is a heuristic fix.
+			double sincScale = audioapi::PI*(passFreq + stopFreq);
 
 			double centreIndex = n*subSampleSteps*0.5, scaleFactor = 1.0/subSampleSteps;
 			std::vector<Sample> windowedSinc(subSampleSteps*n + 1);
 
-			::signalsmith::windows::Kaiser::withBandwidth(kaiserBandwidth, false).fill(windowedSinc, windowedSinc.size());
+            audioapi::dsp::Kaiser::withBandwidth(kaiserBandwidth, false).apply(windowedSinc.data(), windowedSinc.size());
 
 			for (size_t i = 0; i < windowedSinc.size(); ++i) {
 				double x = (i - centreIndex)*scaleFactor;
@@ -504,7 +502,7 @@ namespace delay {
 			}
 
 			if (minimumPhase) {
-				signalsmith::fft::FFT<Sample> fft(windowedSinc.size()*2, 1);
+				signalsmith::fft::FFT<Sample> fft(windowedSinc.getSize()*2, 1);
 				windowedSinc.resize(fft.size(), 0);
 				std::vector<std::complex<Sample>> spectrum(fft.size());
 				std::vector<std::complex<Sample>> cepstrum(fft.size());
@@ -529,7 +527,7 @@ namespace delay {
 				}
 				fft.ifft(spectrum, cepstrum);
 				windowedSinc.resize(subSampleSteps*n + 1);
-				windowedSinc.shrink_to_fit();
+                windowedSinc.shrink_to_fit();
 				for (size_t i = 0; i < windowedSinc.size(); ++i) {
 					windowedSinc[i] = cepstrum[i].real()*scaling;
 				}

package/common/cpp/audioapi/libs/{dsp → signalsmith-stretch}/fft.h

@@ -1,9 +1,8 @@
-#include <audioapi/libs/dsp/common.h>
-
 #ifndef SIGNALSMITH_FFT_V5
 #define SIGNALSMITH_FFT_V5
 
-#include <audioapi/libs/dsp/perf.h>
+#include <audioapi/libs/signalsmith-stretch/perf.h>
+#include <audioapi/core/Constants.h>
 
 #include <vector>
 #include <complex>
@@ -129,7 +128,7 @@ namespace signalsmith { namespace fft {
 			if (!foundStep) {
 				for (size_t i = 0; i < subLength; ++i) {
 					for (size_t f = 0; f < factor; ++f) {
-						double phase = 2*M_PI*i*f/length;
+						double phase = 2*audioapi::PI*i*f/length;
 						complex twiddle = {V(std::cos(phase)), V(-std::sin(phase))};
 						twiddleVector.push_back(twiddle);
 					}
@@ -212,7 +211,7 @@ namespace signalsmith { namespace fft {
 					for (size_t f = 0; f < factor; ++f) {
 						complex sum = working[0];
 						for (size_t i = 1; i < factor; ++i) {
-							double phase = 2*M_PI*f*i/factor;
+							double phase = 2*audioapi::PI*f*i/factor;
 							complex twiddle = {V(std::cos(phase)), V(-std::sin(phase))};
 							sum += _fft_impl::complexMul<inverse>(working[i], twiddle);
 						}
@@ -431,13 +430,13 @@ namespace signalsmith { namespace fft {
 			size_t hhSize = size/4 + 1;
 			twiddlesMinusI.resize(hhSize);
 			for (size_t i = 0; i < hhSize; ++i) {
-				V rotPhase = -2*M_PI*(modified ? i + 0.5 : i)/size;
+				V rotPhase = -2*audioapi::PI*(modified ? i + 0.5 : i)/size;
 				twiddlesMinusI[i] = {std::sin(rotPhase), -std::cos(rotPhase)};
 			}
 			if (modified) {
 				modifiedRotations.resize(size/2);
 				for (size_t i = 0; i < size/2; ++i) {
-					V rotPhase = -2*M_PI*i/size;
+					V rotPhase = -2*audioapi::PI*i/size;
 					modifiedRotations[i] = {std::cos(rotPhase), std::sin(rotPhase)};
 				}
 			}

package/common/cpp/audioapi/libs/{dsp → signalsmith-stretch}/perf.h

@@ -1,5 +1,3 @@
-#include <audioapi/libs/dsp/common.h>
-
 #ifndef SIGNALSMITH_DSP_PERF_H
 #define SIGNALSMITH_DSP_PERF_H
 

package/common/cpp/audioapi/libs/{signalsmith-stretch.h → signalsmith-stretch/signalsmith-stretch.h}

@@ -1,10 +1,9 @@
 #ifndef SIGNALSMITH_STRETCH_H
 #define SIGNALSMITH_STRETCH_H
 
-#include <audioapi/libs/dsp/spectral.h>
-#include <audioapi/libs/dsp/delay.h>
-#include <audioapi/libs/dsp/perf.h>
-SIGNALSMITH_DSP_VERSION_CHECK(1, 6, 0); // Check version is compatible
+#include <audioapi/libs/signalsmith-stretch/spectral.h>
+#include <audioapi/libs/signalsmith-stretch/delay.h>
+#include <audioapi/libs/signalsmith-stretch/perf.h>
 #include <vector>
 #include <algorithm>
 #include <functional>

package/common/cpp/audioapi/libs/{dsp → signalsmith-stretch}/spectral.h

@@ -1,12 +1,13 @@
-#include <audioapi/libs/dsp/common.h>
+#include <audioapi/core/Constants.h>
 
 #ifndef SIGNALSMITH_DSP_SPECTRAL_H
 #define SIGNALSMITH_DSP_SPECTRAL_H
 
-#include <audioapi/libs/dsp/perf.h>
-#include <audioapi/libs/dsp/fft.h>
-#include <audioapi/libs/dsp/windows.h>
-#include <audioapi/libs/dsp/delay.h>
+#include <audioapi/libs/signalsmith-stretch/perf.h>
+#include <audioapi/libs/signalsmith-stretch/fft.h>
+#include <audioapi/libs/signalsmith-stretch/delay.h>
+
+#include <audioapi/dsp/Windows.h>
 
 #include <cmath>
 
@@ -76,7 +77,7 @@ namespace spectral {
 		/// Sets the size (using the default Blackman-Harris window)
 		void setSize(int size, int rotateSamples=0) {
 			setSize(size, [](double x) {
-				double phase = 2*M_PI*x;
+				double phase = 2 * audioapi::PI * x;
 				// Blackman-Harris
 				return 0.35875 - 0.48829*std::cos(phase) + 0.14128*std::cos(phase*2) - 0.01168*std::cos(phase*3);
 			}, Sample(0.5), rotateSamples);
@@ -249,16 +250,12 @@ namespace spectral {
 
 			auto &window = fft.setSizeWindow(_fftSize, rotateToZero ? _windowSize/2 : 0);
 			if (windowShape == Window::kaiser) {
-				using Kaiser = ::signalsmith::windows::Kaiser;
 				/// Roughly optimal Kaiser for STFT analysis (forced to perfect reconstruction)
-				auto kaiser_ = Kaiser::withBandwidth(_windowSize/double(_interval), true);
-				kaiser_.fill(window, _windowSize);
+				audioapi::dsp::Kaiser::withBandwidth(_windowSize/_interval, true).apply(window.data(), _windowSize);
 			} else {
-				using Confined = ::signalsmith::windows::ApproximateConfinedGaussian;
-				auto confined = Confined::withBandwidth(_windowSize/double(_interval));
-				confined.fill(window, _windowSize);
+				audioapi::dsp::ApproximateConfinedGaussian::withBandwidth(_windowSize/_interval).apply(window.data(), _windowSize);
 			}
-			::signalsmith::windows::forcePerfectReconstruction(window, _windowSize, _interval);
+            audioapi::dsp::WindowFunction::forcePerfectReconstruction(window.data(), _windowSize, _interval);
 
 			// TODO: fill extra bits of an input buffer with NaN/Infinity, to break this, and then fix by adding zero-padding to WindowedFFT (as opposed to zero-valued window sections)
 			for (int i = _windowSize; i < _fftSize; ++i) {

package/common/cpp/audioapi/{core/utils → utils}/AudioArray.cpp

@@ -1,5 +1,5 @@
-#include <audioapi/core/utils/AudioArray.h>
 #include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
 
 namespace audioapi {
 
@@ -37,7 +37,7 @@ void AudioArray::normalize() {
     return;
   }
 
-  VectorMath::multiplyByScalar(data_, 1.0f / maxAbsValue, data_, size_);
+  dsp::multiplyByScalar(data_, 1.0f / maxAbsValue, data_, size_);
 }
 
 void AudioArray::resize(size_t size) {
@@ -58,11 +58,11 @@ void AudioArray::resize(size_t size) {
 }
 
 void AudioArray::scale(float value) {
-  VectorMath::multiplyByScalar(data_, value, data_, size_);
+  dsp::multiplyByScalar(data_, value, data_, size_);
 }
 
 float AudioArray::getMaxAbsValue() const {
-  return VectorMath::maximumMagnitude(data_, size_);
+  return dsp::maximumMagnitude(data_, size_);
 }
 
 void AudioArray::zero() {
@@ -86,7 +86,7 @@ void AudioArray::sum(
     size_t sourceStart,
     size_t destinationStart,
     size_t length) {
-  VectorMath::add(
+  dsp::add(
       data_ + destinationStart,
       source->getData() + sourceStart,
       data_ + destinationStart,

package/common/cpp/audioapi/{core/utils → utils}/AudioBus.cpp

@@ -1,7 +1,7 @@
 #include <audioapi/core/Constants.h>
-#include <audioapi/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
 
 // Implementation of channel summing/mixing is based on the WebKit approach,
 // source:
@@ -375,12 +375,12 @@ void AudioBus::sumByDownMixing(
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         0.5f,
         destinationData + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         0.5f,
         destinationData + destinationStart,
@@ -401,22 +401,22 @@ void AudioBus::sumByDownMixing(
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         0.25f,
         destinationData + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         0.25f,
         destinationData + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         0.25f,
         destinationData + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         0.25f,
         destinationData + destinationStart,
@@ -438,27 +438,27 @@ void AudioBus::sumByDownMixing(
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         SQRT_HALF,
         destinationData + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         SQRT_HALF,
         destinationData + destinationStart,
         length);
-    VectorMath::add(
+    dsp::add(
         sourceCenter + sourceStart,
         destinationData + destinationStart,
         destinationData + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         0.5f,
         destinationData + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         0.5f,
         destinationData + destinationStart,
@@ -481,23 +481,23 @@ void AudioBus::sumByDownMixing(
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
 
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         0.5f,
         destinationLeft + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         0.5f,
         destinationLeft + destinationStart,
         length);
 
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         0.5f,
         destinationRight + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         0.5f,
         destinationRight + destinationStart,
@@ -521,33 +521,33 @@ void AudioBus::sumByDownMixing(
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
 
-    VectorMath::add(
+    dsp::add(
         sourceLeft + sourceStart,
         destinationLeft + destinationStart,
         destinationLeft + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceCenter + sourceStart,
         SQRT_HALF,
         destinationLeft + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         SQRT_HALF,
         destinationLeft + destinationStart,
         length);
 
-    VectorMath::add(
+    dsp::add(
         sourceRight + sourceStart,
         destinationRight + destinationStart,
         destinationRight + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceCenter + sourceStart,
         SQRT_HALF,
         destinationRight + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         SQRT_HALF,
         destinationRight + destinationStart,
@@ -576,28 +576,28 @@ void AudioBus::sumByDownMixing(
     float *destinationSurroundRight =
         getChannelByType(ChannelSurroundRight)->getData();
 
-    VectorMath::add(
+    dsp::add(
         sourceLeft + sourceStart,
         destinationLeft + destinationStart,
         destinationLeft + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceCenter, SQRT_HALF, destinationLeft + destinationStart, length);
 
-    VectorMath::add(
+    dsp::add(
         sourceRight + sourceStart,
         destinationRight + destinationStart,
         destinationRight + destinationStart,
         length);
-    VectorMath::multiplyByScalarThenAddToOutput(
+    dsp::multiplyByScalarThenAddToOutput(
         sourceCenter, SQRT_HALF, destinationRight + destinationStart, length);
 
-    VectorMath::add(
+    dsp::add(
         sourceSurroundLeft + sourceStart,
         destinationSurroundLeft + destinationStart,
         destinationSurroundLeft + destinationStart,
         length);
-    VectorMath::add(
+    dsp::add(
         sourceSurroundRight + sourceStart,
         destinationSurroundRight + destinationStart,
         destinationSurroundRight + destinationStart,

package/ios/audioapi/ios/core/AudioDecoder.mm

@@ -1,9 +1,9 @@
 #define MINIAUDIO_IMPLEMENTATION
-#import <audioapi/libs/miniaudio.h>
+#import <audioapi/libs/miniaudio/miniaudio.h>
 
-#include <audioapi/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/core/utils/AudioDecoder.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 

package/ios/audioapi/ios/core/AudioPlayer.h

@@ -14,11 +14,14 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 @property (nonatomic, strong) AVAudioSourceNode *sourceNode;
 @property (nonatomic, copy) RenderAudioBlock renderAudio;
 @property (nonatomic, assign) float sampleRate;
+@property (nonatomic, assign) int channelCount;
 @property (nonatomic, assign) bool isRunning;
 
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio;
+- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio channelCount:(int)channelCount;
 
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio sampleRate:(float)sampleRate;
+- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio
+                              sampleRate:(float)sampleRate
+                            channelCount:(int)channelCount;
 
 - (float)getSampleRate;
 

package/ios/audioapi/ios/core/AudioPlayer.m

@@ -2,7 +2,7 @@
 
 @implementation AudioPlayer
 
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio
+- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio channelCount:(int)channelCount
 {
   if (self = [super init]) {
     self.renderAudio = [renderAudio copy];
@@ -14,8 +14,9 @@
     [self setupAndInitNotificationHandlers];
 
     self.sampleRate = [self.audioSession sampleRate];
+    self.channelCount = channelCount;
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:2];
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
 
     __weak typeof(self) weakSelf = self;
     _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
@@ -34,7 +35,9 @@
   return self;
 }
 
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio sampleRate:(float)sampleRate
+- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio
+                              sampleRate:(float)sampleRate
+                            channelCount:(int)channelCount
 {
   if (self = [super init]) {
     self.renderAudio = [renderAudio copy];
@@ -46,8 +49,9 @@
     [self setupAndInitNotificationHandlers];
 
     self.sampleRate = sampleRate;
+    self.channelCount = channelCount;
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:2];
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
 
     __weak typeof(self) weakSelf = self;
     _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
@@ -119,7 +123,7 @@
                              frameCount:(AVAudioFrameCount)frameCount
                              outputData:(AudioBufferList *)outputData
 {
-  if (outputData->mNumberBuffers < 2) {
+  if (outputData->mNumberBuffers < self.channelCount) {
     return noErr; // Ensure we have stereo output
   }
 

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

@@ -18,6 +18,7 @@ class IOSAudioPlayer {
   std::shared_ptr<AudioBus> audioBus_;
   AudioPlayer *audioPlayer_;
   std::function<void(std::shared_ptr<AudioBus>, int)> renderAudio_;
+  int channelCount_;
 
  public:
   explicit IOSAudioPlayer(

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

@@ -1,14 +1,14 @@
 #import <AVFoundation/AVFoundation.h>
 
 #include <audioapi/core/Constants.h>
-#include <audioapi/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/ios/core/IOSAudioPlayer.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
 IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio)
-    : renderAudio_(renderAudio), audioBus_(0)
+    : channelCount_(2), renderAudio_(renderAudio), audioBus_(0)
 {
   RenderAudioBlock renderAudioBlock = ^(AudioBufferList *outputData, int numFrames) {
     int processedFrames = 0;
@@ -18,7 +18,7 @@ IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus
       renderAudio_(audioBus_, framesToProcess);
 
       // TODO: optimize this with SIMD?
-      for (int channel = 0; channel < CHANNEL_COUNT; channel += 1) {
+      for (int channel = 0; channel < channelCount_; channel += 1) {
         float *outputChannel = (float *)outputData->mBuffers[channel].mData;
         auto *inputChannel = audioBus_->getChannel(channel)->getData();
 
@@ -31,12 +31,12 @@ IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus
     }
   };
 
-  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudioBlock:renderAudioBlock];
-  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, CHANNEL_COUNT, getSampleRate());
+  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudioBlock:renderAudioBlock channelCount:channelCount_];
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, getSampleRate());
 }
 
 IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio, float sampleRate)
-    : renderAudio_(renderAudio), audioBus_(0)
+    : channelCount_(2), renderAudio_(renderAudio), audioBus_(0)
 {
   RenderAudioBlock renderAudioBlock = ^(AudioBufferList *outputData, int numFrames) {
     int processedFrames = 0;
@@ -46,7 +46,7 @@ IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus
       renderAudio_(audioBus_, framesToProcess);
 
       // TODO: optimize this with SIMD?
-      for (int channel = 0; channel < CHANNEL_COUNT; channel += 1) {
+      for (int channel = 0; channel < channelCount_; channel += 1) {
         float *outputChannel = (float *)outputData->mBuffers[channel].mData;
         auto *inputChannel = audioBus_->getChannel(channel)->getData();
 
@@ -59,8 +59,10 @@ IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus
     }
   };
 
-  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudioBlock:renderAudioBlock sampleRate:sampleRate];
-  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, CHANNEL_COUNT, getSampleRate());
+  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudioBlock:renderAudioBlock
+                                                    sampleRate:sampleRate
+                                                  channelCount:channelCount_];
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, getSampleRate());
 }
 
 IOSAudioPlayer::~IOSAudioPlayer()