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

package/android/src/main/cpp/AudioPlayer/AudioPlayer.cpp

@@ -1,13 +1,14 @@
 
-#include "AudioBus.h"
-#include "Constants.h"
-#include "AudioArray.h"
 #include "AudioPlayer.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 #include "AudioContext.h"
+#include "Constants.h"
 
 namespace audioapi {
 
-AudioPlayer::AudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio)
+AudioPlayer::AudioPlayer(
+    const std::function<void(AudioBus *, int)> &renderAudio)
     : renderAudio_(renderAudio) {
   AudioStreamBuilder builder;
 
@@ -20,7 +21,9 @@ AudioPlayer::AudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio)
       ->setDataCallback(this)
       ->openStream(mStream_);
 
-  mBus_ = std::make_shared<AudioBus>(getSampleRate(), getBufferSizeInFrames(), CHANNEL_COUNT);
+  mBus_ = std::make_shared<AudioBus>(
+      getSampleRate(), getBufferSizeInFrames(), CHANNEL_COUNT);
+  isInitialized_ = true;
 }
 
 int AudioPlayer::getSampleRate() const {
@@ -38,6 +41,8 @@ void AudioPlayer::start() {
 }
 
 void AudioPlayer::stop() {
+  isInitialized_ = false;
+
   if (mStream_) {
     mStream_->requestStop();
     mStream_->close();
@@ -49,14 +54,18 @@ DataCallbackResult AudioPlayer::onAudioReady(
     AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
-  auto buffer = static_cast<float *>(audioData);
+  if (!isInitialized_) {
+    return DataCallbackResult::Continue;
+  }
 
+  auto buffer = static_cast<float *>(audioData);
   renderAudio_(mBus_.get(), numFrames);
 
   // TODO: optimize this with SIMD?
   for (int32_t i = 0; i < numFrames; i += 1) {
     for (int channel = 0; channel < CHANNEL_COUNT; channel += 1) {
-      buffer[i * CHANNEL_COUNT + channel] = mBus_->getChannel(channel)->getData()[i];
+      buffer[i * CHANNEL_COUNT + channel] =
+          mBus_->getChannel(channel)->getData()[i];
     }
   }
 

package/android/src/main/cpp/AudioPlayer/AudioPlayer.h

@@ -12,7 +12,7 @@ class AudioBus;
 
 class AudioPlayer : public AudioStreamDataCallback {
  public:
-  explicit AudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio);
+  explicit AudioPlayer(const std::function<void(AudioBus *, int)> &renderAudio);
 
   int getSampleRate() const;
   int getBufferSizeInFrames() const;
@@ -25,9 +25,10 @@ class AudioPlayer : public AudioStreamDataCallback {
       int32_t numFrames) override;
 
  private:
-  std::function<void(AudioBus*, int)> renderAudio_;
+  std::function<void(AudioBus *, int)> renderAudio_;
   std::shared_ptr<AudioStream> mStream_;
   std::shared_ptr<AudioBus> mBus_;
+  bool isInitialized_ = false;
 };
 
 } // namespace audioapi

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.cpp

@@ -4,8 +4,10 @@ namespace audioapi {
 using namespace facebook;
 
 AudioAPIInstallerHostObject::AudioAPIInstallerHostObject(
-    const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper)
-    : wrapper_(wrapper) {}
+    const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper, jsi::Runtime* runtime, const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker)
+    : wrapper_(wrapper) {
+      promiseVendor_ = std::make_shared<JsiPromise::PromiseVendor>(runtime, jsInvoker);
+    }
 
 std::vector<jsi::PropNameID> AudioAPIInstallerHostObject::getPropertyNames(
     jsi::Runtime &runtime) {
@@ -32,7 +34,7 @@ jsi::Value AudioAPIInstallerHostObject::get(
             size_t count) -> jsi::Value {
           auto audioContext = wrapper_->createAudioContext();
           auto audioContextHostObject =
-              AudioContextHostObject::createFromWrapper(audioContext);
+              AudioContextHostObject::createFromWrapper(audioContext, promiseVendor_);
           return jsi::Object::createFromHostObject(
               runtime, audioContextHostObject);
         });

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.h

@@ -1,12 +1,15 @@
 #pragma once
 
+#include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
 #include <vector>
 
+
 #include "AudioAPIInstallerWrapper.h"
 #include "AudioContextHostObject.h"
+#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -16,7 +19,7 @@ class AudioAPIInstallerWrapper;
 class AudioAPIInstallerHostObject : public jsi::HostObject {
  public:
   explicit AudioAPIInstallerHostObject(
-      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper);
+      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper, jsi::Runtime* runtime, const std::shared_ptr<react::CallInvoker> &jsInvoker);
 
 #ifdef ANDROID
   static void createAndInstallFromWrapper(
@@ -41,5 +44,6 @@ class AudioAPIInstallerHostObject : public jsi::HostObject {
 
  private:
   std::shared_ptr<AudioAPIInstallerWrapper> wrapper_;
+  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioBufferHostObject.cpp

@@ -128,6 +128,12 @@ jsi::Value AudioBufferHostObject::get(
         });
   }
 
+  // `decodeAudioData` is a method that returns a promise to AudioBufferHostObject
+  // It seems that async/await checks for the presence of `then` method on the object
+  if (propName == "then") {
+    return jsi::Value::undefined();
+  }
+
   throw std::runtime_error("Not yet implemented!");
 }
 

package/common/cpp/HostObjects/AudioContextHostObject.cpp

@@ -4,8 +4,8 @@ namespace audioapi {
 using namespace facebook;
 
 AudioContextHostObject::AudioContextHostObject(
-    const std::shared_ptr<AudioContextWrapper> &wrapper)
-    : BaseAudioContextHostObject(wrapper) {}
+    const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    : BaseAudioContextHostObject(wrapper, promiseVendor) {}
 
 std::vector<jsi::PropNameID> AudioContextHostObject::getPropertyNames(
     jsi::Runtime &runtime) {

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -4,6 +4,7 @@
 #include <memory>
 #include <vector>
 
+#include"JsiPromise.h"
 #include "AudioContextWrapper.h"
 #include "BaseAudioContextHostObject.h"
 
@@ -13,7 +14,7 @@ using namespace facebook;
 class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
-      const std::shared_ptr<AudioContextWrapper> &wrapper);
+      const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
@@ -25,8 +26,8 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
   static std::shared_ptr<AudioContextHostObject> createFromWrapper(
-      const std::shared_ptr<AudioContextWrapper> &wrapper) {
-    return std::make_shared<AudioContextHostObject>(wrapper);
+      const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor) {
+    return std::make_shared<AudioContextHostObject>(wrapper, promiseVendor);
   }
 
  private:

package/common/cpp/HostObjects/BaseAudioContextHostObject.cpp

@@ -1,11 +1,13 @@
+#include <thread>
+
 #include "BaseAudioContextHostObject.h"
 
 namespace audioapi {
 using namespace facebook;
 
 BaseAudioContextHostObject::BaseAudioContextHostObject(
-    const std::shared_ptr<BaseAudioContextWrapper> &wrapper)
-    : wrapper_(wrapper) {
+    const std::shared_ptr<BaseAudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    : wrapper_(wrapper), promiseVendor_(promiseVendor) {
   auto destinationNodeWrapper = wrapper_->getDestination();
   destination_ =
       AudioDestinationNodeHostObject::createFromWrapper(destinationNodeWrapper);
@@ -30,6 +32,8 @@ std::vector<jsi::PropNameID> BaseAudioContextHostObject::getPropertyNames(
   propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createBuffer"));
   propertyNames.push_back(
       jsi::PropNameID::forUtf8(runtime, "createPeriodicWave"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "decodeAudioDataSource"));
   return propertyNames;
 }
 
@@ -200,6 +204,28 @@ jsi::Value BaseAudioContextHostObject::get(
         });
   }
 
+  if (propName == "decodeAudioDataSource") {
+    auto decode = [this](jsi::Runtime& runtime,
+                         const jsi::Value&,
+                         const jsi::Value* arguments,
+                         size_t count) -> jsi::Value {
+      auto sourcePath = arguments[0].getString(runtime).utf8(runtime);
+
+      auto promise = promiseVendor_->createPromise([this, &runtime, sourcePath](std::shared_ptr<JsiPromise::Promise> promise) {
+        std::thread([this, &runtime, sourcePath, promise = std::move(promise)]() {
+          auto results = wrapper_->decodeAudioDataSource(sourcePath);
+          auto audioBufferHostObject = AudioBufferHostObject::createFromWrapper(results);
+
+          promise->resolve(jsi::Object::createFromHostObject(runtime, audioBufferHostObject));
+        }).detach();
+      });
+
+      return promise;
+    };
+
+    return jsi::Function::createFromHostFunction(runtime, propNameId, 1, decode);
+  }
+
   throw std::runtime_error("Not yet implemented!");
 }
 

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -5,6 +5,7 @@
 #include <utility>
 #include <vector>
 
+#include "JsiPromise.h"
 #include "AudioBufferHostObject.h"
 #include "AudioBufferSourceNodeHostObject.h"
 #include "AudioDestinationNodeHostObject.h"
@@ -21,7 +22,7 @@ using namespace facebook;
 class BaseAudioContextHostObject : public jsi::HostObject {
  public:
   explicit BaseAudioContextHostObject(
-      const std::shared_ptr<BaseAudioContextWrapper> &wrapper);
+      const std::shared_ptr<BaseAudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
@@ -35,5 +36,6 @@ class BaseAudioContextHostObject : public jsi::HostObject {
  protected:
   std::shared_ptr<BaseAudioContextWrapper> wrapper_;
   std::shared_ptr<AudioDestinationNodeHostObject> destination_;
+  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
 };
 } // namespace audioapi

package/common/cpp/core/AudioArray.cpp

@@ -5,14 +5,14 @@
 
 namespace audioapi {
 
-AudioArray::AudioArray(int size) : size_(size), data_(0) {
+AudioArray::AudioArray(int size) : data_(nullptr), size_(size) {
   resize(size);
 }
 
 AudioArray::~AudioArray() {
   if (data_) {
     delete[] data_;
-    data_ = 0;
+    data_ = nullptr;
   }
 }
 
@@ -20,15 +20,15 @@ int AudioArray::getSize() const {
   return size_;
 }
 
-float* AudioArray::getData() const {
+float *AudioArray::getData() const {
   return data_;
 }
 
-float& AudioArray::operator[](int index) {
+float &AudioArray::operator[](int index) {
   return data_[index];
 }
 
-const float& AudioArray::operator[](int index) const {
+const float &AudioArray::operator[](int index) const {
   return data_[index];
 }
 
@@ -75,29 +75,43 @@ void AudioArray::zero(int start, int length) {
   memset(data_ + start, 0, length * sizeof(float));
 }
 
-void AudioArray::sum(const AudioArray* source) {
+void AudioArray::sum(const AudioArray *source) {
   sum(source, 0, 0, size_);
 }
 
-void AudioArray::sum(const AudioArray* source, int start, int length) {
+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::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) {
+void AudioArray::copy(const AudioArray *source) {
   copy(source, 0, size_);
 }
 
-void AudioArray::copy(const AudioArray* source, int start, int length) {
+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));
+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

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <memory>
 #include <algorithm>
+#include <memory>
 
 namespace audioapi {
 
@@ -11,28 +11,34 @@ class AudioArray {
   ~AudioArray();
 
   [[nodiscard]] int getSize() const;
-  float* getData() const;
-
+  [[nodiscard]] float *getData() const;
 
-  float& operator[](int index);
-  const float& operator[](int index) const;
+  float &operator[](int index);
+  const float &operator[](int index) const;
 
   void normalize();
   void resize(int size);
   void scale(float value);
-  float getMaxAbsValue() const;
+  [[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);
-
+  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_;

package/common/cpp/core/AudioBuffer.cpp

@@ -1,6 +1,6 @@
-#include "AudioBus.h"
-#include "AudioArray.h"
 #include "AudioBuffer.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 
 namespace audioapi {
 
@@ -8,6 +8,10 @@ AudioBuffer::AudioBuffer(int numberOfChannels, int length, int sampleRate) {
   bus_ = std::make_shared<AudioBus>(sampleRate, length, numberOfChannels);
 }
 
+AudioBuffer::AudioBuffer(AudioBus *bus) {
+  bus_ = std::shared_ptr<AudioBus>(bus);
+}
+
 int AudioBuffer::getLength() const {
   return bus_->getSize();
 }
@@ -24,7 +28,7 @@ double AudioBuffer::getDuration() const {
   return static_cast<double>(getLength()) / getSampleRate();
 }
 
-float* AudioBuffer::getChannelData(int channel) const {
+float *AudioBuffer::getChannelData(int channel) const {
   return bus_->getChannel(channel)->getData();
 }
 
@@ -34,10 +38,10 @@ void AudioBuffer::copyFromChannel(
     int channelNumber,
     int startInChannel) const {
   memcpy(
-    destination,
-    bus_->getChannel(channelNumber)->getData() + startInChannel,
-    std::min(destinationLength, getLength() - startInChannel) * sizeof(float)
-  );
+      destination,
+      bus_->getChannel(channelNumber)->getData() + startInChannel,
+      std::min(destinationLength, getLength() - startInChannel) *
+          sizeof(float));
 }
 
 void AudioBuffer::copyToChannel(
@@ -46,10 +50,9 @@ void AudioBuffer::copyToChannel(
     int channelNumber,
     int startInChannel) {
   memcpy(
-    bus_->getChannel(channelNumber)->getData() + startInChannel,
-    source,
-    std::min(sourceLength, getLength() - startInChannel) * sizeof(float)
-  );
+      bus_->getChannel(channelNumber)->getData() + startInChannel,
+      source,
+      std::min(sourceLength, getLength() - startInChannel) * sizeof(float));
 }
 
 } // namespace audioapi

package/common/cpp/core/AudioBuffer.h

@@ -12,6 +12,7 @@ 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;

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -1,9 +1,9 @@
 #include <algorithm>
 
-#include "AudioBus.h"
 #include "AudioArray.h"
-#include "BaseAudioContext.h"
 #include "AudioBufferSourceNode.h"
+#include "AudioBus.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
@@ -28,7 +28,6 @@ void AudioBufferSourceNode::setLoop(bool loop) {
 
 void AudioBufferSourceNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer) {
-
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
     return;
@@ -37,16 +36,20 @@ void AudioBufferSourceNode::setBuffer(
   buffer_ = buffer;
 }
 
-// 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) {
+// 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.
+  // 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());
 
@@ -65,9 +68,12 @@ void AudioBufferSourceNode::processNode(AudioBus* processingBus, int framesToPro
     int framesToCopy = 0;
 
     while (framesToProcess - outputBusIndex > 0) {
-      framesToCopy = std::min(framesToProcess - outputBusIndex, buffer_->getLength() - bufferIndex_);
+      framesToCopy = std::min(
+          framesToProcess - outputBusIndex,
+          buffer_->getLength() - bufferIndex_);
 
-      processingBus->copy(buffer_->bus_.get(), bufferIndex_, outputBusIndex, framesToCopy);
+      processingBus->copy(
+          buffer_->bus_.get(), bufferIndex_, outputBusIndex, framesToCopy);
 
       bufferIndex_ += framesToCopy;
       outputBusIndex += framesToCopy;
@@ -76,12 +82,11 @@ void AudioBufferSourceNode::processNode(AudioBus* processingBus, int framesToPro
         continue;
       }
 
-
       bufferIndex_ %= buffer_->getLength();
 
       if (!loop_) {
-      playbackState_ = PlaybackState::FINISHED;
-      disable();
+        playbackState_ = PlaybackState::FINISHED;
+        disable();
 
         if (framesToProcess - outputBusIndex > 0) {
           processingBus->zero(outputBusIndex, framesToProcess - outputBusIndex);
@@ -94,9 +99,11 @@ void AudioBufferSourceNode::processNode(AudioBus* processingBus, int framesToPro
 
   // 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.
+    // 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());
+    processingBus->zero(
+        buffer_->getLength(), framesToProcess - buffer_->getLength());
 
     playbackState_ = PlaybackState::FINISHED;
     disable();
@@ -104,9 +111,10 @@ void AudioBufferSourceNode::processNode(AudioBus* processingBus, int framesToPro
     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.
+  // 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;
@@ -125,9 +133,11 @@ void AudioBufferSourceNode::processNode(AudioBus* processingBus, int framesToPro
     processingBusPosition += bufferSize;
   }
 
-  // Fill in the remaining frames from the processing buffer and update buffer index for next render quantum.
+  // 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);
+    processingBus->copy(
+        buffer_->bus_.get(), 0, processingBusPosition, remainingFrames);
     bufferIndex_ = remainingFrames;
   }
 }

package/common/cpp/core/AudioBufferSourceNode.h

@@ -19,7 +19,7 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
   void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
 
  protected:
-  void processNode(AudioBus* processingBus, int framesToProcess) override;
+  void processNode(AudioBus *processingBus, int framesToProcess) override;
 
  private:
   bool loop_;