react-native-audio-api 0.4.11 → 0.4.12-beta.1

package/common/cpp/HostObjects/AudioBufferSourceNodeHostObject.h

@@ -23,8 +23,7 @@ class AudioBufferSourceNodeHostObject
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopStart),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopEnd),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, detune),
-        JSI_EXPORT_PROPERTY_GETTER(
-            AudioBufferSourceNodeHostObject, playbackRate));
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, playbackRate));
 
     addSetters(
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loop),

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -19,6 +19,7 @@
 #include "PeriodicWaveHostObject.h"
 #include "StereoPannerNodeHostObject.h"
 #include "AnalyserNodeHostObject.h"
+#include "StretcherNodeHostObject.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -44,6 +45,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStretcher),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource));
   }
 
@@ -140,6 +142,12 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return jsi::Object::createFromHostObject(runtime, analyserHostObject);
   }
 
+  JSI_HOST_FUNCTION(createStretcher) {
+    auto stretcher = context_->createStretcher();
+    auto stretcherHostObject = std::make_shared<StretcherNodeHostObject>(stretcher);
+    return jsi::Object::createFromHostObject(runtime, stretcherHostObject);
+  }
+
   JSI_HOST_FUNCTION(decodeAudioDataSource) {
     auto sourcePath = args[0].getString(runtime).utf8(runtime);
 

package/common/cpp/HostObjects/GainNodeHostObject.h

@@ -19,9 +19,9 @@ class GainNodeHostObject : public AudioNodeHostObject {
 
   JSI_PROPERTY_GETTER(gain) {
     auto gainNode = std::static_pointer_cast<GainNode>(node_);
-    auto gainParam_ =
+    auto gainParam =
         std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
-    return jsi::Object::createFromHostObject(runtime, gainParam_);
+    return jsi::Object::createFromHostObject(runtime, gainParam);
   }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/StretcherNodeHostObject.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "StretcherNode.h"
+
+namespace audioapi {
+    using namespace facebook;
+
+    class StretcherNodeHostObject : public AudioNodeHostObject {
+    public:
+        explicit StretcherNodeHostObject(const std::shared_ptr<StretcherNode> &node)
+                : AudioNodeHostObject(node) {
+            addGetters(JSI_EXPORT_PROPERTY_GETTER(StretcherNodeHostObject, rate),
+                       JSI_EXPORT_PROPERTY_GETTER(StretcherNodeHostObject, semitones));
+        }
+
+        JSI_PROPERTY_GETTER(rate) {
+            auto stretcherNode = std::static_pointer_cast<StretcherNode>(node_);
+            auto rateParam =
+                    std::make_shared<AudioParamHostObject>(stretcherNode->getRateParam());
+            return jsi::Object::createFromHostObject(runtime, rateParam);
+        }
+
+        JSI_PROPERTY_GETTER(semitones) {
+            auto stretcherNode = std::static_pointer_cast<StretcherNode>(node_);
+            auto semitonesParam =
+                    std::make_shared<AudioParamHostObject>(stretcherNode->getSemitonesParam());
+            return jsi::Object::createFromHostObject(runtime, semitonesParam);
+        }
+    };
+} // namespace audioapi

package/common/cpp/core/AudioBus.cpp

@@ -119,6 +119,14 @@ AudioArray *AudioBus::getChannelByType(int channelType) const {
   }
 }
 
+AudioArray &AudioBus::operator[](size_t index) {
+  return *channels_[index];
+}
+
+const AudioArray &AudioBus::operator[](size_t index) const {
+  return *channels_[index];
+}
+
 /**
  * Public interfaces - audio processing and setters
  */

package/common/cpp/core/AudioBus.h

@@ -34,6 +34,9 @@ class AudioBus {
   [[nodiscard]] AudioArray *getChannel(int index) const;
   [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
 
+    AudioArray &operator[](size_t index);
+    const AudioArray &operator[](size_t index) const;
+
   void normalize();
   void scale(float value);
   [[nodiscard]] float maxAbsValue() const;

package/common/cpp/core/AudioDestinationNode.cpp

@@ -33,7 +33,7 @@ void AudioDestinationNode::renderAudio(
 
   destinationBus->zero();
 
-  auto processedBus = processAudio(destinationBus, numFrames);
+  auto processedBus = processAudio(destinationBus, numFrames, true);
 
   if (processedBus && processedBus != destinationBus) {
     destinationBus->copy(processedBus.get());

package/common/cpp/core/AudioNode.cpp

@@ -99,17 +99,19 @@ std::string AudioNode::toString(ChannelInterpretation interpretation) {
 
 std::shared_ptr<AudioBus> AudioNode::processAudio(
     std::shared_ptr<AudioBus> outputBus,
-    int framesToProcess) {
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
   if (!isInitialized_) {
     return outputBus;
   }
 
-  if (isAlreadyProcessed()) {
+  if (checkIsAlreadyProcessed && isAlreadyProcessed()) {
     return audioBus_;
   }
 
   // Process inputs and return the bus with the most channels.
-  auto processingBus = processInputs(outputBus, framesToProcess);
+  auto processingBus =
+      processInputs(outputBus, framesToProcess, checkIsAlreadyProcessed);
 
   // Apply channel count mode.
   processingBus = applyChannelCountMode(processingBus);
@@ -142,7 +144,8 @@ bool AudioNode::isAlreadyProcessed() {
 
 std::shared_ptr<AudioBus> AudioNode::processInputs(
     const std::shared_ptr<AudioBus> &outputBus,
-    int framesToProcess) {
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
   auto processingBus = audioBus_;
   processingBus->zero();
 
@@ -154,7 +157,8 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
       continue;
     }
 
-    auto inputBus = inputNode->processAudio(outputBus, framesToProcess);
+    auto inputBus = inputNode->processAudio(
+        outputBus, framesToProcess, checkIsAlreadyProcessed);
     inputBuses_.push_back(inputBus);
 
     if (maxNumberOfChannels < inputBus->getNumberOfChannels()) {

package/common/cpp/core/AudioNode.h

@@ -57,16 +57,18 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   std::size_t lastRenderedFrame_{SIZE_MAX};
 
  private:
+  friend class StretcherNode;
+
   std::vector<std::shared_ptr<AudioBus>> inputBuses_ = {};
 
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
 
-  std::shared_ptr<AudioBus> processAudio(std::shared_ptr<AudioBus> outputBus, int framesToProcess);
+  virtual std::shared_ptr<AudioBus> processAudio(std::shared_ptr<AudioBus> outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   virtual void processNode(const std::shared_ptr<AudioBus>&, int) = 0;
 
   bool isAlreadyProcessed();
-  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess);
+  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   std::shared_ptr<AudioBus> applyChannelCountMode(std::shared_ptr<AudioBus> processingBus);
   void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
 

package/common/cpp/core/BaseAudioContext.cpp

@@ -14,6 +14,7 @@
 #include "GainNode.h"
 #include "OscillatorNode.h"
 #include "StereoPannerNode.h"
+#include "StretcherNode.h"
 
 namespace audioapi {
 
@@ -96,6 +97,12 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   return analyser;
 }
 
+std::shared_ptr<StretcherNode> BaseAudioContext::createStretcher() {
+  auto node = std::make_shared<StretcherNode>(this);
+  nodeManager_->addNode(node);
+  return node;
+}
+
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
     const std::string &path) {
   auto audioBus = audioDecoder_->decodeWithFilePath(path);

package/common/cpp/core/BaseAudioContext.h

@@ -24,6 +24,7 @@ class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioDecoder;
 class AnalyserNode;
+class StretcherNode;
 
 class BaseAudioContext {
  public:
@@ -49,6 +50,7 @@ class BaseAudioContext {
       bool disableNormalization,
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
+  std::shared_ptr<StretcherNode> createStretcher();
 
   std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
 

package/common/cpp/core/StretcherNode.cpp

@@ -0,0 +1,96 @@
+#include <cassert>
+
+#include "AudioArray.h"
+#include "AudioBus.h"
+#include "BaseAudioContext.h"
+#include "StretcherNode.h"
+
+namespace audioapi {
+
+StretcherNode::StretcherNode(BaseAudioContext *context) : AudioNode(context) {
+  channelCountMode_ = ChannelCountMode::EXPLICIT;
+  rate_ = std::make_shared<AudioParam>(1.0, 0.0, 3.0);
+  semitones_ = std::make_shared<AudioParam>(0.0, -12.0, 12.0);
+
+  stretch_ =
+      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
+  stretch_->presetDefault(channelCount_, context->getSampleRate());
+  playbackRateBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+
+  isInitialized_ = true;
+}
+
+std::shared_ptr<AudioParam> StretcherNode::getRateParam() const {
+  return rate_;
+}
+
+std::shared_ptr<AudioParam> StretcherNode::getSemitonesParam() const {
+  return semitones_;
+}
+
+void StretcherNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  auto time = context_->getCurrentTime();
+  auto semitones = semitones_->getValueAtTime(time);
+
+  stretch_->setTransposeSemitones(semitones);
+  stretch_->process(
+      playbackRateBus_.get()[0],
+      framesNeededToStretch_,
+      audioBus_.get()[0],
+      framesToProcess);
+}
+
+std::shared_ptr<AudioBus> StretcherNode::processAudio(
+    std::shared_ptr<AudioBus> outputBus,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  if (!isInitialized_) {
+    return outputBus;
+  }
+
+  if (isAlreadyProcessed()) {
+    return audioBus_;
+  }
+
+  auto time = context_->getCurrentTime();
+
+  auto rate = rate_->getValueAtTime(time);
+  framesNeededToStretch_ =
+      static_cast<int>(rate * static_cast<float>(framesToProcess));
+
+  playbackRateBus_->zero();
+  auto writeIndex = 0;
+  auto framesNeededToStretch = framesNeededToStretch_;
+
+  // Collecting frames needed to stretch
+  while (framesNeededToStretch > 0) {
+    auto framesToCopy = std::min(framesNeededToStretch, framesToProcess);
+
+    // Process inputs and return the bus with the most channels. We must not
+    // check if the node has already been processed, cause we need to process it
+    // multiple times in this case.
+    auto processingBus = processInputs(outputBus, framesToCopy, false);
+
+    // Apply channel count mode.
+    processingBus = applyChannelCountMode(processingBus);
+
+    // Mix all input buses into the processing bus.
+    mixInputsBuses(processingBus);
+
+    assert(processingBus != nullptr);
+
+    playbackRateBus_->copy(processingBus.get(), 0, writeIndex, framesToCopy);
+
+    writeIndex += framesToCopy;
+    framesNeededToStretch -= framesToCopy;
+  }
+
+  processNode(audioBus_, framesToProcess);
+
+  return audioBus_;
+}
+
+} // namespace audioapi

package/common/cpp/core/StretcherNode.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "signalsmith-stretch.h"
+#include "TimeStretchType.h"
+#include "AudioNode.h"
+#include "AudioParam.h"
+
+namespace audioapi {
+class AudioBus;
+
+class StretcherNode : public AudioNode {
+ public:
+    explicit StretcherNode(BaseAudioContext *context);
+
+    [[nodiscard]] std::shared_ptr<AudioParam> getRateParam() const;
+    [[nodiscard]] std::shared_ptr<AudioParam> getSemitonesParam() const;
+
+ protected:
+    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+    std::shared_ptr<AudioBus> processAudio(std::shared_ptr<AudioBus> outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
+
+ private:
+    // k-rate params
+    std::shared_ptr<AudioParam> rate_;
+    std::shared_ptr<AudioParam> semitones_;
+
+    std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
+    std::shared_ptr<AudioBus> playbackRateBus_;
+    int framesNeededToStretch_ = RENDER_QUANTUM_SIZE;
+
+    static TimeStretchType fromString(const std::string &type) {
+        std::string lowerType = type;
+        std::transform(
+                lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+
+        if (lowerType == "linear")
+            return TimeStretchType::LINEAR;
+        if (lowerType == "speech")
+            return TimeStretchType::SPEECH;
+        if (lowerType == "music")
+            return TimeStretchType::MUSIC;
+
+        throw std::invalid_argument("Unknown time stretch type: " + type);
+    }
+
+    static std::string toString(TimeStretchType type) {
+        switch (type) {
+            case TimeStretchType::LINEAR:
+                return "linear";
+            case TimeStretchType::SPEECH:
+                return "speech";
+            case TimeStretchType::MUSIC:
+                return "music";
+            default:
+                throw std::invalid_argument("Unknown time stretch type");
+        }
+    }
+};
+
+} // namespace audioapi

package/common/cpp/installer/AudioAPIModuleInstaller.h

@@ -9,14 +9,14 @@ namespace audioapi {
 using namespace facebook;
 
 class AudioAPIModuleInstaller {
-public:
+ public:
   static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
     auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker);
     jsiRuntime->global().setProperty(
         *jsiRuntime, "createAudioContext", createAudioContext);
   }
 
-private:
+ private:
   static jsi::Function getCreateAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
@@ -34,8 +34,8 @@ private:
             auto sampleRate = static_cast<float>(args[0].getNumber());
             audioContext = std::make_shared<AudioContext>(sampleRate);
           }
-              
-              auto promiseVendor = std::make_shared<PromiseVendor>(jsiRuntime, jsCallInvoker);
+
+          auto promiseVendor = std::make_shared<PromiseVendor>(jsiRuntime, jsCallInvoker);
 
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, promiseVendor);

package/common/cpp/libs/dsp/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Geraint Luff / Signalsmith Audio Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/common/cpp/libs/dsp/README.md

@@ -0,0 +1,40 @@
+# Signalsmith Audio's DSP Library
+
+A C++11 header-only library, providing classes/templates for (mostly audio) signal-processing tasks.
+
+More detail is in the [main project page](https://signalsmith-audio.co.uk/code/dsp/), and the [Doxygen docs](https://signalsmith-audio.co.uk/code/dsp/html/modules.html).
+
+## Basic use
+
+```
+git clone https://signalsmith-audio.co.uk/code/dsp.git
+```
+
+Just include the header file(s) you need, and start using classes:
+
+```cpp
+#include "dsp/delay.h"
+
+using Delay = signalsmith::delay::Delay<float>;
+Delay delayLine(1024);
+```
+
+You can add a compile-time version-check to make sure you have a compatible version of the library:
+```cpp
+#include "dsp/envelopes.h"
+SIGNALSMITH_DSP_VERSION_CHECK(1, 6, 1)
+```
+
+### Development / contributing
+
+Tests (and source-scripts for the above docs) are available in a separate repo:
+
+```
+git clone https://signalsmith-audio.co.uk/code/dsp-doc.git
+```
+
+The goal (where possible) is to measure/test the actual audio characteristics of the tools (e.g. frequency responses and aliasing levels).
+
+### License
+
+This code is [MIT licensed](LICENSE.txt).  If you'd prefer something else, get in touch.

package/common/cpp/libs/dsp/common.h

@@ -0,0 +1,47 @@
+#ifndef SIGNALSMITH_DSP_COMMON_H
+#define SIGNALSMITH_DSP_COMMON_H
+
+#if defined(__FAST_MATH__) && (__apple_build_version__ >= 16000000) && (__apple_build_version__ <= 16000099)
+#	error Apple Clang 16.0.0 generates incorrect SIMD for ARM. If you HAVE to use this version of Clang, turn off -ffast-math.
+#endif
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338327950288
+#endif
+
+namespace signalsmith {
+	/**	@defgroup Common Common
+		@brief Definitions and helper classes used by the rest of the library
+		
+		@{
+		@file
+	*/
+
+#define SIGNALSMITH_DSP_VERSION_MAJOR 1
+#define SIGNALSMITH_DSP_VERSION_MINOR 6
+#define SIGNALSMITH_DSP_VERSION_PATCH 1
+#define SIGNALSMITH_DSP_VERSION_STRING "1.6.1"
+
+	/** Version compatability check.
+	\code{.cpp}
+		static_assert(signalsmith::version(1, 4, 1), "version check");
+	\endcode
+	... or use the equivalent `SIGNALSMITH_DSP_VERSION_CHECK`.
+	Major versions are not compatible with each other.  Minor and patch versions are backwards-compatible.
+	*/
+	constexpr bool versionCheck(int major, int minor, int patch=0) {
+		return major == SIGNALSMITH_DSP_VERSION_MAJOR
+			&& (SIGNALSMITH_DSP_VERSION_MINOR > minor
+				|| (SIGNALSMITH_DSP_VERSION_MINOR == minor && SIGNALSMITH_DSP_VERSION_PATCH >= patch));
+	}
+
+/// Check the library version is compatible (semver).
+#define SIGNALSMITH_DSP_VERSION_CHECK(major, minor, patch) \
+	static_assert(::signalsmith::versionCheck(major, minor, patch), "signalsmith library version is " SIGNALSMITH_DSP_VERSION_STRING);
+
+/** @} */
+} // signalsmith::
+#else
+// If we've already included it, check it's the same version
+static_assert(SIGNALSMITH_DSP_VERSION_MAJOR == 1 && SIGNALSMITH_DSP_VERSION_MINOR == 6 && SIGNALSMITH_DSP_VERSION_PATCH == 1, "multiple versions of the Signalsmith DSP library");
+#endif // include guard