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

package/common/cpp/HostObjects/StereoPannerNodeHostObject.h

@@ -6,7 +6,7 @@
 
 #include "AudioNodeHostObject.h"
 #include "AudioParamHostObject.h"
-#include "StereoPannerNodeWrapper.h"
+#include "StereoPannerNode.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -14,23 +14,16 @@ using namespace facebook;
 class StereoPannerNodeHostObject : public AudioNodeHostObject {
  public:
   explicit StereoPannerNodeHostObject(
-      const std::shared_ptr<StereoPannerNodeWrapper> &wrapper);
-
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
-
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-
-  static std::shared_ptr<StereoPannerNodeHostObject> createFromWrapper(
-      const std::shared_ptr<StereoPannerNodeWrapper> &wrapper) {
-    return std::make_shared<StereoPannerNodeHostObject>(wrapper);
+      const std::shared_ptr<StereoPannerNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(JSI_EXPORT_PROPERTY_GETTER(StereoPannerNodeHostObject, pan));
   }
 
- private:
-  std::shared_ptr<AudioParamHostObject> panParam_;
+  JSI_PROPERTY_GETTER(pan) {
+    auto stereoPannerNode = std::static_pointer_cast<StereoPannerNode>(node_);
+    auto panParam_ =
+        std::make_shared<AudioParamHostObject>(stereoPannerNode->getPanParam());
+    return jsi::Object::createFromHostObject(runtime, panParam_);
+  }
 };
 } // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -3,14 +3,27 @@
 #include "AudioArray.h"
 #include "AudioBufferSourceNode.h"
 #include "AudioBus.h"
+#include "AudioParam.h"
+#include "AudioUtils.h"
 #include "BaseAudioContext.h"
