react-native-audio-api 0.11.0-alpha.0 → 0.11.0-nightly-bfab178-20251107

package/common/cpp/test/src/biquad/BiquadFilterTest.cpp

@@ -0,0 +1,284 @@
+#include <test/src/biquad/BiquadFilterChromium.h>
+#include <test/src/biquad/BiquadFilterTest.h>
+
+namespace audioapi {
+
+void BiquadFilterTest::expectCoefficientsNear(
+    const std::shared_ptr<BiquadFilterNode> &biquadNode,
+    const BiquadCoefficients &expected) {
+  EXPECT_NEAR(biquadNode->b0_, expected.b0, tolerance);
+  EXPECT_NEAR(biquadNode->b1_, expected.b1, tolerance);
+  EXPECT_NEAR(biquadNode->b2_, expected.b2, tolerance);
+  EXPECT_NEAR(biquadNode->a1_, expected.a1, tolerance);
+  EXPECT_NEAR(biquadNode->a2_, expected.a2, tolerance);
+}
+
+void BiquadFilterTest::testLowpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateLowpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testHighpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateHighpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testBandpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setBandpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateBandpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testNotch(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setNotchCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateNotchCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testAllpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setAllpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateAllpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testPeaking(float frequency, float Q, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setPeakingCoefficients(normalizedFrequency, Q, gain);
+  expectCoefficientsNear(
+      node, calculatePeakingCoefficients(normalizedFrequency, Q, gain));
+}
+
+void BiquadFilterTest::testLowshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(
+      node, calculateLowshelfCoefficients(normalizedFrequency, gain));
+}
+
+void BiquadFilterTest::testHighshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(
+      node, calculateHighshelfCoefficients(normalizedFrequency, gain));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    Frequencies,
+    BiquadFilterFrequencyTest,
+    ::testing::Values(
+        0.0f, // 0 Hz - the filter should block all input signal
+        10.0f, // very low frequency
+        350.0f, // default
+        nyquistFrequency - 0.0001f, // frequency near Nyquist
+        nyquistFrequency)); // maximal frequency
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestLowpassHighpass,
+    ::testing::Values(
+        -770.63678f, // min value for lowpass and highpass
+        0.0f, // default
+        770.63678f)); // max value for lowpass and highpass
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestRestTypes, // bandpass, notch, allpass, peaking
+    ::testing::Values(
+        0.0f, // default and min value
+        MOST_POSITIVE_SINGLE_FLOAT));
+
+INSTANTIATE_TEST_SUITE_P(
+    GainEdgeCases,
+    BiquadFilterGainTest,
+    ::testing::Values(
+        -40.0f,
+        0.0f, // default
+        40.0f));
+
+TEST_P(BiquadFilterFrequencyTest, SetLowpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetBandpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetNotchCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetAllpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetPeakingCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetLowshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testHighshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetLowpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetHighpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetBandpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetNotchCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetAllpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float gain = GetParam();
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetLowshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetHighshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testHighshelf(frequency, gain);
+}
+
+TEST_F(BiquadFilterTest, GetFrequencyResponse) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  auto coeffs = calculateLowpassCoefficients(normalizedFrequency, Q);
+
+  std::vector<float> TestFrequencies = {
+      -0.0001f,
+      0.0f,
+      0.0001f,
+      0.25f * nyquistFrequency,
+      0.5f * nyquistFrequency,
+      0.75f * nyquistFrequency,
+      nyquistFrequency - 0.0001f,
+      nyquistFrequency,
+      nyquistFrequency + 0.0001f};
+
+  std::vector<float> magResponseNode(TestFrequencies.size());
+  std::vector<float> phaseResponseNode(TestFrequencies.size());
+  std::vector<float> magResponseExpected(TestFrequencies.size());
+  std::vector<float> phaseResponseExpected(TestFrequencies.size());
+
+  node->getFrequencyResponse(
+      TestFrequencies.data(),
+      magResponseNode.data(),
+      phaseResponseNode.data(),
+      TestFrequencies.size());
+  getFrequencyResponse(
+      coeffs,
+      TestFrequencies,
+      magResponseExpected,
+      phaseResponseExpected,
+      nyquistFrequency);
+
+  for (size_t i = 0; i < TestFrequencies.size(); ++i) {
+    float f = TestFrequencies[i];
+    if (std::isnan(magResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(magResponseNode[i]))
+          << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(magResponseNode[i], magResponseExpected[i], tolerance)
+          << "Magnitude mismatch at " << f << " Hz";
+    }
+
+    if (std::isnan(phaseResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(phaseResponseNode[i]))
+          << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(phaseResponseNode[i], phaseResponseExpected[i], tolerance)
+          << "Phase mismatch at " << f << " Hz";
+    }
+  }
+}
+
+} // namespace audioapi

