react-native-audio-api 0.1.0 → 0.3.0-rc1

package/common/cpp/wrappers/BaseAudioContextWrapper.cpp

@@ -0,0 +1,83 @@
+#include "BaseAudioContextWrapper.h"
+
+namespace audioapi {
+
+BaseAudioContextWrapper::BaseAudioContextWrapper(
+    const std::shared_ptr<BaseAudioContext> &context)
+    : context_(context) {
+  auto destination = context_->getDestination();
+  destination_ = std::make_shared<AudioDestinationNodeWrapper>(destination);
+}
+
+std::shared_ptr<AudioDestinationNodeWrapper>
+BaseAudioContextWrapper::getDestination() const {
+  return destination_;
+}
+
+std::string BaseAudioContextWrapper::getState() const {
+  return context_->getState();
+}
+
+int BaseAudioContextWrapper::getSampleRate() const {
+  return context_->getSampleRate();
+}
+
+double BaseAudioContextWrapper::getCurrentTime() const {
+  return context_->getCurrentTime();
+}
+
+std::shared_ptr<OscillatorNodeWrapper>
+BaseAudioContextWrapper::createOscillator() const {
+  auto oscillator = context_->createOscillator();
+  return std::make_shared<OscillatorNodeWrapper>(oscillator);
+}
+
+std::shared_ptr<GainNodeWrapper> BaseAudioContextWrapper::createGain() const {
+  auto gain = context_->createGain();
+  return std::make_shared<GainNodeWrapper>(gain);
+}
+
+std::shared_ptr<StereoPannerNodeWrapper>
+BaseAudioContextWrapper::createStereoPanner() const {
+  auto panner = context_->createStereoPanner();
+  return std::make_shared<StereoPannerNodeWrapper>(panner);
+}
+
+std::shared_ptr<BiquadFilterNodeWrapper>
+BaseAudioContextWrapper::createBiquadFilter() const {
+  auto filter = context_->createBiquadFilter();
+  return std::make_shared<BiquadFilterNodeWrapper>(filter);
+}
+
+std::shared_ptr<AudioBufferSourceNodeWrapper>
+BaseAudioContextWrapper::createBufferSource() const {
+  auto bufferSource = context_->createBufferSource();
+  return std::make_shared<AudioBufferSourceNodeWrapper>(bufferSource);
+}
+
+std::shared_ptr<AudioBufferWrapper> BaseAudioContextWrapper::createBuffer(
+    int numberOfChannels,
+    int length,
+    int sampleRate) const {
+  auto buffer = context_->createBuffer(numberOfChannels, length, sampleRate);
+  return std::make_shared<AudioBufferWrapper>(buffer);
+}
+
+std::shared_ptr<PeriodicWaveWrapper>
+BaseAudioContextWrapper::createPeriodicWave(
+    float *real,
+    float *imag,
+    bool disableNormalization,
+    int length) {
+  auto periodicWave =
+      context_->createPeriodicWave(real, imag, disableNormalization, length);
+  return std::make_shared<PeriodicWaveWrapper>(periodicWave);
+}
+
+std::shared_ptr<AudioBufferWrapper>
+BaseAudioContextWrapper::decodeAudioDataSource(const std::string &source) {
+  return std::make_shared<AudioBufferWrapper>(
+      context_->decodeAudioDataSource(source));
+}
+
+} // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "AudioBufferSourceNodeWrapper.h"
+#include "AudioBufferWrapper.h"
+#include "AudioDestinationNodeWrapper.h"
+#include "BaseAudioContext.h"
+#include "BiquadFilterNodeWrapper.h"
+#include "GainNodeWrapper.h"
+#include "OscillatorNodeWrapper.h"
+#include "PeriodicWaveWrapper.h"
+#include "StereoPannerNodeWrapper.h"
+
+namespace audioapi {
+
+class BaseAudioContextWrapper {
+ public:
+  explicit BaseAudioContextWrapper(
+      const std::shared_ptr<BaseAudioContext> &context);
+
+  [[nodiscard]] std::shared_ptr<AudioDestinationNodeWrapper> getDestination()
+      const;
+  [[nodiscard]] std::string getState() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] double getCurrentTime() const;
+  [[nodiscard]] std::shared_ptr<OscillatorNodeWrapper> createOscillator() const;
+  [[nodiscard]] std::shared_ptr<GainNodeWrapper> createGain() const;
+  [[nodiscard]] std::shared_ptr<StereoPannerNodeWrapper> createStereoPanner()
+      const;
+  [[nodiscard]] std::shared_ptr<BiquadFilterNodeWrapper> createBiquadFilter()
+      const;
+  [[nodiscard]] std::shared_ptr<AudioBufferSourceNodeWrapper>
+  createBufferSource() const;
+  [[nodiscard]] std::shared_ptr<AudioBufferWrapper>
+  createBuffer(int numberOfChannels, int length, int sampleRate) const;
+  [[nodiscard]] std::shared_ptr<PeriodicWaveWrapper> createPeriodicWave(
+      float *real,
+      float *imag,
+      bool disableNormalization,
+      int length);
+  std::shared_ptr<AudioBufferWrapper> decodeAudioDataSource(const std::string &source);
+
+ protected:
+  std::shared_ptr<AudioDestinationNodeWrapper> destination_;
+  std::shared_ptr<BaseAudioContext> context_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.cpp

@@ -48,4 +48,13 @@ void BiquadFilterNodeWrapper::setType(const std::string &filterType) {
   auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
   biquadFilterNode_->setType(filterType);
 }
+
+void BiquadFilterNodeWrapper::getFrequencyResponse(
+    const std::vector<float> &frequencyArray,
+    std::vector<float> &magResponseOutput,
+    std::vector<float> &phaseResponseOutput) {
+  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
+  biquadFilterNode_->getFrequencyResponse(
+      frequencyArray, magResponseOutput, phaseResponseOutput);
+}
 } // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "AudioNodeWrapper.h"
 #include "AudioParamWrapper.h"
