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

package/common/cpp/HostObjects/OscillatorNodeHostObject.cpp

@@ -24,6 +24,8 @@ std::vector<jsi::PropNameID> OscillatorNodeHostObject::getPropertyNames(
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "frequency"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "detune"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "setPeriodicWave"));
   return propertyNames;
 }
 
@@ -46,6 +48,25 @@ jsi::Value OscillatorNodeHostObject::get(
     return jsi::String::createFromUtf8(runtime, waveType);
   }
 
+  if (propName == "setPeriodicWave") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
+          auto periodicWaveHostObject =
+              args[0].getObject(rt).asHostObject<PeriodicWaveHostObject>(rt);
+
+          wrapper->setPeriodicWave(periodicWaveHostObject->wrapper_);
+          return jsi::Value::undefined();
+        });
+  }
+
   return AudioScheduledSourceNodeHostObject::get(runtime, propNameId);
 }
 

package/common/cpp/HostObjects/OscillatorNodeHostObject.h

@@ -7,6 +7,7 @@
 #include "AudioParamHostObject.h"
 #include "AudioScheduledSourceNodeHostObject.h"
 #include "OscillatorNodeWrapper.h"
+#include "PeriodicWaveHostObject.h"
 
 namespace audioapi {
 using namespace facebook;

package/common/cpp/HostObjects/PeriodicWaveHostObject.cpp

@@ -0,0 +1,33 @@
+#include "PeriodicWaveHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+PeriodicWaveHostObject::PeriodicWaveHostObject(
+    const std::shared_ptr<PeriodicWaveWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> PeriodicWaveHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  return propertyNames;
+}
+
+jsi::Value PeriodicWaveHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void PeriodicWaveHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+} // namespace audioapi

package/common/cpp/HostObjects/PeriodicWaveHostObject.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+
+#include "PeriodicWaveWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class PeriodicWaveHostObject : public jsi::HostObject {
+ public:
+  std::shared_ptr<PeriodicWaveWrapper> wrapper_;
+
+  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);
+  }
+};
+} // namespace audioapi

package/common/cpp/core/AudioArray.cpp