package/common/cpp/test/src/biquad/BiquadFilterTest.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+static constexpr int sampleRate = 44100;
+static constexpr float nyquistFrequency = sampleRate / 2.0f;
+static constexpr float tolerance = 0.0001f;
+
+namespace audioapi {
+class BiquadFilterTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+
+  void expectCoefficientsNear(const std::shared_ptr<BiquadFilterNode> &node, const BiquadCoefficients &expected);
+  void testLowpass(float frequency, float Q);
+  void testHighpass(float frequency, float Q);
+  void testBandpass(float frequency, float Q);
+  void testNotch(float frequency, float Q);
+  void testAllpass(float frequency, float Q);
+  void testPeaking(float frequency, float Q, float gain);
+  void testLowshelf(float frequency, float gain);
+  void testHighshelf(float frequency, float gain);
+};
+
+class BiquadFilterQTestLowpassHighpass : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+class BiquadFilterQTestRestTypes : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+class BiquadFilterFrequencyTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+class BiquadFilterGainTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+} // namespace audioapi

package/ios/audioapi/ios/AudioAPIModule.h

@@ -1,5 +1,6 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTCallInvokerModule.h>
+#import <React/RCTInvalidating.h>
 #import <rnaudioapi/rnaudioapi.h>
 #else // RCT_NEW_ARCH_ENABLED
 #import <React/RCTBridgeModule.h>
@@ -14,7 +15,7 @@
 
 @interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
-                            <NativeAudioAPIModuleSpec, RCTCallInvokerModule>
+                            <NativeAudioAPIModuleSpec, RCTCallInvokerModule, RCTInvalidating>
 #else
                             <RCTBridgeModule>
 #endif // RCT_NEW_ARCH_ENABLED

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -54,6 +54,8 @@ RCT_EXPORT_MODULE(AudioAPIModule);
 
   _eventHandler = nullptr;
 
+  audioapi::AudioAPIModuleInstaller::closeAllContexts();
+
   [super invalidate];
 }
 
