react-native-audio-api 0.6.0-rc.1 → 0.6.0-rc.2

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -18,9 +18,10 @@ AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
       std::make_shared<IOSAudioPlayer>(this->renderAudio(), sampleRate);
 #endif
 
-  sampleRate_ = audioPlayer_->getSampleRate();
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
+  sampleRate_ = sampleRate;
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate);
 
+  state_ = ContextState::RUNNING;
   audioPlayer_->start();
 }
 
@@ -53,7 +54,7 @@ bool AudioContext::suspend() {
   }
 
   state_ = ContextState::SUSPENDED;
-  audioPlayer_->suspend();
+  audioPlayer_->pause();
   return true;
 }
 

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

@@ -43,25 +43,25 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
 
 std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
   auto oscillator = std::make_shared<OscillatorNode>(this);
-  nodeManager_->addNode(oscillator);
+  nodeManager_->addSourceNode(oscillator);
   return oscillator;
 }
 
 std::shared_ptr<GainNode> BaseAudioContext::createGain() {
   auto gain = std::make_shared<GainNode>(this);
-  nodeManager_->addNode(gain);
+  nodeManager_->addProcessingNode(gain);
   return gain;
 }
 
 std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner() {
   auto stereoPanner = std::make_shared<StereoPannerNode>(this);
-  nodeManager_->addNode(stereoPanner);
+  nodeManager_->addProcessingNode(stereoPanner);
   return stereoPanner;
 }
 
 std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
   auto biquadFilter = std::make_shared<BiquadFilterNode>(this);
-  nodeManager_->addNode(biquadFilter);
+  nodeManager_->addProcessingNode(biquadFilter);
   return biquadFilter;
 }
 
@@ -69,7 +69,7 @@ std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
     bool pitchCorrection) {
   auto bufferSource =
       std::make_shared<AudioBufferSourceNode>(this, pitchCorrection);
-  nodeManager_->addNode(bufferSource);
+  nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
@@ -90,7 +90,7 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
 
 std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   auto analyser = std::make_shared<AnalyserNode>(this);
-  nodeManager_->addNode(analyser);
+  nodeManager_->addProcessingNode(analyser);
   return analyser;
 }
 

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+#include <functional>
+
+namespace audioapi {
+class AudioBus;
+
+class AudioRecorder {
+ public:
+  explicit AudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::function<void(void)> &onError,
+    const std::function<void(void)> &onStatusChange,
+    const std::function<void(std::shared_ptr<AudioBus>, int, double)> &onAudioReady
+  )
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      onError_(onError),
+      onStatusChange_(onStatusChange),
+      onAudioReady_(onAudioReady) {}
+
+  virtual ~AudioRecorder() = default;
+
+  virtual void start() = 0;
+  virtual void stop() = 0;
+
+ protected:
+  float sampleRate_;
+  int bufferLength_;
+
+  std::function<void(void)> onError_;
+  std::function<void(void)> onStatusChange_;
+  std::function<void(std::shared_ptr<AudioBus>, int, double)> onAudioReady_;
+};
+
+} // namespace audioapi

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