@@ -0,0 +1,117 @@
+#include <algorithm>
+
+#include "AudioArray.h"
+#include "VectorMath.h"
+
+namespace audioapi {
+
+AudioArray::AudioArray(int size) : data_(nullptr), size_(size) {
+  resize(size);
+}
+
+AudioArray::~AudioArray() {
+  if (data_) {
+    delete[] data_;
+    data_ = nullptr;
+  }
+}
+
+int AudioArray::getSize() const {
+  return size_;
+}
+
+float *AudioArray::getData() const {
+  return data_;
+}
+
+float &AudioArray::operator[](int index) {
+  return data_[index];
+}
+
+const float &AudioArray::operator[](int index) const {
+  return data_[index];
+}
+
+void AudioArray::normalize() {
+  float maxAbsValue = getMaxAbsValue();
+
+  if (maxAbsValue == 0.0f || maxAbsValue == 1.0f) {
+    return;
+  }
+
+  VectorMath::multiplyByScalar(data_, 1.0f / maxAbsValue, data_, size_);
+}
+
+void AudioArray::resize(int size) {
+  if (size == size_) {
+    if (!data_) {
+      data_ = new float[size];
+    }
+
+    zero(0, size);
+    return;
+  }
+
+  delete[] data_;
+  size_ = size;
+  data_ = new float[size_];
+
+  zero(0, size_);
+}
+
+void AudioArray::scale(float value) {
+  VectorMath::multiplyByScalar(data_, value, data_, size_);
+}
+
+float AudioArray::getMaxAbsValue() const {
+  return VectorMath::maximumMagnitude(data_, size_);
+}
+
+void AudioArray::zero() {
+  zero(0, size_);
+}
+
+void AudioArray::zero(int start, int length) {
+  memset(data_ + start, 0, length * sizeof(float));
+}
+
+void AudioArray::sum(const AudioArray *source) {
+  sum(source, 0, 0, size_);
+}
+
+void AudioArray::sum(const AudioArray *source, int start, int length) {
+  sum(source, start, start, length);
+}
+
+void AudioArray::sum(
+    const AudioArray *source,
+    int sourceStart,
+    int destinationStart,
+    int length) {
+  VectorMath::add(
+      data_ + destinationStart,
+      source->getData() + sourceStart,
+      data_ + destinationStart,
+      length);
+}
+
+void AudioArray::copy(const AudioArray *source) {
+  copy(source, 0, size_);
+}
+
+void AudioArray::copy(const AudioArray *source, int start, int length) {
+  copy(source, start, start, length);
+}
+
+void AudioArray::copy(
+    const AudioArray *source,
+    int sourceStart,
+    int destinationStart,
+    int length) {
+  memcpy(
+      data_ + destinationStart,
+      source->getData() + sourceStart,
+      length * sizeof(float));
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioArray.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <algorithm>
+#include <memory>
+
+namespace audioapi {
+
+class AudioArray {
+ public:
+  explicit AudioArray(int size);
+  ~AudioArray();
+
+  [[nodiscard]] int getSize() const;
+  [[nodiscard]] float *getData() const;
+
+  float &operator[](int index);
+  const float &operator[](int index) const;
+
+  void normalize();
+  void resize(int size);
+  void scale(float value);
+  [[nodiscard]] float getMaxAbsValue() const;
+
+  void zero();
+  void zero(int start, int length);
+
+  void sum(const AudioArray *source);
+  void sum(const AudioArray *source, int start, int length);
+  void sum(
+      const AudioArray *source,
+      int sourceStart,
+      int destinationStart,
+      int length);
+
+  void copy(const AudioArray *source);
+  void copy(const AudioArray *source, int start, int length);
+  void copy(
+      const AudioArray *source,
+      int sourceStart,
+      int destinationStart,
+      int length);
+
+ private:
+  float *data_;
+  int size_;
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioBuffer.cpp

@@ -1,77 +1,35 @@
 #include "AudioBuffer.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 
 namespace audioapi {
 
-AudioBuffer::AudioBuffer(int numberOfChannels, int length, int sampleRate)
-    : numberOfChannels_(numberOfChannels),
-      length_(length),
-      sampleRate_(sampleRate),
-      duration_(static_cast<double>(length) / sampleRate) {
-  if (numberOfChannels != 1 && numberOfChannels != 2) {
-    throw std::invalid_argument("Invalid number of channels");
-  }
-
-  channels_ = new float *[numberOfChannels];
-
-  for (int i = 0; i < numberOfChannels; i++) {
-    channels_[i] = new float[length];
-
-    for (int j = 0; j < length; j++) {
-      channels_[i][j] = 0.0f;
-    }
-  }
+AudioBuffer::AudioBuffer(int numberOfChannels, int length, int sampleRate) {
+  bus_ = std::make_shared<AudioBus>(sampleRate, length, numberOfChannels);
 }
 
-int AudioBuffer::getNumberOfChannels() const {
-  return numberOfChannels_;
+AudioBuffer::AudioBuffer(AudioBus *bus) {
+  bus_ = std::shared_ptr<AudioBus>(bus);
 }
 
 int AudioBuffer::getLength() const {
-  return length_;
+  return bus_->getSize();
+}
+
+int AudioBuffer::getNumberOfChannels() const {
+  return bus_->getNumberOfChannels();
 }
 
 int AudioBuffer::getSampleRate() const {
-  return sampleRate_;
+  return bus_->getSampleRate();
 }
 
 double AudioBuffer::getDuration() const {
-  return duration_;
+  return static_cast<double>(getLength()) / getSampleRate();
 }
 
 float *AudioBuffer::getChannelData(int channel) const {
-  if (channel < 0 || channel >= numberOfChannels_) {
-    throw std::invalid_argument("Invalid channel number");
-  }
-
-  return channels_[channel];
-}
-
-std::shared_ptr<AudioBuffer> AudioBuffer::mix(int outputNumberOfChannels) {
-  if (outputNumberOfChannels != 1 && outputNumberOfChannels != 2) {
-    throw std::invalid_argument("Invalid number of channels");
-  }
-
-  if (outputNumberOfChannels == numberOfChannels_) {
-    return shared_from_this();
-  }
-
-  auto mixedBuffer = std::make_shared<AudioBuffer>(
-      outputNumberOfChannels, length_, sampleRate_);
-
-  switch (this->numberOfChannels_) {
-    case 1:
-      mixedBuffer->copyToChannel(this->channels_[0], length_, 0, 0);
-      mixedBuffer->copyToChannel(this->channels_[0], length_, 1, 0);
-      break;
-    case 2:
-      for (int i = 0; i < length_; i++) {
-        mixedBuffer->channels_[0][i] =
-            (this->channels_[0][i] + this->channels_[1][i]) / 2;
-      }
-      break;
-  }
-
-  return mixedBuffer;
+  return bus_->getChannel(channel)->getData();
 }
 
 void AudioBuffer::copyFromChannel(
@@ -79,19 +37,11 @@ void AudioBuffer::copyFromChannel(
     int destinationLength,
     int channelNumber,
     int startInChannel) const {
-  if (channelNumber < 0 || channelNumber >= numberOfChannels_) {
-    throw std::invalid_argument("Invalid channel number");
-  }
-
-  if (startInChannel < 0 || startInChannel >= length_) {
-    throw std::invalid_argument("Invalid start in channel");
-  }
-
-  std::copy(
-      channels_[channelNumber] + startInChannel,
-      channels_[channelNumber] + startInChannel +
-          std::min(destinationLength, length_ - startInChannel),
-      destination);
+  memcpy(
+      destination,
+      bus_->getChannel(channelNumber)->getData() + startInChannel,
+      std::min(destinationLength, getLength() - startInChannel) *
+          sizeof(float));
 }
 
 void AudioBuffer::copyToChannel(
@@ -99,17 +49,10 @@ void AudioBuffer::copyToChannel(
     int sourceLength,
     int channelNumber,
     int startInChannel) {
-  if (channelNumber < 0 || channelNumber >= numberOfChannels_) {
-    throw std::invalid_argument("Invalid channel number");
-  }
-
-  if (startInChannel < 0 || startInChannel >= length_) {
-    throw std::invalid_argument("Invalid start in channel");
-  }
-
-  std::copy(
+  memcpy(
+      bus_->getChannel(channelNumber)->getData() + startInChannel,
       source,
-      source + std::min(sourceLength, length_ - startInChannel),
-      channels_[channelNumber] + startInChannel);
+      std::min(sourceLength, getLength() - startInChannel) * sizeof(float));
 }
+
 } // namespace audioapi

package/common/cpp/core/AudioBuffer.h

@@ -7,15 +7,20 @@
 
 namespace audioapi {
 
+class AudioBus;
+
 class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
  public:
   explicit AudioBuffer(int numberOfChannels, int length, int sampleRate);
+  explicit AudioBuffer(AudioBus *bus);
+
+  [[nodiscard]] int getLength() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] double getDuration() const;
+
+  [[nodiscard]] int getNumberOfChannels() const;
+  [[nodiscard]] float *getChannelData(int channel) const;
 
-  int getNumberOfChannels() const;
-  int getLength() const;
-  int getSampleRate() const;
-  double getDuration() const;
-  float *getChannelData(int channel) const;
   void copyFromChannel(
       float *destination,
       int destinationLength,
@@ -28,15 +33,9 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
       int startInChannel);
 
  private:
-  friend class AudioBufferSourceNode;
-
-  int numberOfChannels_;
-  int length_;
-  int sampleRate_;
-  double duration_;
-  float **channels_;
+  std::shared_ptr<AudioBus> bus_;
 
-  std::shared_ptr<AudioBuffer> mix(int outputNumberOfChannels);
+  friend class AudioBufferSourceNode;
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -1,12 +1,17 @@
+#include <algorithm>
+
+#include "AudioArray.h"
 #include "AudioBufferSourceNode.h"
-#include "AudioContext.h"
+#include "AudioBus.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
-AudioBufferSourceNode::AudioBufferSourceNode(AudioContext *context)
+AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context), loop_(false), bufferIndex_(0) {
   numberOfInputs_ = 0;
-  buffer_ = std::nullopt;
+  buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+  isInitialized_ = true;
 }
 
 bool AudioBufferSourceNode::getLoop() const {
@@ -14,11 +19,7 @@ bool AudioBufferSourceNode::getLoop() const {
 }
 
 std::shared_ptr<AudioBuffer> AudioBufferSourceNode::getBuffer() const {
-  if (!buffer_.has_value()) {
-    throw std::runtime_error("Buffer is not set");
-  }
-
-  return buffer_.value();
+  return buffer_;
 }
 
 void AudioBufferSourceNode::setLoop(bool loop) {
@@ -27,32 +28,118 @@ void AudioBufferSourceNode::setLoop(bool loop) {
 
 void AudioBufferSourceNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer) {
-  buffer_ = buffer->mix(channelCount_);
+  if (!buffer) {
+    buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+    return;
+  }
+
+  buffer_ = buffer;
 }
 
-bool AudioBufferSourceNode::processAudio(float *audioData, int32_t numFrames) {
-  if (!isPlaying_ || !buffer_.has_value()) {
-    return false;
-  } else {
-    for (int i = 0; i < numFrames; ++i) {
-      for (int j = 0; j < channelCount_; j++) {
-        audioData[i * channelCount_ + j] =
-            buffer_.value()->getChannelData(j)[bufferIndex_];
+// 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) {
+  // No audio data to fill, zero the output and return.
+  if (!isPlaying() || !buffer_ || buffer_->getLength() == 0) {
+    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 (!loop_) {
+      playbackState_ = PlaybackState::FINISHED;
+      disable();
+    }
+
+    return;
+  }
+
+  // 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;
+
+    while (framesToProcess - outputBusIndex > 0) {
+      framesToCopy = std::min(
+          framesToProcess - outputBusIndex,
+          buffer_->getLength() - bufferIndex_);
+
+      processingBus->copy(
+          buffer_->bus_.get(), bufferIndex_, outputBusIndex, framesToCopy);
+
+      bufferIndex_ += framesToCopy;
+      outputBusIndex += framesToCopy;
+
+      if (bufferIndex_ < buffer_->getLength()) {
+        continue;
       }
 
-      bufferIndex_++;
+      bufferIndex_ %= buffer_->getLength();
+
+      if (!loop_) {
+        playbackState_ = PlaybackState::FINISHED;
+        disable();
 
-      if (bufferIndex_ >= buffer_.value()->getLength()) {
-        if (loop_) {
-          bufferIndex_ = 0;
-        } else {
-          isPlaying_ = false;
-          break;
+        if (framesToProcess - outputBusIndex > 0) {
+          processingBus->zero(outputBusIndex, framesToProcess - outputBusIndex);
         }
       }
     }
 
-    return true;
+    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());
+
+    playbackState_ = PlaybackState::FINISHED;
+    disable();
+
+    return;
+  }
+
+  // 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;
+  }
+
+  // Copy the entire buffer n times to the processing bus.
+  while (processingBusPosition + bufferSize <= framesToProcess) {
+    processingBus->copy(buffer_->bus_.get());
+    processingBusPosition += bufferSize;
+  }
+
+  // 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;
   }
 }
+
 } // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.h

@@ -1,26 +1,30 @@
 #pragma once
 
 #include <memory>
-#include <optional>
 
 #include "AudioBuffer.h"
 #include "AudioScheduledSourceNode.h"
 
 namespace audioapi {
 
+class AudioBus;
+
 class AudioBufferSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit AudioBufferSourceNode(AudioContext *context);
+  explicit AudioBufferSourceNode(BaseAudioContext *context);
 
-  bool getLoop() const;
-  std::shared_ptr<AudioBuffer> getBuffer() const;
+  [[nodiscard]] bool getLoop() const;
+  [[nodiscard]] std::shared_ptr<AudioBuffer> getBuffer() const;
   void setLoop(bool loop);
   void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
-  bool processAudio(float *audioData, int32_t numFrames) override;
+
+ protected:
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
   bool loop_;
-  std::optional<std::shared_ptr<AudioBuffer>> buffer_;
+  std::shared_ptr<AudioBuffer> buffer_;
   int bufferIndex_;
 };
+
 } // namespace audioapi