@@ -14,12 +15,16 @@ class BiquadFilterNodeWrapper : public AudioNodeWrapper {
   explicit BiquadFilterNodeWrapper(
       const std::shared_ptr<BiquadFilterNode> &biquadFilterNode);
 
-  std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
-  std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
-  std::shared_ptr<AudioParamWrapper> getQParam() const;
-  std::shared_ptr<AudioParamWrapper> getGainParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getQParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getGainParam() const;
   std::string getType();
   void setType(const std::string &filterType);
+  void getFrequencyResponse(
+      const std::vector<float> &frequencyArray,
+      std::vector<float> &magResponseOutput,
+      std::vector<float> &phaseResponseOutput);
 
  private:
   std::shared_ptr<AudioParamWrapper> frequencyParam_;

package/common/cpp/wrappers/GainNodeWrapper.h

@@ -12,7 +12,7 @@ class GainNodeWrapper : public AudioNodeWrapper {
  public:
   explicit GainNodeWrapper(const std::shared_ptr<GainNode> &gainNode);
 
-  std::shared_ptr<AudioParamWrapper> getGainParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getGainParam() const;
 
  private:
   std::shared_ptr<AudioParamWrapper> gainParam_;

package/common/cpp/wrappers/OscillatorNodeWrapper.cpp

@@ -35,4 +35,10 @@ void OscillatorNodeWrapper::setType(const std::string &type) {
   auto oscillatorNode_ = getOscillatorNodeFromAudioNode();
   oscillatorNode_->setType(type);
 }
+
+void OscillatorNodeWrapper::setPeriodicWave(
+    const std::shared_ptr<PeriodicWaveWrapper> &periodicWave) {
+  auto oscillatorNode_ = getOscillatorNodeFromAudioNode();
+  oscillatorNode_->setPeriodicWave(periodicWave->periodicWave_);
+}
 } // namespace audioapi

package/common/cpp/wrappers/OscillatorNodeWrapper.h

@@ -6,6 +6,7 @@
 #include "AudioParamWrapper.h"
 #include "AudioScheduledSourceNodeWrapper.h"
 #include "OscillatorNode.h"
+#include "PeriodicWaveWrapper.h"
 
 namespace audioapi {
 
@@ -14,10 +15,12 @@ class OscillatorNodeWrapper : public AudioScheduledSourceNodeWrapper {
   explicit OscillatorNodeWrapper(
       const std::shared_ptr<OscillatorNode> &oscillatorNode);
 
-  std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
-  std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
   std::string getType();
   void setType(const std::string &type);
+  void setPeriodicWave(
+      const std::shared_ptr<PeriodicWaveWrapper> &periodicWave);
 
  private:
   std::shared_ptr<AudioParamWrapper> frequencyParam_;

package/common/cpp/wrappers/PeriodicWaveWrapper.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <memory>
+
+#include "PeriodicWave.h"
+
+namespace audioapi {
+
+class PeriodicWaveWrapper {
+ public:
+  explicit PeriodicWaveWrapper(
+      const std::shared_ptr<PeriodicWave> &periodicWave)
+      : periodicWave_(periodicWave) {}
+
+  std::shared_ptr<PeriodicWave> periodicWave_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/StereoPannerNodeWrapper.h

@@ -13,7 +13,7 @@ class StereoPannerNodeWrapper : public AudioNodeWrapper {
   explicit StereoPannerNodeWrapper(
       const std::shared_ptr<StereoPannerNode> &stereoPannerNode);
 
-  std::shared_ptr<AudioParamWrapper> getPanParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getPanParam() const;
 
  private:
   std::shared_ptr<AudioParamWrapper> panParam_;

package/ios/AudioAPIModule.h

@@ -1,5 +1,24 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTInitializing.h>
+#if REACT_NATIVE_MINOR_VERSION >= 74
+#import <React/RCTRuntimeExecutorModule.h>
+#import <ReactCommon/RCTRuntimeExecutor.h>
+#endif // REACT_NATIVE_MINOR_VERSION >= 74
+#else // RCT_NEW_ARCH_ENABLED
 #import <React/RCTBridgeModule.h>
+#endif // RCT_NEW_ARCH_ENABLED
 
-@interface AudioAPIModule : NSObject <RCTBridgeModule>
+#import <React/RCTEventEmitter.h>
 
+@interface AudioAPIModule : RCTEventEmitter
+#ifdef RCT_NEW_ARCH_ENABLED
+                            <RCTInitializing
+#if REACT_NATIVE_MINOR_VERSION >= 74
+                             ,
+                             RCTRuntimeExecutorModule
+#endif // REACT_NATIVE_MINOR_VERSION >= 74
+#else
+                            <RCTBridgeModule
+#endif // RCT_NEW_ARCH_ENABLED
+                             >
 @end

package/ios/AudioAPIModule.mm

@@ -1,11 +1,13 @@
 #import "AudioAPIModule.h"
 
+#import <ReactCommon/RCTTurboModule.h>
 #import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
 #import <React/RCTUtils.h>
 #import <jsi/jsi.h>
 
-#import "../common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.h"
-#import "../common/cpp/AudioAPIInstaller/AudioAPIInstallerWrapper.h"
+#import "AudioAPIInstallerHostObject.h"
+#import "AudioAPIInstallerWrapper.h"
 
 @implementation AudioAPIModule
 
@@ -14,7 +16,7 @@ RCT_EXPORT_MODULE(AudioAPIModule)
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
   NSLog(@"Installing JSI bindings for react-native-audio-api...");
-  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)[RCTBridge currentBridge];
+  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
 
   if (cxxBridge == nil) {
     NSLog(@"Error during getting bridge!");
@@ -33,7 +35,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   auto &runtime = *jsRuntime;
 
   auto wrapper = std::make_shared<audioapi::AudioAPIInstallerWrapper>();
-  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(wrapper);
+  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(wrapper, jsRuntime, cxxBridge.jsCallInvoker);
   auto object = jsi::Object::createFromHostObject(runtime, hostObject);
   runtime.global().setProperty(runtime, "__AudioAPIInstaller", std::move(object));
 

package/ios/AudioDecoder/AudioDecoder.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+@interface AudioDecoder : NSObject
+
+@property (nonatomic, strong) AVAudioPCMBuffer *buffer;
+@property (nonatomic, assign) int sampleRate;
+
+- (instancetype)initWithSampleRate:(int)sampleRate;
+
+- (const AudioBufferList *)decode:(NSString *)pathOrURL;
+
+- (void)cleanup;
+
+@end

package/ios/AudioDecoder/AudioDecoder.m

@@ -0,0 +1,167 @@
+#import <AudioDecoder.h>
+
+@implementation AudioDecoder
+
+- (instancetype)initWithSampleRate:(int)sampleRate
+{
+  if (self = [super init]) {
+    self.sampleRate = sampleRate;
+  }
+  return self;
+}
+
+- (const AudioBufferList *)decode:(NSString *)pathOrURL
+{
+  // check if the input is a URL or a local file path
+  NSURL *url = [NSURL URLWithString:pathOrURL];
+
+  if (url && url.scheme) {
+    self.buffer = [self decodeWithURL:url];
+  } else {
+    self.buffer = [self decodeWithFilePath:pathOrURL];
+  }
+
+  return self.buffer.audioBufferList;
+}
+
+- (AVAudioPCMBuffer *)decodeWithFilePath:(NSString *)path
+{
+  NSError *error = nil;
+  NSURL *fileURL = [NSURL fileURLWithPath:path];
+  AVAudioFile *audioFile = [[AVAudioFile alloc] initForReading:fileURL error:&error];
+
+  if (error) {
+    NSLog(@"Error occurred while opening the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+  AVAudioPCMBuffer *buffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile processingFormat]
+                                                           frameCapacity:[audioFile length]];
+
+  AVAudioFormat *format = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                           sampleRate:self.sampleRate
+                                                             channels:buffer.audioBufferList->mNumberBuffers
+                                                          interleaved:NO];
+
+  [audioFile readIntoBuffer:buffer error:&error];
+  if (error) {
+    NSLog(@"Error occurred while reading the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+
+  if (self.sampleRate != audioFile.processingFormat.sampleRate) {
+    return [self convertBuffer:buffer ToFormat:format];
+  }
+
+  return buffer;
+}
+
+- (AVAudioPCMBuffer *)decodeWithURL:(NSURL *)url
+{
+  __block NSURL *tempFileURL = nil;
+
+  dispatch_group_t group = dispatch_group_create();
+
+  dispatch_group_enter(group);
+
+  [self downloadFileFromURL:url
+                 completion:^(NSURL *downloadedFileURL, NSError *downloadError) {
+                   if (downloadError) {
+                     NSLog(@"Error downloading file: %@", downloadError.localizedDescription);
+                     tempFileURL = nil;
+                   } else {
+                     tempFileURL = downloadedFileURL;
+                   }
+
+                   dispatch_group_leave(group);
+                 }];
+
+  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+
+  if (!tempFileURL) {
+    NSLog(@"Cannot process given url");
+    return nil;
+  }
+
+  return [self decodeWithFilePath:tempFileURL.path];
+}
+
+- (void)downloadFileFromURL:(NSURL *)url completion:(void (^)(NSURL *tempFileURL, NSError *error))completion
+{
+  // get unique file path in temporary dir
+  NSString *tempDirectory = NSTemporaryDirectory();
+  NSString *timestamp = [NSString stringWithFormat:@"_%@", @((long long)[[NSDate date] timeIntervalSince1970])];
+  NSString *fileNameWithTimestamp = [url.lastPathComponent stringByDeletingPathExtension];
+  fileNameWithTimestamp = [fileNameWithTimestamp stringByAppendingString:timestamp];
+  NSString *fileExtension =
+      [url.pathExtension length] > 0 ? [NSString stringWithFormat:@".%@", url.pathExtension] : @"";
+  NSString *tempFilePath =
+      [tempDirectory stringByAppendingPathComponent:[fileNameWithTimestamp stringByAppendingString:fileExtension]];
+  NSURL *tempFileURL = [NSURL fileURLWithPath:tempFilePath];
+
+  // download file
+  NSURLSession *session = [NSURLSession sharedSession];
+  NSURLSessionDownloadTask *downloadTask = [session
+      downloadTaskWithURL:url
+        completionHandler:^(NSURL *location, NSURLResponse *response, NSError *error) {
+          if (error) {
+            NSLog(@"Error downloading file: %@", error.localizedDescription);
+            if (completion) {
+              completion(nil, error);
+            }
+            return;
+          }
+
+          // move to generated file path in temporary dir
+          NSError *fileError = nil;
+          BOOL success = [[NSFileManager defaultManager] moveItemAtURL:location toURL:tempFileURL error:&fileError];
+          if (success) {
+            NSLog(@"File downloaded successfully to %@", tempFileURL.path);
+            if (completion) {
+              completion(tempFileURL, nil);
+            }
+          } else {
+            NSLog(@"Error moving downloaded file: %@", fileError.localizedDescription);
+            if (completion) {
+              completion(nil, fileError);
+            }
+          }
+        }];
+
+  [downloadTask resume];
+}
+
+- (AVAudioPCMBuffer *)convertBuffer:(AVAudioPCMBuffer *)buffer ToFormat:(AVAudioFormat *)format
+{
+  NSError *error = nil;
+  AVAudioConverter *converter = [[AVAudioConverter alloc] initFromFormat:buffer.format toFormat:format];
+  AVAudioPCMBuffer *convertedBuffer =
+      [[AVAudioPCMBuffer alloc] initWithPCMFormat:format frameCapacity:(AVAudioFrameCount)buffer.frameCapacity];
+
+  AVAudioConverterInputBlock inputBlock =
+      ^AVAudioBuffer *(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+  {
+    if (buffer.frameLength > 0) {
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return buffer;
+    } else {
+      *outStatus = AVAudioConverterInputStatus_NoDataNow;
+      return nil;
+    }
+  };
+
+  [converter convertToBuffer:convertedBuffer error:&error withInputFromBlock:inputBlock];
+
+  if (error) {
+    NSLog(@"Error occurred while converting the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+
+  return convertedBuffer;
+}
+
+- (void)cleanup
+{
+  self.buffer = nil;
+}
+
+@end

package/ios/AudioDecoder/IOSAudioDecoder.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+
+#ifdef __OBJC__ // when compiled as Objective-C++
+#import <AudioDecoder.h>
+#else // when compiled as C++
+typedef struct objc_object AudioDecoder;
+#endif // __OBJC__
+
+namespace audioapi {
+
+class AudioBus;
+
+class IOSAudioDecoder {
+ protected:
+  AudioDecoder *audioDecoder_;
+  int sampleRate_;
+
+ public:
+  IOSAudioDecoder(int sampleRate);
+  ~IOSAudioDecoder();
+
+  AudioBus *decodeWithFilePath(const std::string &path);
+};
+} // namespace audioapi

package/ios/AudioDecoder/IOSAudioDecoder.mm

@@ -0,0 +1,40 @@
+#import <AVFoundation/AVFoundation.h>
+
+#include <AudioArray.h>
+#include <AudioBus.h>
+#include <IOSAudioDecoder.h>
+
+namespace audioapi {
+
+IOSAudioDecoder::IOSAudioDecoder(int sampleRate) : sampleRate_(sampleRate)
+{
+  audioDecoder_ = [[AudioDecoder alloc] initWithSampleRate:sampleRate_];
+}
+
+IOSAudioDecoder::~IOSAudioDecoder()
+{
+  [audioDecoder_ cleanup];
+  audioDecoder_ = nullptr;
+}
+
+AudioBus *IOSAudioDecoder::decodeWithFilePath(const std::string &path)
+{
+  auto bufferList = [audioDecoder_ decode:[NSString stringWithUTF8String:path.c_str()]];
+  AudioBus *audioBus;
+  if (bufferList) {
+    auto numberOfChannels = bufferList->mNumberBuffers;
+    auto size = bufferList->mBuffers[0].mDataByteSize / sizeof(float);
+
+    audioBus = new AudioBus(sampleRate_, size, numberOfChannels);
+
+    for (int i = 0; i < numberOfChannels; i++) {
+      float *data = (float *)bufferList->mBuffers[i].mData;
+      memcpy(audioBus->getChannel(i)->getData(), data, sizeof(float) * size);
+    }
+  } else {
+    audioBus = new AudioBus(sampleRate_, 1, 1);
+  }
+
+  return audioBus;
+}
+} // namespace audioapi

package/ios/AudioPlayer/AudioPlayer.h

@@ -3,7 +3,7 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
-typedef void (^RenderAudioBlock)(float *audioData, int numFrames);
+typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 @interface AudioPlayer : NSObject
 
@@ -12,12 +12,13 @@ typedef void (^RenderAudioBlock)(float *audioData, int numFrames);
 @property (nonatomic, strong) AVAudioFormat *format;
 @property (nonatomic, strong) AVAudioSourceNode *sourceNode;
 @property (nonatomic, copy) RenderAudioBlock renderAudio;
-@property (nonatomic, assign) float *buffer;
 
 - (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio;
 
 - (int)getSampleRate;
 
+- (int)getBufferSizeInFrames;
+
 - (void)start;
 
 - (void)stop;

package/ios/AudioPlayer/AudioPlayer.m

@@ -42,8 +42,6 @@
                                                                                     frameCount:frameCount
                                                                                     outputData:outputData];
                                                 }];
-
-    self.buffer = nil;
   }
 
   return self;
@@ -54,6 +52,19 @@
   return [self.audioSession sampleRate];
 }
 
+- (int)getBufferSizeInFrames
+{
+  // Note: might be important in the future.
+  // For some reason audioSession.IOBufferDuration is always 0.01, which for sample rate of 48k
+  // gives exactly 480 frames, while at the same time frameCount requested by AVAudioSourceEngine
+  // might vary f.e. between 555-560.
+  // preferredIOBufferDuration seems to be double the value (resulting in 960 frames),
+  // which is safer to base our internal AudioBus sizes.
+  // Buut no documentation => no guarantee :)
+  // If something is crackling when it should play silence, start here 📻
+  return (int)(self.audioSession.preferredIOBufferDuration * self.audioSession.sampleRate);
+}
+
 - (void)start
 {
   [self.audioEngine attachNode:self.sourceNode];
@@ -88,8 +99,6 @@
   self.audioEngine = nil;
   self.audioSession = nil;
   self.renderAudio = nil;
-
-  free(_buffer);
 }
 
 - (OSStatus)renderCallbackWithIsSilence:(BOOL *)isSilence
@@ -101,19 +110,7 @@
     return noErr; // Ensure we have stereo output
   }
 
-  if (!self.buffer) {
-    self.buffer = malloc(frameCount * 2 * sizeof(float));
-  }
-
-  float *leftBuffer = (float *)outputData->mBuffers[0].mData;
-  float *rightBuffer = (float *)outputData->mBuffers[1].mData;
-
-  self.renderAudio(self.buffer, frameCount);
-
-  for (int frame = 0; frame < frameCount; frame += 1) {
-    leftBuffer[frame] = self.buffer[frame * 2];
-    rightBuffer[frame] = self.buffer[frame * 2 + 1];
-  }
+  self.renderAudio(outputData, frameCount);
 
   return noErr;
 }

package/ios/AudioPlayer/IOSAudioPlayer.h

@@ -11,19 +11,23 @@ typedef struct objc_object AudioPlayer;
 namespace audioapi {
 
 class AudioContext;
+class AudioBus;
 
 class IOSAudioPlayer {
  protected:
+  AudioBus *audioBus_;
   AudioPlayer *audioPlayer_;
-  std::function<void(float *, int)> renderAudio_;
+  std::function<void(AudioBus *, int)> renderAudio_;
 
  public:
-  explicit IOSAudioPlayer(const std::function<void(float *, int)> &renderAudio);
+  explicit IOSAudioPlayer(
+      const std::function<void(AudioBus *, int)> &renderAudio);
   ~IOSAudioPlayer();
 
   int getSampleRate() const;
+  int getBufferSizeInFrames() const;
+
   void start();
   void stop();
-  void renderAudio(float *audioData, int32_t numFrames);
 };
 } // namespace audioapi