react-native-audio-api 0.4.0 → 0.4.2

package/common/cpp/core/AudioArray.h

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

package/common/cpp/core/AudioBuffer.cpp

@@ -4,7 +4,10 @@
 
 namespace audioapi {
 
-AudioBuffer::AudioBuffer(int numberOfChannels, int length, int sampleRate) {
+AudioBuffer::AudioBuffer(
+    int numberOfChannels,
+    size_t length,
+    float sampleRate) {
   bus_ = std::make_shared<AudioBus>(sampleRate, length, numberOfChannels);
 }
 
@@ -12,7 +15,7 @@ AudioBuffer::AudioBuffer(AudioBus *bus) {
   bus_ = std::shared_ptr<AudioBus>(bus);
 }
 
-int AudioBuffer::getLength() const {
+size_t AudioBuffer::getLength() const {
   return bus_->getSize();
 }
 
@@ -20,12 +23,12 @@ int AudioBuffer::getNumberOfChannels() const {
   return bus_->getNumberOfChannels();
 }
 
-int AudioBuffer::getSampleRate() const {
+float AudioBuffer::getSampleRate() const {
   return bus_->getSampleRate();
 }
 
-double AudioBuffer::getDuration() const {
-  return static_cast<double>(getLength()) / getSampleRate();
+float AudioBuffer::getDuration() const {
+  return static_cast<float>(getLength()) / getSampleRate();
 }
 
 float *AudioBuffer::getChannelData(int channel) const {
@@ -34,9 +37,9 @@ float *AudioBuffer::getChannelData(int channel) const {
 
 void AudioBuffer::copyFromChannel(
     float *destination,
-    int destinationLength,
+    size_t destinationLength,
     int channelNumber,
-    int startInChannel) const {
+    size_t startInChannel) const {
   memcpy(
       destination,
       bus_->getChannel(channelNumber)->getData() + startInChannel,
@@ -46,9 +49,9 @@ void AudioBuffer::copyFromChannel(
 
 void AudioBuffer::copyToChannel(
     const float *source,
-    int sourceLength,
+    size_t sourceLength,
     int channelNumber,
-    int startInChannel) {
+    size_t startInChannel) {
   memcpy(
       bus_->getChannel(channelNumber)->getData() + startInChannel,
       source,

package/common/cpp/core/AudioBuffer.h

@@ -4,6 +4,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <cstddef>
 
 namespace audioapi {
 
@@ -11,26 +12,26 @@ class AudioBus;
 
 class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
  public:
-  explicit AudioBuffer(int numberOfChannels, int length, int sampleRate);
+  explicit AudioBuffer(int numberOfChannels, size_t length, float sampleRate);
   explicit AudioBuffer(AudioBus *bus);
 
-  [[nodiscard]] int getLength() const;
-  [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] double getDuration() const;
+  [[nodiscard]] size_t getLength() const;
+  [[nodiscard]] float getSampleRate() const;
+  [[nodiscard]] float getDuration() const;
 
   [[nodiscard]] int getNumberOfChannels() const;
   [[nodiscard]] float *getChannelData(int channel) const;
 
   void copyFromChannel(
       float *destination,
-      int destinationLength,
+      size_t destinationLength,
       int channelNumber,
-      int startInChannel) const;
+      size_t startInChannel) const;
   void copyToChannel(
       const float *source,
-      int sourceLength,
+      size_t sourceLength,
       int channelNumber,
-      int startInChannel);
+      size_t startInChannel);
 
  private:
   std::shared_ptr<AudioBus> bus_;

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -16,10 +16,9 @@ AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
       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);
+  detuneParam_ = std::make_shared<AudioParam>(0.0, MIN_DETUNE, MAX_DETUNE);
   playbackRateParam_ = std::make_shared<AudioParam>(
       1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
 
@@ -73,7 +72,9 @@ void AudioBufferSourceNode::setBuffer(
 
   buffer_ = buffer;
   alignedBus_ = std::make_shared<AudioBus>(
-      context_->getSampleRate(), buffer_->getLength());
+      context_->getSampleRate(),
+      buffer_->getLength(),
+      buffer_->getNumberOfChannels());
 
   alignedBus_->zero();
   alignedBus_->sum(buffer_->bus_.get());
@@ -90,7 +91,7 @@ void AudioBufferSourceNode::processNode(
 
   // No audio data to fill, zero the output and return.
   if (!isPlaying() || !alignedBus_ || alignedBus_->getSize() == 0 ||
-      !playbackRate) {
+      playbackRate == 0.0f) {
     processingBus->zero();
     return;
   }
@@ -115,7 +116,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
     size_t startOffset,
     size_t offsetLength,
     float playbackRate) {
-  size_t direction = playbackRate < 0 ? -1 : 1;
+  size_t direction = playbackRate < 0.0f ? -1 : 1;
 
   auto readIndex = static_cast<size_t>(vReadIndex_);
   size_t writeIndex = startOffset;
@@ -165,7 +166,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
   }
 
   // update reading index for next render quantum
-  vReadIndex_ = readIndex;
+  vReadIndex_ = static_cast<double>(readIndex);
 }
 
 void AudioBufferSourceNode::processWithInterpolation(
@@ -173,13 +174,13 @@ void AudioBufferSourceNode::processWithInterpolation(
     size_t startOffset,
     size_t offsetLength,
     float playbackRate) {
-  size_t direction = playbackRate < 0 ? -1 : 1;
+  size_t direction = playbackRate < 0.0f ? -1 : 1;
 
   size_t writeIndex = startOffset;
 
-  double vFrameStart = getVirtualStartFrame();
-  double vFrameEnd = getVirtualEndFrame();
-  double vFrameDelta = vFrameEnd - vFrameStart;
+  auto vFrameStart = getVirtualStartFrame();
+  auto vFrameEnd = getVirtualEndFrame();
+  auto vFrameDelta = vFrameEnd - vFrameStart;
 
   auto frameStart = static_cast<size_t>(vFrameStart);
   auto frameEnd = static_cast<size_t>(vFrameEnd);
@@ -195,7 +196,8 @@ void AudioBufferSourceNode::processWithInterpolation(
   while (framesLeft > 0) {
     auto readIndex = static_cast<size_t>(vReadIndex_);
     size_t nextReadIndex = readIndex + 1;
-    float factor = vReadIndex_ - readIndex;
+    auto factor =
+        static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
 
     if (nextReadIndex >= frameEnd) {
       nextReadIndex = loop_ ? frameStart : readIndex;
@@ -210,11 +212,11 @@ void AudioBufferSourceNode::processWithInterpolation(
     }
 
     writeIndex += 1;
-    vReadIndex_ += playbackRate * direction;
+    vReadIndex_ += playbackRate * static_cast<double>(direction);
     framesLeft -= 1;
 
     if (vReadIndex_ < vFrameStart || vReadIndex_ >= vFrameEnd) {
-      vReadIndex_ -= direction * vFrameDelta;
+      vReadIndex_ -= static_cast<double>(direction) * vFrameDelta;
 
       if (!loop_) {
         processingBus->zero(writeIndex, framesLeft);
@@ -227,23 +229,26 @@ void AudioBufferSourceNode::processWithInterpolation(
 }
 
 float AudioBufferSourceNode::getPlaybackRateValue(size_t &startOffset) {
-  double time =
-      context_->getCurrentTime() + startOffset / context_->getSampleRate();
+  auto time = context_->getCurrentTime() +
+      static_cast<double>(startOffset) / context_->getSampleRate();
 
-  return playbackRateParam_->getValueAtTime(time) *
-      std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+  auto sampleRateFactor = buffer_->getSampleRate() / context_->getSampleRate();
+  auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+  auto playbackRate = playbackRateParam_->getValueAtTime(time);
+
+  return playbackRate * sampleRateFactor * detune;
 }
 
 double AudioBufferSourceNode::getVirtualStartFrame() {
-  double loopStartFrame = loopStart_ * context_->getSampleRate();
+  auto 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();
+  auto inputBufferLength = static_cast<double>(alignedBus_->getSize());
+  auto loopEndFrame = loopEnd_ * context_->getSampleRate();
 
   return loop_ && loopEndFrame > 0 && loopStart_ < loopEnd_
       ? std::min(loopEndFrame, inputBufferLength)

package/common/cpp/core/AudioBufferSourceNode.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <cstddef>
 
 #include "AudioBuffer.h"
 #include "AudioScheduledSourceNode.h"

package/common/cpp/core/AudioBus.cpp

@@ -17,12 +17,8 @@ namespace audioapi {
 /**
  * Public interfaces - memory management
  */
-AudioBus::AudioBus(int sampleRate, int size)
-    : numberOfChannels_(CHANNEL_COUNT), sampleRate_(sampleRate), size_(size) {
-  createChannels();
-}
 
-AudioBus::AudioBus(int sampleRate, int size, int numberOfChannels)
+AudioBus::AudioBus(float sampleRate, size_t size, int numberOfChannels)
     : numberOfChannels_(numberOfChannels),
       sampleRate_(sampleRate),
       size_(size) {
@@ -41,11 +37,11 @@ int AudioBus::getNumberOfChannels() const {
   return numberOfChannels_;
 }
 
-int AudioBus::getSampleRate() const {
+float AudioBus::getSampleRate() const {
   return sampleRate_;
 }
 
-int AudioBus::getSize() const {
+size_t AudioBus::getSize() const {
   return size_;
 }
 
@@ -56,7 +52,7 @@ AudioArray *AudioBus::getChannel(int index) const {
 AudioArray *AudioBus::getChannelByType(int channelType) const {
   switch (getNumberOfChannels()) {
     case 1: // mono
-      if (channelType == ChannelMono || channelType == ChannelLeft) {
+      if (channelType == ChannelMono) {
         return getChannel(0);
       }
       return nullptr;
@@ -131,7 +127,7 @@ void AudioBus::zero() {
   zero(0, getSize());
 }
 
-void AudioBus::zero(int start, int length) {
+void AudioBus::zero(size_t start, size_t length) {
   for (auto it = channels_.begin(); it != channels_.end(); it += 1) {
     it->get()->zero(start, length);
   }
@@ -169,15 +165,15 @@ void AudioBus::sum(const AudioBus *source) {
   sum(source, 0, 0, getSize());
 }
 
-void AudioBus::sum(const AudioBus *source, int start, int length) {
+void AudioBus::sum(const AudioBus *source, size_t start, size_t length) {
   sum(source, start, start, length);
 }
 
 void AudioBus::sum(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   if (source == this) {
     return;
   }
@@ -210,15 +206,15 @@ void AudioBus::copy(const AudioBus *source) {
   copy(source, 0, 0, getSize());
 }
 
-void AudioBus::copy(const AudioBus *source, int start, int length) {
+void AudioBus::copy(const AudioBus *source, size_t start, size_t length) {
   copy(source, start, start, length);
 }
 
 void AudioBus::copy(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   if (source == this) {
     return;
   }
@@ -255,9 +251,9 @@ void AudioBus::createChannels() {
 
 void AudioBus::discreteSum(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) const {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) const {
   int numberOfChannels =
       std::min(getNumberOfChannels(), source->getNumberOfChannels());
 
@@ -272,9 +268,9 @@ void AudioBus::discreteSum(
 
 void AudioBus::sumByUpMixing(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   int numberOfSourceChannels = source->getNumberOfChannels();
   int numberOfChannels = getNumberOfChannels();
 
@@ -351,9 +347,9 @@ void AudioBus::sumByUpMixing(
 
 void AudioBus::sumByDownMixing(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   int numberOfSourceChannels = source->getNumberOfChannels();
   int numberOfChannels = getNumberOfChannels();
 

package/common/cpp/core/AudioBus.h

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 namespace audioapi {
 
@@ -21,14 +22,13 @@ class AudioBus {
     ChannelSurroundRight = 5,
   };
 
-  explicit AudioBus(int sampleRate, int size);
-  explicit AudioBus(int sampleRate, int size, int numberOfChannels);
+  explicit AudioBus(float sampleRate, size_t size, int numberOfChannels);
 
   ~AudioBus();
 
   [[nodiscard]] int getNumberOfChannels() const;
-  [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] int getSize() const;
+  [[nodiscard]] float getSampleRate() const;
+  [[nodiscard]] size_t getSize() const;
   [[nodiscard]] AudioArray *getChannel(int index) const;
   [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
 
@@ -37,47 +37,47 @@ class AudioBus {
   [[nodiscard]] float maxAbsValue() const;
 
   void zero();
-  void zero(int start, int length);
+  void zero(size_t start, size_t length);
 
   void sum(const AudioBus *source);
-  void sum(const AudioBus *source, int start, int length);
+  void sum(const AudioBus *source, size_t start, size_t length);
   void sum(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
 
   void copy(const AudioBus *source);
-  void copy(const AudioBus *source, int start, int length);
+  void copy(const AudioBus *source, size_t start, size_t length);
   void copy(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
 
  private:
   std::vector<std::shared_ptr<AudioArray>> channels_;
 
   int numberOfChannels_;
-  int sampleRate_;
-  int size_;
+  float sampleRate_;
+  size_t size_;
 
   void createChannels();
   void discreteSum(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length) const;
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length) const;
   void sumByUpMixing(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
   void sumByDownMixing(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioContext.cpp

@@ -5,16 +5,56 @@
 #endif
 
 #include "AudioContext.h"
+#include "AudioDecoder.h"
+#include "AudioDestinationNode.h"
 
 namespace audioapi {
-
 AudioContext::AudioContext() : BaseAudioContext() {
+#ifdef ANDROID
+  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+#else
+  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
+#endif
+  sampleRate_ = audioPlayer_->getSampleRate();
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
+
+  audioPlayer_->start();
+}
+
+AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
+#ifdef ANDROID
+  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio(), sampleRate);
+#else
+  audioPlayer_ =
+      std::make_shared<IOSAudioPlayer>(this->renderAudio(), sampleRate);
+#endif
+  sampleRate_ = audioPlayer_->getSampleRate();
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
+
   audioPlayer_->start();
 }
 
+AudioContext::~AudioContext() {
+  if (isRunning()) {
+    return;
+  }
+
+  close();
+}
+
 void AudioContext::close() {
   state_ = ContextState::CLOSED;
   audioPlayer_->stop();
 }
 
+std::function<void(AudioBus *, int)> AudioContext::renderAudio() {
+  if (!isRunning()) {
+    return [](AudioBus *, int) {};
+  }
+
+  return [this](AudioBus *data, int frames) {
+    destination_->renderAudio(data, frames);
+  };
+}
+
 } // namespace audioapi

package/common/cpp/core/AudioContext.h

@@ -1,16 +1,33 @@
 #pragma once
 
 #include <memory>
+#include <functional>
 
 #include "BaseAudioContext.h"
 
 namespace audioapi {
+#ifdef ANDROID
+class AudioPlayer;
+#else
+class IOSAudioPlayer;
+#endif
 
 class AudioContext : public BaseAudioContext {
  public:
   AudioContext();
+  explicit AudioContext(float sampleRate);
+  ~AudioContext() override;
 
   void close();
+
+  std::function<void(AudioBus *, int)> renderAudio();
+
+ private:
+#ifdef ANDROID
+    std::shared_ptr<AudioPlayer> audioPlayer_;
+#else
+    std::shared_ptr<IOSAudioPlayer> audioPlayer_;
+#endif
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioDecoder.h

@@ -8,12 +8,12 @@ class AudioBus;
 
 class AudioDecoder {
  public:
-  explicit AudioDecoder(int sampleRate) : sampleRate_(sampleRate) {}
+  explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
 
   [[nodiscard]] AudioBus *decodeWithFilePath(const std::string &path) const;
 
  private:
-  int sampleRate_;
+  float sampleRate_;
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -25,7 +25,7 @@ double AudioDestinationNode::getCurrentTime() const {
 
 void AudioDestinationNode::renderAudio(
     AudioBus *destinationBus,
-    int32_t numFrames) {
+    int numFrames) {
   if (!numFrames || !destinationBus || !isInitialized_) {
     return;
   }

package/common/cpp/core/AudioDestinationNode.h

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 #include "AudioNode.h"
 
@@ -15,7 +16,7 @@ class AudioDestinationNode : public AudioNode {
  public:
   explicit AudioDestinationNode(BaseAudioContext *context);
 
-  void renderAudio(AudioBus *audioData, int32_t numFrames);
+  void renderAudio(AudioBus *audioData, int numFrames);
 
   std::size_t getCurrentSampleFrame() const;
   double getCurrentTime() const;