@@ -116,6 +118,9 @@ RCT_EXPORT_METHOD(
     setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
         reject)
 {
+  if (!self.audioSessionManager.shouldManageSession) {
+    [self.audioSessionManager setShouldManageSession:true];
+  }
   if ([self.audioSessionManager setActive:enabled]) {
     resolve(@"true");
     return;
@@ -128,6 +133,9 @@ RCT_EXPORT_METHOD(
     setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
         options allowHaptics : (BOOL)allowHaptics)
 {
+  if (!self.audioSessionManager.shouldManageSession) {
+    [self.audioSessionManager setShouldManageSession:true];
+  }
   [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options allowHaptics:allowHaptics];
 }
 
@@ -180,6 +188,11 @@ RCT_EXPORT_METHOD(
   [self.audioSessionManager getDevicesInfo:resolve reject:reject];
 }
 
+RCT_EXPORT_METHOD(disableSessionManagement)
+{
+  [self.audioSessionManager disableSessionManagement];
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -1,11 +1,8 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as C++
+#ifdef __OBJC__ // when compiled as Objective-C++
 #import <NativeAudioRecorder.h>
-#else
-typedef struct objc_object AVAudioFile;
-typedef struct objc_object NSURL;
-typedef struct objc_object AudioBufferList;
+#else // when compiled as C++
 typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
@@ -15,27 +12,21 @@ namespace audioapi {
 
 class AudioBus;
 class CircularAudioArray;
-class IOSAudioFileWriter;
-class AudioEventHandlerRegistry;
 
 class IOSAudioRecorder : public AudioRecorder {
  public:
-  IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  IOSAudioRecorder(
+      float sampleRate,
+      int bufferLength,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+
   ~IOSAudioRecorder() override;
 
   void start() override;
-  std::string stop() override;
-
-  void enableFileOutput(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags, size_t androidFlags)
-      override;
-  void disableFileOutput() override;
-
-  void pause() override;
-  void resume() override;
+  void stop() override;
 
  private:
-  std::shared_ptr<IOSAudioFileWriter> fileWriter_;
-  NativeAudioRecorder *nativeRecorder_;
+  NativeAudioRecorder *audioRecorder_;
 };
 
 } // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -1,112 +1,70 @@
 #import <AVFoundation/AVFoundation.h>
-#import <Foundation/Foundation.h>
-#include <unordered_map>
 
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/ios/core/IOSAudioFileWriter.h>
 #include <audioapi/ios/core/IOSAudioRecorder.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <unordered_map>
 
 namespace audioapi {
 
-// AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-//   if (isRunning_.load()) {
-//     auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
-//     writeToBuffers(inputChannel, numFrames);
-//   }
-
-//   while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-//     auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-//     auto *outputChannel = bus->getChannel(0)->getData();
+IOSAudioRecorder::IOSAudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
+{
+  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
+    if (isRunning_.load()) {
+      auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
+      writeToBuffers(inputChannel, numFrames);
+    }
 
-//     circularBuffer_->pop_front(outputChannel, bufferLength_);
+    while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
+      auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
+      auto *outputChannel = bus->getChannel(0)->getData();
 
-//     invokeOnAudioReadyCallback(bus, bufferLength_);
-//   }
-// };
+      circularBuffer_->pop_front(outputChannel, bufferLength_);
 
-IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(audioEventHandlerRegistry), fileWriter_(nullptr)
-{
-  AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (usesFileOutput()) {
-      fileWriter_->writeAudioData(inputBuffer, numFrames);
+      invokeOnAudioReadyCallback(bus, bufferLength_);
     }
   };
 
-  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
+  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
+                                                         bufferLength:bufferLength
+                                                           sampleRate:sampleRate];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
 {
   stop();
-  [nativeRecorder_ cleanup];
+  [audioRecorder_ cleanup];
 }
 
 void IOSAudioRecorder::start()
 {
-  if (isRecording()) {
+  if (isRunning_.load()) {
     return;
   }
 
-  if (usesFileOutput()) {
-    fileWriter_->openFile([nativeRecorder_ getInputFormat]);
-  }
-
-  if (usesCallback()) {
-    // TODO: create circular buffer and converter?
-  }
-
-  if (isConnected()) {
-    // TODO: set adapter node properties?
-  }
-
-  [nativeRecorder_ start];
+  [audioRecorder_ start];
   isRunning_.store(true);
 }
 
-std::string IOSAudioRecorder::stop()
+void IOSAudioRecorder::stop()
 {
-  if (!isRecording()) {
-    return std::string("");
+  if (!isRunning_.load()) {
+    return;
   }
 
-  [nativeRecorder_ stop];
   isRunning_.store(false);
+  [audioRecorder_ stop];
 
-  // TODO: send remaining data?
-
-  if (usesFileOutput()) {
-    return fileWriter_->closeFile();
-  }
-
-  return std::string("");
+  sendRemainingData();
 }
 
-void IOSAudioRecorder::enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags)
-{
-  fileOutputEnabled_.store(true);
-  fileWriter_ = std::make_shared<IOSAudioFileWriter>(sampleRate, channelCount, bitRate, iosFlags);
-}
-
-void IOSAudioRecorder::disableFileOutput()
-{
-  fileOutputEnabled_.store(false);
-  fileWriter_ = nullptr;
-}
-
-void IOSAudioRecorder::pause() {}
-
-void IOSAudioRecorder::resume() {}
-
 } // namespace audioapi

package/ios/audioapi/ios/core/NativeAudioRecorder.h

@@ -14,9 +14,13 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 @property (nonatomic, copy) AVAudioSinkNodeReceiverBlock receiverSinkBlock;
 @property (nonatomic, copy) AudioReceiverBlock receiverBlock;
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
+@property (nonatomic, strong) AVAudioConverter *audioConverter;
+@property (nonatomic, strong) AVAudioFormat *inputFormat;
+@property (nonatomic, strong) AVAudioFormat *outputFormat;
 
-- (AVAudioFormat *)getInputFormat;
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
+                         bufferLength:(int)bufferLength
+                           sampleRate:(float)sampleRate;
 
 - (void)start;
 

package/ios/audioapi/ios/core/NativeAudioRecorder.m

@@ -5,18 +5,40 @@
 @implementation NativeAudioRecorder
 
 - (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
+                         bufferLength:(int)bufferLength
+                           sampleRate:(float)sampleRate
 {
   if (self = [super init]) {
+    self.bufferLength = bufferLength;
+    self.sampleRate = sampleRate;
+
     self.receiverBlock = [receiverBlock copy];
 
+    float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
+
+    if (!devicePrefferedSampleRate) {
+      NSError *error;
+      devicePrefferedSampleRate = sampleRate;
+
+      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate error:&error];
+    }
+
+    self.inputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                        sampleRate:devicePrefferedSampleRate
+                                                          channels:1
+                                                       interleaved:NO];
+    self.outputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                         sampleRate:sampleRate
+                                                           channels:1
+                                                        interleaved:NO];
+    self.audioConverter = [[AVAudioConverter alloc] initFromFormat:self.inputFormat toFormat:self.outputFormat];
+
     __weak typeof(self) weakSelf = self;
     self.receiverSinkBlock = ^OSStatus(
         const AudioTimeStamp *_Nonnull timestamp,
         AVAudioFrameCount frameCount,
         const AudioBufferList *_Nonnull inputData) {
-      weakSelf.receiverBlock(inputData, frameCount);
-
-      return kAudioServicesNoError;
+      return [weakSelf processAudioInput:inputData withFrameCount:frameCount atTimestamp:timestamp];
     };
 
     self.sinkNode = [[AVAudioSinkNode alloc] initWithReceiverBlock:self.receiverSinkBlock];
@@ -25,9 +47,55 @@
   return self;
 }
 
-- (AVAudioFormat *)getInputFormat
+- (OSStatus)processAudioInput:(const AudioBufferList *)inputData
+               withFrameCount:(AVAudioFrameCount)frameCount
+                  atTimestamp:(const AudioTimeStamp *)timestamp
 {
-  return [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
+  float inputSampleRate = self.inputFormat.sampleRate;
+  float outputSampleRate = self.outputFormat.sampleRate;
+
+  if (inputSampleRate != outputSampleRate) {
+    AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.inputFormat
+                                                                  frameCapacity:frameCount];
+    memcpy(
+        inputBuffer.mutableAudioBufferList->mBuffers[0].mData,
+        inputData->mBuffers[0].mData,
+        inputData->mBuffers[0].mDataByteSize);
+    inputBuffer.frameLength = frameCount;
+
+    int outputFrameCount = frameCount * outputSampleRate / inputSampleRate;
+
+    AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.audioConverter.outputFormat
+                                                                   frameCapacity:outputFrameCount];
+
+    NSError *error = nil;
+    AVAudioConverterInputBlock inputBlock =
+        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return inputBuffer;
+    };
+
+    /// IMPORTANT: AVAudioConverter leaks memory without autorelease pool
+    /// more details here: https://github.com/poneciak57/AVAudioConverter-memory-leak-repro-electric-boogaloo
+    /// we can try to remove it in the future or refactor to reuse buffers to minimize allocations
+    @autoreleasepool {
+      [self.audioConverter convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
+    }
+
+    if (error) {
+      NSLog(@"Error during audio conversion: %@", error.localizedDescription);
+      return kAudioServicesBadSpecifierSizeError;
+    }
+
+    self.receiverBlock(outputBuffer.audioBufferList, outputBuffer.frameLength);
+
+    return kAudioServicesNoError;
+  }
+
+  self.receiverBlock(inputData, frameCount);
+
+  return kAudioServicesNoError;
 }
 
 - (void)start