+#include "Constants.h"
 
 namespace audioapi {
 
 AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
-    : AudioScheduledSourceNode(context), loop_(false), bufferIndex_(0) {
+    : AudioScheduledSourceNode(context),
+      loop_(false),
+      loopStart_(0),
+      loopEnd_(0),
+      vReadIndex_(0.0) {
   numberOfInputs_ = 0;
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+
+  detuneParam_ =
+      std::make_shared<AudioParam>(context, 0.0, -MAX_DETUNE, MAX_DETUNE);
+  playbackRateParam_ = std::make_shared<AudioParam>(
+      context, 1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+
   isInitialized_ = true;
 }
 
@@ -18,6 +31,23 @@ bool AudioBufferSourceNode::getLoop() const {
   return loop_;
 }
 
+double AudioBufferSourceNode::getLoopStart() const {
+  return loopStart_;
+}
+
+double AudioBufferSourceNode::getLoopEnd() const {
+  return loopEnd_;
+}
+
+std::shared_ptr<AudioParam> AudioBufferSourceNode::getDetuneParam() const {
+  return detuneParam_;
+}
+
+std::shared_ptr<AudioParam> AudioBufferSourceNode::getPlaybackRateParam()
+    const {
+  return playbackRateParam_;
+}
+
 std::shared_ptr<AudioBuffer> AudioBufferSourceNode::getBuffer() const {
   return buffer_;
 }
@@ -26,120 +56,197 @@ void AudioBufferSourceNode::setLoop(bool loop) {
   loop_ = loop;
 }
 
+void AudioBufferSourceNode::setLoopStart(double loopStart) {
+  loopStart_ = loopStart;
+}
+
+void AudioBufferSourceNode::setLoopEnd(double loopEnd) {
+  loopEnd_ = loopEnd;
+}
+
 void AudioBufferSourceNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer) {
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+    alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
     return;
   }
 
   buffer_ = buffer;
+  alignedBus_ = std::make_shared<AudioBus>(
+      context_->getSampleRate(), buffer_->getLength());
+
+  alignedBus_->zero();
+  alignedBus_->sum(buffer_->bus_.get());
 }
 
-// Note: AudioBus copy method will use memcpy if the source buffer and system
-// processing bus have same channel count, otherwise it will use the summing
-// function taking care of up/down mixing.
 void AudioBufferSourceNode::processNode(
     AudioBus *processingBus,
     int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+  float playbackRate = getPlaybackRateValue(startOffset);
+
   // No audio data to fill, zero the output and return.
-  if (!isPlaying() || !buffer_ || buffer_->getLength() == 0) {
+  if (!isPlaying() || !alignedBus_ || alignedBus_->getSize() == 0 ||
+      !playbackRate) {
     processingBus->zero();
     return;
   }
 
-  // Easiest case, the buffer is the same length as the number of frames to
-  // process, just copy the data.
-  if (framesToProcess == buffer_->getLength()) {
-    processingBus->copy(buffer_->bus_.get());
+  if (std::fabs(playbackRate) == 1.0) {
+    processWithoutInterpolation(
+        processingBus, startOffset, offsetLength, playbackRate);
+  } else {
+    processWithInterpolation(
+        processingBus, startOffset, offsetLength, playbackRate);
+  }
+}
 
-    if (!loop_) {
-      playbackState_ = PlaybackState::FINISHED;
-      disable();
-    }
+/**
+ * Helper functions
+ */
 
-    return;
-  }
+void AudioBufferSourceNode::processWithoutInterpolation(
+    AudioBus *processingBus,
+    size_t startOffset,
+    size_t offsetLength,
+    float playbackRate) {
+  size_t direction = playbackRate < 0 ? -1 : 1;
 
-  // The buffer is longer than the number of frames to process.
-  // We have to keep track of where we are in the buffer.
-  if (framesToProcess < buffer_->getLength()) {
-    int outputBusIndex = 0;
-    int framesToCopy = 0;
+  auto readIndex = static_cast<size_t>(vReadIndex_);
+  size_t writeIndex = startOffset;
 
-    while (framesToProcess - outputBusIndex > 0) {
-      framesToCopy = std::min(
-          framesToProcess - outputBusIndex,
-          buffer_->getLength() - bufferIndex_);
+  auto frameStart = static_cast<size_t>(getVirtualStartFrame());
+  auto frameEnd = static_cast<size_t>(getVirtualEndFrame());
+  size_t frameDelta = frameEnd - frameStart;
 
-      processingBus->copy(
-          buffer_->bus_.get(), bufferIndex_, outputBusIndex, framesToCopy);
+  size_t framesLeft = offsetLength;
 
-      bufferIndex_ += framesToCopy;
-      outputBusIndex += framesToCopy;
+  if (loop_ && (readIndex >= frameEnd || readIndex < frameStart)) {
+    readIndex = frameStart + (readIndex - frameStart) % frameDelta;
+  }
+
+  while (framesLeft > 0) {
+    size_t framesToEnd = frameEnd - readIndex;
+    size_t framesToCopy = std::min(framesToEnd, framesLeft);
+    framesToCopy = framesToCopy > 0 ? framesToCopy : 0;
 
-      if (bufferIndex_ < buffer_->getLength()) {
-        continue;
+    // Direction is forward, we can normally copy the data
+    if (direction == 1) {
+      processingBus->copy(
+          alignedBus_.get(), readIndex, writeIndex, framesToCopy);
+    } else {
+      for (int i = 0; i < framesToCopy; i += 1) {
+        for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
+          (*processingBus->getChannel(j))[writeIndex + i] =
+              (*alignedBus_->getChannel(j))[readIndex - i];
+        }
       }
+    }
+
+    writeIndex += framesToCopy;
+    readIndex += framesToCopy * direction;
+    framesLeft -= framesToCopy;
 
-      bufferIndex_ %= buffer_->getLength();
+    if (readIndex >= frameEnd || readIndex < frameStart) {
+      readIndex -= direction * frameDelta;
 
       if (!loop_) {
+        processingBus->zero(writeIndex, framesLeft);
         playbackState_ = PlaybackState::FINISHED;
         disable();
-
-        if (framesToProcess - outputBusIndex > 0) {
-          processingBus->zero(outputBusIndex, framesToProcess - outputBusIndex);
-        }
+        break;
       }
     }
-
-    return;
   }
 
-  // processing bus is longer than the source buffer
-  if (!loop_) {
-    // If we don't loop the buffer, copy it once and zero the remaining
-    // processing bus frames.
-    processingBus->copy(buffer_->bus_.get());
-    processingBus->zero(
-        buffer_->getLength(), framesToProcess - buffer_->getLength());
+  // update reading index for next render quantum
+  vReadIndex_ = readIndex;
+}
+
+void AudioBufferSourceNode::processWithInterpolation(
+    AudioBus *processingBus,
+    size_t startOffset,
+    size_t offsetLength,
+    float playbackRate) {
+  size_t direction = playbackRate < 0 ? -1 : 1;
 
-    playbackState_ = PlaybackState::FINISHED;
-    disable();
+  size_t writeIndex = startOffset;
 
-    return;
-  }
+  double vFrameStart = getVirtualStartFrame();
+  double vFrameEnd = getVirtualEndFrame();
+  double vFrameDelta = vFrameEnd - vFrameStart;
 
-  // If we loop the buffer, we need to loop the buffer framesToProcess /
-  // bufferSize times There might also be a remainder of frames to copy after
-  // the loop, which will also carry over some buffer frames to the next render
-  // quantum.
-  int processingBusPosition = 0;
-  int bufferSize = buffer_->getLength();
-  int remainingFrames = framesToProcess - framesToProcess / bufferSize;
-
-  // Do we have some frames left in the buffer from the previous render quantum,
-  // if yes copy them over and reset the buffer position.
-  if (bufferIndex_ > 0) {
-    processingBus->copy(buffer_->bus_.get(), 0, bufferIndex_);
-    processingBusPosition += bufferIndex_;
-    bufferIndex_ = 0;
-  }
+  auto frameStart = static_cast<size_t>(vFrameStart);
+  auto frameEnd = static_cast<size_t>(vFrameEnd);
 
-  // Copy the entire buffer n times to the processing bus.
-  while (processingBusPosition + bufferSize <= framesToProcess) {
-    processingBus->copy(buffer_->bus_.get());
-    processingBusPosition += bufferSize;
+  size_t framesLeft = offsetLength;
+
+  // Wrap to the start of the loop if necessary
+  if (loop_ && (vReadIndex_ >= vFrameEnd || vReadIndex_ < vFrameStart)) {
+    vReadIndex_ =
+        vFrameStart + std::fmod(vReadIndex_ - vFrameStart, vFrameDelta);
   }
 
-  // Fill in the remaining frames from the processing buffer and update buffer
-  // index for next render quantum.
-  if (remainingFrames > 0) {
-    processingBus->copy(
-        buffer_->bus_.get(), 0, processingBusPosition, remainingFrames);
-    bufferIndex_ = remainingFrames;
+  while (framesLeft > 0) {
+    auto readIndex = static_cast<size_t>(vReadIndex_);
+    size_t nextReadIndex = readIndex + 1;
+    float factor = vReadIndex_ - readIndex;
+
+    if (nextReadIndex >= frameEnd) {
+      nextReadIndex = loop_ ? frameStart : readIndex;
+    }
+
+    for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
+      float *destination = processingBus->getChannel(i)->getData();
+      const float *source = alignedBus_->getChannel(i)->getData();
+
+      destination[writeIndex] = AudioUtils::linearInterpolate(
+          source, readIndex, nextReadIndex, factor);
+    }
+
+    writeIndex += 1;
+    vReadIndex_ += playbackRate * direction;
+    framesLeft -= 1;
+
+    if (vReadIndex_ < vFrameStart || vReadIndex_ >= vFrameEnd) {
+      vReadIndex_ -= direction * vFrameDelta;
+
+      if (!loop_) {
+        processingBus->zero(writeIndex, framesLeft);
+        playbackState_ = PlaybackState::FINISHED;
+        disable();
+        break;
+      }
+    }
   }
 }
 
+float AudioBufferSourceNode::getPlaybackRateValue(size_t &startOffset) {
+  double time =
+      context_->getCurrentTime() + startOffset / context_->getSampleRate();
+
+  return playbackRateParam_->getValueAtTime(time) *
+      std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+}
+
+double AudioBufferSourceNode::getVirtualStartFrame() {
+  double loopStartFrame = loopStart_ * context_->getSampleRate();
+
+  return loop_ && loopStartFrame >= 0 && loopStart_ < loopEnd_ ? loopStartFrame
+                                                               : 0.0;
+}
+
+double AudioBufferSourceNode::getVirtualEndFrame() {
+  double inputBufferLength = alignedBus_->getSize();
+  double loopEndFrame = loopEnd_ * context_->getSampleRate();
+
+  return loop_ && loopEndFrame > 0 && loopStart_ < loopEnd_
+      ? std::min(loopEndFrame, inputBufferLength)
+      : inputBufferLength;
+}
+
 } // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.h

@@ -8,23 +8,63 @@
 namespace audioapi {
 
 class AudioBus;
+class AudioParam;
 
 class AudioBufferSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferSourceNode(BaseAudioContext *context);
 
   [[nodiscard]] bool getLoop() const;
+  [[nodiscard]] double getLoopStart() const;
+  [[nodiscard]] double getLoopEnd() const;
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
+
   [[nodiscard]] std::shared_ptr<AudioBuffer> getBuffer() const;
+
   void setLoop(bool loop);
+  void setLoopStart(double loopStart);
+  void setLoopEnd(double loopEnd);
+
   void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
 
  protected:
   void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
+  // Looping related properties
   bool loop_;
+  double loopStart_;
+  double loopEnd_;
+
+  // playback rate aka pitch change params
+  std::shared_ptr<AudioParam> detuneParam_;
+  std::shared_ptr<AudioParam> playbackRateParam_;
+
+  // internal helper
+  double vReadIndex_;
+
+  // User provided buffer
   std::shared_ptr<AudioBuffer> buffer_;
-  int bufferIndex_;
+  std::shared_ptr<AudioBus> alignedBus_;
+
+  float getPlaybackRateValue(size_t &startOffset);
+
+  double getVirtualStartFrame();
+  double getVirtualEndFrame();
+
+  void processWithoutInterpolation(
+      AudioBus *processingBus,
+      size_t startOffset,
+      size_t offsetLength,
+      float playbackRate);
+
+  void processWithInterpolation(
+      AudioBus *processingBus,
+      size_t startOffset,
+      size_t offsetLength,
+      float playbackRate);
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -31,6 +31,7 @@ void AudioDestinationNode::renderAudio(
   }
 
   context_->getNodeManager()->preProcessGraph();
+
   destinationBus->zero();
 
   AudioBus *processedBus = processAudio(destinationBus, numFrames);

package/common/cpp/core/AudioDestinationNode.h

@@ -23,7 +23,7 @@ class AudioDestinationNode : public AudioNode {
  protected:
   // DestinationNode is triggered by AudioContext using renderAudio
   // processNode function is not necessary and is never called.
-  void processNode(AudioBus *, int) final{};
+  void processNode(AudioBus *, int) final {};
 
  private:
   std::size_t currentSampleFrame_;

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -1,24 +1,37 @@
 #include "AudioScheduledSourceNode.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 #include "AudioNodeManager.h"
+#include "AudioUtils.h"
 #include "BaseAudioContext.h"
 
 namespace audioapi {
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
-    : AudioNode(context), playbackState_(PlaybackState::UNSCHEDULED) {
+    : AudioNode(context),
+      playbackState_(PlaybackState::UNSCHEDULED),
+      startTime_(-1.0),
+      stopTime_(-1.0) {
   numberOfInputs_ = 0;
-  isInitialized_ = true;
 }
 
 void AudioScheduledSourceNode::start(double time) {
-  context_->getNodeManager()->addSourceNode(shared_from_this());
-
   playbackState_ = PlaybackState::SCHEDULED;
-  waitAndExecute(time, [this](double time) { startPlayback(); });
+  startTime_ = time;
+
+  context_->getNodeManager()->addSourceNode(shared_from_this());
 }
 
 void AudioScheduledSourceNode::stop(double time) {
-  waitAndExecute(time, [this](double time) { stopPlayback(); });
+  stopTime_ = time;
+}
+
+bool AudioScheduledSourceNode::isUnscheduled() {
+  return playbackState_ == PlaybackState::UNSCHEDULED;
+}
+
+bool AudioScheduledSourceNode::isScheduled() {
+  return playbackState_ == PlaybackState::SCHEDULED;
 }
 
 bool AudioScheduledSourceNode::isPlaying() {
@@ -29,25 +42,77 @@ bool AudioScheduledSourceNode::isFinished() {
   return playbackState_ == PlaybackState::FINISHED;
 }
 
-void AudioScheduledSourceNode::startPlayback() {
-  playbackState_ = PlaybackState::PLAYING;
-}
+void AudioScheduledSourceNode::updatePlaybackInfo(
+    AudioBus *processingBus,
+    int framesToProcess,
+    size_t &startOffset,
+    size_t &nonSilentFramesToProcess) {
+  if (!isInitialized_) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+    return;
+  }
 
-void AudioScheduledSourceNode::stopPlayback() {
-  playbackState_ = PlaybackState::FINISHED;
-  disable();
-}
+  int sampleRate = context_->getSampleRate();
+
+  size_t firstFrame = context_->getCurrentSampleFrame();
+  size_t lastFrame = firstFrame + framesToProcess;
+
+  size_t startFrame = std::max(
+      AudioUtils::timeToSampleFrame(startTime_, sampleRate), firstFrame);
+  size_t stopFrame = stopTime_ == -1.0
+      ? std::numeric_limits<size_t>::max()
+      : std::max(
+            AudioUtils::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
+
+  if (isUnscheduled() || isFinished()) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+    return;
+  }
 
-void AudioScheduledSourceNode::waitAndExecute(
-    double time,
-    const std::function<void(double)> &fun) {
-  std::thread([this, time, fun]() {
-    while (context_->getCurrentTime() < time) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  if (isScheduled()) {
+    // not yet playing
+    if (startFrame > lastFrame) {
+      startOffset = 0;
+      nonSilentFramesToProcess = 0;
+      return;
     }
 
-    fun(time);
-  }).detach();
+    // start playing
+    // zero first frames before starting frame
+    playbackState_ = PlaybackState::PLAYING;
+    startOffset = std::max(startFrame, firstFrame) - firstFrame > 0
+        ? std::max(startFrame, firstFrame) - firstFrame
+        : 0;
+    nonSilentFramesToProcess =
+        std::min(lastFrame, stopFrame) - startFrame - startOffset;
+    processingBus->zero(0, startOffset);
+    return;
+  }
+
+  // the node is playing
+
+  // stop will happen in this render quantum
+  // zero remaining frames after stop frame
+  if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+    startOffset = 0;
+    nonSilentFramesToProcess = stopFrame - firstFrame;
+    processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
+    return;
+  }
+
+  // mark as finished in first silent render quantum
+  if (stopFrame < firstFrame) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+    playbackState_ = PlaybackState::FINISHED;
+    return;
+  }
+
+  // normal "mid-buffer" playback
+  startOffset = 0;
+  nonSilentFramesToProcess = framesToProcess;
 }
 
 } // namespace audioapi

package/common/cpp/core/AudioScheduledSourceNode.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <functional>
 #include <iostream>
+#include <limits>
 #include <memory>
 #include <thread>
 
@@ -19,16 +21,22 @@ class AudioScheduledSourceNode : public AudioNode {
   void start(double time);
   void stop(double time);
 
-  bool isFinished();
+  bool isUnscheduled();
+  bool isScheduled();
   bool isPlaying();
+  bool isFinished();
 
  protected:
   std::atomic<PlaybackState> playbackState_;
+  void updatePlaybackInfo(
+      AudioBus *processingBus,
+      int framesToProcess,
+      size_t &startOffset,
+      size_t &nonSilentFramesToProcess);
 
  private:
-  void startPlayback();
-  void stopPlayback();
-  void waitAndExecute(double time, const std::function<void(double)> &fun);
+  double startTime_;
+  double stopTime_;
 };
 
 } // namespace audioapi

package/common/cpp/core/BaseAudioContext.cpp

@@ -1,4 +1,5 @@
 #ifdef ANDROID
+#include "AudioDecoder.h"
 #include "AudioPlayer.h"
 #else
 #include "IOSAudioDecoder.h"
@@ -24,6 +25,7 @@ namespace audioapi {
 BaseAudioContext::BaseAudioContext() {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+  audioDecoder_ = std::make_shared<AudioDecoder>(audioPlayer_->getSampleRate());
 #else
   audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
   audioDecoder_ =
@@ -108,19 +110,20 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
 
 #ifdef ANDROID
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
-    const std::string &source) {
-  return {nullptr};
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
+  return std::make_shared<AudioBuffer>(audioBus);
 }
 #else
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
-    const std::string &source) {
-  auto audioBus = audioDecoder_->decodeWithFilePath(source);
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
   return std::make_shared<AudioBuffer>(audioBus);
 }
 #endif
 
 std::function<void(AudioBus *, int)> BaseAudioContext::renderAudio() {
-  if (isClosed()) {
+  if (!isRunning()) {
     return [](AudioBus *, int) {};
   }