react-native-audio-api 0.3.0-rc2 → 0.3.2

package/common/cpp/HostObjects/OscillatorNodeHostObject.h

@@ -6,7 +6,7 @@
 
 #include "AudioParamHostObject.h"
 #include "AudioScheduledSourceNodeHostObject.h"
-#include "OscillatorNodeWrapper.h"
+#include "OscillatorNode.h"
 #include "PeriodicWaveHostObject.h"
 
 namespace audioapi {
@@ -14,28 +14,51 @@ using namespace facebook;
 
 class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit OscillatorNodeHostObject(
-      const std::shared_ptr<OscillatorNodeWrapper> &wrapper);
+  explicit OscillatorNodeHostObject(const std::shared_ptr<OscillatorNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
+        JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, detune),
+        JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, type));
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    addFunctions(
+        JSI_EXPORT_FUNCTION(OscillatorNodeHostObject, setPeriodicWave));
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(OscillatorNodeHostObject, type));
+  }
+
+  JSI_PROPERTY_GETTER(frequency) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
+        oscillatorNode->getFrequencyParam());
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  JSI_PROPERTY_GETTER(detune) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto detuneParam_ = std::make_shared<AudioParamHostObject>(
+        oscillatorNode->getDetuneParam());
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
 
-  static std::shared_ptr<OscillatorNodeHostObject> createFromWrapper(
-      const std::shared_ptr<OscillatorNodeWrapper> &wrapper) {
-    return std::make_shared<OscillatorNodeHostObject>(wrapper);
+  JSI_PROPERTY_GETTER(type) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto waveType = oscillatorNode->getType();
+    return jsi::String::createFromUtf8(runtime, waveType);
   }
 
- private:
-  std::shared_ptr<AudioParamHostObject> frequencyParam_;
-  std::shared_ptr<AudioParamHostObject> detuneParam_;
+  JSI_HOST_FUNCTION(setPeriodicWave) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto periodicWave =
+        args[0].getObject(runtime).getHostObject<PeriodicWaveHostObject>(
+            runtime);
+    oscillatorNode->setPeriodicWave(periodicWave->periodicWave_);
+    return jsi::Value::undefined();
+  }
 
-  std::shared_ptr<OscillatorNodeWrapper>
-  getOscillatorNodeWrapperFromAudioNodeWrapper();
+  JSI_PROPERTY_SETTER(type) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    oscillatorNode->setType(value.getString(runtime).utf8(runtime));
+  }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/PeriodicWaveHostObject.h

@@ -4,30 +4,17 @@
 #include <memory>
 #include <vector>
 
-#include "PeriodicWaveWrapper.h"
+#include "PeriodicWave.h"
 
 namespace audioapi {
 using namespace facebook;
 
 class PeriodicWaveHostObject : public jsi::HostObject {
  public:
-  std::shared_ptr<PeriodicWaveWrapper> wrapper_;
+  std::shared_ptr<PeriodicWave> periodicWave_;
 
   explicit PeriodicWaveHostObject(
-      const std::shared_ptr<PeriodicWaveWrapper> &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<PeriodicWaveHostObject> createFromWrapper(
-      const std::shared_ptr<PeriodicWaveWrapper> &wrapper) {
-    return std::make_shared<PeriodicWaveHostObject>(wrapper);
-  }
+      const std::shared_ptr<PeriodicWave> &periodicWave)
+      : periodicWave_(periodicWave) {}
 };
 } // namespace audioapi

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,26 @@
 #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>(0.0, -MAX_DETUNE, MAX_DETUNE);
+  playbackRateParam_ = std::make_shared<AudioParam>(
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+
   isInitialized_ = true;
 }
 
@@ -18,6 +30,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 +55,199 @@ 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();
-    }
+  handleStopScheduled();
+}
 
-    return;
-  }
+/**
+ * Helper functions
+ */
 
-  // 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;
+void AudioBufferSourceNode::processWithoutInterpolation(
+    AudioBus *processingBus,
+    size_t startOffset,
+    size_t offsetLength,
+    float playbackRate) {
+  size_t direction = playbackRate < 0 ? -1 : 1;
 
-    while (framesToProcess - outputBusIndex > 0) {
-      framesToCopy = std::min(
-          framesToProcess - outputBusIndex,
-          buffer_->getLength() - bufferIndex_);
+  auto readIndex = static_cast<size_t>(vReadIndex_);
+  size_t writeIndex = startOffset;
 
-      processingBus->copy(
-          buffer_->bus_.get(), bufferIndex_, outputBusIndex, framesToCopy);
+  auto frameStart = static_cast<size_t>(getVirtualStartFrame());
+  auto frameEnd = static_cast<size_t>(getVirtualEndFrame());
+  size_t frameDelta = frameEnd - frameStart;
 
-      bufferIndex_ += framesToCopy;
-      outputBusIndex += framesToCopy;
+  size_t framesLeft = offsetLength;
 
-      if (bufferIndex_ < buffer_->getLength()) {
-        continue;
+  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;
+
+    // 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];
+        }
       }
+    }
 
-      bufferIndex_ %= buffer_->getLength();
+    writeIndex += framesToCopy;
+    readIndex += framesToCopy * direction;
+    framesLeft -= framesToCopy;
+
+    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;
+}
 
-    playbackState_ = PlaybackState::FINISHED;
-    disable();
+void AudioBufferSourceNode::processWithInterpolation(
+    AudioBus *processingBus,
+    size_t startOffset,
+    size_t offsetLength,
+    float playbackRate) {
+  size_t direction = playbackRate < 0 ? -1 : 1;
 
-    return;
-  }
+  size_t writeIndex = startOffset;
 
-  // 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;
-  }
+  double vFrameStart = getVirtualStartFrame();
+  double vFrameEnd = getVirtualEndFrame();
+  double vFrameDelta = vFrameEnd - vFrameStart;
 
-  // Copy the entire buffer n times to the processing bus.
-  while (processingBusPosition + bufferSize <= framesToProcess) {
-    processingBus->copy(buffer_->bus_.get());
-    processingBusPosition += bufferSize;
+  auto frameStart = static_cast<size_t>(vFrameStart);
+  auto frameEnd = static_cast<size_t>(vFrameEnd);
+
+  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/{android/src/main/cpp/AudioDecoder → common/cpp/core}/AudioDecoder.h

@@ -8,11 +8,9 @@ class AudioBus;
 
 class AudioDecoder {
  public:
-  explicit AudioDecoder(int sampleRate);
+  explicit AudioDecoder(int sampleRate) : sampleRate_(sampleRate) {}
 
   [[nodiscard]] AudioBus *decodeWithFilePath(const std::string &path) const;
-  // TODO: implement this
-  [[nodiscard]] AudioBus *decodeWithArrayBuffer() const;
 
  private:
   int sampleRate_;

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_;