@@ -18,6 +18,11 @@ namespace audioapi {
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
+  // UNSCHEDULED: The node is not scheduled to play.
+  // SCHEDULED: The node is scheduled to play at a specific time.
+  // PLAYING: The node is currently playing.
+  // FINISHED: The node has finished playing.
+  // STOP_SCHEDULED: The node is scheduled to stop at a specific time, but is still playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, FINISHED, STOP_SCHEDULED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
 

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

@@ -51,7 +51,7 @@ void OscillatorNode::processNode(
 
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
 
-  if (!isPlaying()) {
+  if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();
     return;
   }

package/common/cpp/audioapi/core/utils/AudioNodeManager.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Locker.h>
 
@@ -28,9 +29,16 @@ std::mutex &AudioNodeManager::getGraphLock() {
   return graphLock_;
 }
 
-void AudioNodeManager::addNode(const std::shared_ptr<AudioNode> &node) {
+void AudioNodeManager::addProcessingNode(
+    const std::shared_ptr<AudioNode> &node) {
   Locker lock(getGraphLock());
-  nodes_.insert(node);
+  processingNodes_.insert(node);
+}
+
+void AudioNodeManager::addSourceNode(
+    const std::shared_ptr<AudioScheduledSourceNode> &node) {
+  Locker lock(getGraphLock());
+  sourceNodes_.insert(node);
 }
 
 void AudioNodeManager::settlePendingConnections() {
@@ -54,17 +62,35 @@ void AudioNodeManager::settlePendingConnections() {
   audioNodesToConnect_.clear();
 }
 
+void AudioNodeManager::cleanupNode(const std::shared_ptr<AudioNode> &node) {
+  nodeDeconstructor_.addNodeForDeconstruction(node);
+  node.get()->cleanup();
+}
+
 void AudioNodeManager::prepareNodesForDestruction() {
   nodeDeconstructor_.tryCallWithLock([this]() {
-    auto it = nodes_.begin();
+    auto sNodesIt = sourceNodes_.begin();
+
+    while (sNodesIt != sourceNodes_.end()) {
+      // we don't want to destroy nodes that are still playing or will be
+      // playing
+      if (sNodesIt->use_count() == 1 &&
+          (sNodesIt->get()->isUnscheduled() || sNodesIt->get()->isFinished())) {
+        cleanupNode(*sNodesIt);
+        sNodesIt = sourceNodes_.erase(sNodesIt);
+      } else {
+        ++sNodesIt;
+      }
+    }
 
-    while (it != nodes_.end()) {
-      if (it->use_count() == 1) {
-        nodeDeconstructor_.addNodeForDeconstruction(*it);
-        it->get()->cleanup();
-        it = nodes_.erase(it);
+    auto pNodesIt = processingNodes_.begin();
+
+    while (pNodesIt != processingNodes_.end()) {
+      if (pNodesIt->use_count() == 1) {
+        cleanupNode(*pNodesIt);
+        pNodesIt = processingNodes_.erase(pNodesIt);
       } else {
-        ++it;
+        ++pNodesIt;
       }
     }
   });
@@ -74,11 +100,19 @@ void AudioNodeManager::prepareNodesForDestruction() {
 void AudioNodeManager::cleanup() {
   Locker lock(getGraphLock());
 
-  for (auto it = nodes_.begin(), end = nodes_.end(); it != end; ++it) {
+  for (auto it = sourceNodes_.begin(), end = sourceNodes_.end(); it != end;
+       ++it) {
+    it->get()->cleanup();
+  }
+
+  for (auto it = processingNodes_.begin(), end = processingNodes_.end();
+       it != end;
+       ++it) {
     it->get()->cleanup();
   }
 
-  nodes_.clear();
+  sourceNodes_.clear();
+  processingNodes_.clear();
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioNodeManager.h

@@ -11,6 +11,7 @@
 namespace audioapi {
 
 class AudioNode;
+class AudioScheduledSourceNode;
 
 class AudioNodeManager {
  public:
@@ -27,7 +28,8 @@ class AudioNodeManager {
       const std::shared_ptr<AudioNode> &to,
       ConnectionType type);
 
-  void addNode(const std::shared_ptr<AudioNode> &node);
+  void addProcessingNode(const std::shared_ptr<AudioNode> &node);
+  void addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node);
 
   void cleanup();
 
@@ -36,7 +38,8 @@ class AudioNodeManager {
   AudioNodeDestructor nodeDeconstructor_;
 
   // all nodes created in the context
-  std::unordered_set<std::shared_ptr<AudioNode>> nodes_;
+  std::unordered_set<std::shared_ptr<AudioScheduledSourceNode>> sourceNodes_;
+  std::unordered_set<std::shared_ptr<AudioNode>> processingNodes_;
 
   // connections to be settled
   std::vector<std::tuple<
@@ -46,6 +49,7 @@ class AudioNodeManager {
       audioNodesToConnect_;
 
   void settlePendingConnections();
+  void cleanupNode(const std::shared_ptr<AudioNode> &node);
   void prepareNodesForDestruction();
 };
 

package/ios/audioapi/ios/AudioManagerModule.mm

@@ -49,16 +49,9 @@ RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled
   [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
 }
 
-RCT_EXPORT_METHOD(setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
-                      options active : (BOOL)active)
+RCT_EXPORT_METHOD(setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)options)
 {
-  NSError *error = nil;
-
-  if (active) {
-    [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options];
-  } else {
-    [self.audioSessionManager setActive:false error:&error];
-  }
+  [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options];
 }
 
 RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
@@ -66,6 +59,11 @@ RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
   [self.notificationManager observeAudioInterruptions:enabled];
 }
 
+RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
+{
+  [self.notificationManager observeVolumeChanges:(BOOL)enabled];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
 {
   return [self.audioSessionManager getDevicePreferredSampleRate];
@@ -87,7 +85,8 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
     @"onRemoteSeekBackward",
     @"onRemoteChangePlaybackPosition",
     @"onInterruption",
-    @"onRouteChange"
+    @"onRouteChange",
+    @"onVolumeChange"
   ];
 }
 

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

@@ -1,9 +1,9 @@
 #pragma once
 
 #ifdef __OBJC__ // when compiled as Objective-C++
-#import <AudioPlayer.h>
+#import <NativeAudioPlayer.h>
 #else // when compiled as C++
-typedef struct objc_object AudioPlayer;
+typedef struct objc_object NativeAudioPlayer;
 #endif // __OBJC__
 
 #include <functional>
@@ -14,23 +14,22 @@ class AudioBus;
 class AudioContext;
 
 class IOSAudioPlayer {
- protected:
-  std::shared_ptr<AudioBus> audioBus_;
-  AudioPlayer *audioPlayer_;
-  std::function<void(std::shared_ptr<AudioBus>, int)> renderAudio_;
-  int channelCount_;
-
  public:
   IOSAudioPlayer(
       const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
       float sampleRate);
   ~IOSAudioPlayer();
 
-  float getSampleRate() const;
-
   void start();
-  void stop();
   void resume();
-  void suspend();
+  void stop();
+  void pause();
+
+ protected:
+  std::shared_ptr<AudioBus> audioBus_;
+  NativeAudioPlayer *audioPlayer_;
+  std::function<void(std::shared_ptr<AudioBus>, int)> renderAudio_;
+  int channelCount_;
+  std::atomic<bool> isRunning_;
 };
 } // namespace audioapi

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

@@ -9,14 +9,19 @@
 namespace audioapi {
 
 IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio, float sampleRate)
-    : channelCount_(2), renderAudio_(renderAudio), audioBus_(0)
+    : channelCount_(2), renderAudio_(renderAudio), audioBus_(0), isRunning_(false)
 {
   RenderAudioBlock renderAudioBlock = ^(AudioBufferList *outputData, int numFrames) {
     int processedFrames = 0;
 
     while (processedFrames < numFrames) {
       int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
-      renderAudio_(audioBus_, framesToProcess);
+
+      if (isRunning_.load()) {
+        renderAudio_(audioBus_, framesToProcess);
+      } else {
+        audioBus_->zero();
+      }
 
       for (int channel = 0; channel < channelCount_; channel += 1) {
         float *outputChannel = (float *)outputData->mBuffers[channel].mData;
@@ -29,11 +34,11 @@ IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus
     }
   };
 
-  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudio:renderAudioBlock
-                                               sampleRate:sampleRate
-                                             channelCount:channelCount_];
+  audioPlayer_ = [[NativeAudioPlayer alloc] initWithRenderAudio:renderAudioBlock
+                                                     sampleRate:sampleRate
+                                                   channelCount:channelCount_];
 
-  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, getSampleRate());
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate);
 }
 
 IOSAudioPlayer::~IOSAudioPlayer()
@@ -48,27 +53,28 @@ IOSAudioPlayer::~IOSAudioPlayer()
 
 void IOSAudioPlayer::start()
 {
-  return [audioPlayer_ start];
-}
+  if (isRunning_.load()) {
+    return;
+  }
 
-void IOSAudioPlayer::stop()
-{
-  return [audioPlayer_ stop];
+  [audioPlayer_ start];
+  isRunning_.store(true);
 }
 
 void IOSAudioPlayer::resume()
 {
-  return [audioPlayer_ resume];
+  isRunning_.store(true);
 }
 
-void IOSAudioPlayer::suspend()
+void IOSAudioPlayer::stop()
 {
-  return [audioPlayer_ suspend];
+  isRunning_.store(false);
+  [audioPlayer_ stop];
 }
 
-float IOSAudioPlayer::getSampleRate() const
+void IOSAudioPlayer::pause()
 {
-  return [audioPlayer_ getSampleRate];
+  isRunning_.store(false);
 }
 
 } // namespace audioapi

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#ifdef __OBJC__ // when compiled as Objective-C++
+#import <NativeAudioRecorder.h>
+#else // when compiled as C++
+typedef struct objc_object NativeAudioRecorder;
+#endif // __OBJC__
+
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <functional>
+
+namespace audioapi {
+
+class AudioBus;
+
+class IOSAudioRecorder : public AudioRecorder {
+ public:
+  IOSAudioRecorder(
+      float sampleRate,
+      int bufferLength,
+      const std::function<void(void)> &onError,
+      const std::function<void(void)> &onStatusChange,
+      const std::function<void(std::shared_ptr<AudioBus>, int, double)>
+          &onAudioReady);
+
+  ~IOSAudioRecorder() override;
+
+  void start() override;
+  void stop() override;
+
+ private:
+  NativeAudioRecorder *audioRecorder_;
+  std::atomic<bool> isRunning_;
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,62 @@
+#import <AVFoundation/AVFoundation.h>
+
+#include <audioapi/core/Constants.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/ios/core/IOSAudioRecorder.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+
+IOSAudioRecorder::IOSAudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::function<void(void)> &onError,
+    const std::function<void(void)> &onStatusChange,
+    const std::function<void(std::shared_ptr<AudioBus>, int, double)> &onAudioReady)
+    : AudioRecorder(sampleRate, bufferLength, onError, onStatusChange, onAudioReady)
+{
+  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames, AVAudioTime *when) {
+    if (isRunning_.load()) {
+      auto bus = std::make_shared<AudioBus>(numFrames, 1, sampleRate);
+
+      auto *inputChannel = (float *)inputBuffer->mBuffers[0].mData;
+      auto *outputChannel = bus->getChannel(0)->getData();
+
+      memcpy(outputChannel, inputChannel, numFrames * sizeof(float));
+      onAudioReady_(bus, numFrames, [when sampleTime] / [when sampleRate]);
+    }
+  };
+
+  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock bufferLength:bufferLength];
+}
+
+IOSAudioRecorder::~IOSAudioRecorder()
+{
+  AudioRecorder::~AudioRecorder();
+
+  stop();
+  [audioRecorder_ cleanup];
+}
+
+void IOSAudioRecorder::start()
+{
+  if (isRunning_.load()) {
+    return;
+  }
+
+  [audioRecorder_ start];
+  isRunning_.store(true);
+}
+
+void IOSAudioRecorder::stop()
+{
+  if (!isRunning_.load()) {
+    return;
+  }
+
+  isRunning_.store(false);
+  [audioRecorder_ stop];
+}
+
+} // namespace audioapi

package/ios/audioapi/ios/core/{AudioPlayer.h → NativeAudioPlayer.h}

@@ -5,14 +5,13 @@
 
 typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
-@interface AudioPlayer : NSObject
+@interface NativeAudioPlayer : NSObject
 
 @property (nonatomic, strong) AVAudioFormat *format;
 @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;
 @property (nonatomic, strong) NSString *sourceNodeId;
 @property (nonatomic, strong) AVAudioSourceNodeRenderBlock renderBlock;
 
@@ -20,16 +19,10 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
                          sampleRate:(float)sampleRate
                        channelCount:(int)channelCount;
 
-- (float)getSampleRate;
-
 - (void)start;
 
 - (void)stop;
 
-- (void)resume;
-
-- (void)suspend;
-
 - (void)cleanup;
 
 @end

package/ios/audioapi/ios/core/{AudioPlayer.m → NativeAudioPlayer.m}

@@ -1,7 +1,7 @@
-#import <audioapi/ios/core/AudioPlayer.h>
+#import <audioapi/ios/core/NativeAudioPlayer.h>
 #import <audioapi/ios/system/AudioEngine.h>
 
-@implementation AudioPlayer
+@implementation NativeAudioPlayer
 
 - (instancetype)initWithRenderAudio:(RenderAudioBlock)renderAudio
                          sampleRate:(float)sampleRate
@@ -21,6 +21,7 @@
       }
 
       weakSelf.renderAudio(outputData, frameCount);
+
       return kAudioServicesNoError;
     };
 
@@ -31,53 +32,23 @@
   return self;
 }
 
-- (float)getSampleRate
-{
-  return self.sampleRate;
-}
-
 - (void)start
 {
   NSLog(@"[AudioPlayer] start");
+
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
-  self.isRunning = true;
   self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
 }
 
 - (void)stop
 {
   NSLog(@"[AudioPlayer] stop");
-  if (!self.isRunning) {
-    return;
-  }
 
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
-  self.isRunning = false;
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
   self.sourceNodeId = nil;
 }
 
-- (void)suspend
-{
-  NSLog(@"[AudioPlayer] suspend");
-  if (!self.isRunning) {
-    return;
-  }
-
-  AudioEngine *audioEngine = [AudioEngine sharedInstance];
-  self.isRunning = false;
-  [audioEngine detachSourceNodeWithId:self.sourceNodeId];
-  self.sourceNodeId = nil;
-}
-
-- (void)resume
-{
-  NSLog(@"[AudioPlayer] resume");
-  AudioEngine *audioEngine = [AudioEngine sharedInstance];
-  self.isRunning = true;
-  self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
-}
-
 - (void)cleanup
 {
   self.renderAudio = nil;

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFrames, AVAudioTime *when);
+
+@interface NativeAudioRecorder : NSObject
+
+@property (nonatomic, assign) int bufferLength;
+@property (nonatomic, assign) double sampleRate;
+
+@property (nonatomic, strong) AVAudioSinkNode *sinkNode;
+@property (nonatomic, copy) AVAudioSinkNodeReceiverBlock receiverSinkBlock;
+@property (nonatomic, copy) AudioReceiverBlock receiverBlock;
+
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock bufferLength:(int)bufferLength;
+
+- (void)start;
+
+- (void)stop;
+
+- (void)cleanup;
+
+@end