react-native-audio-api 0.3.1 → 0.3.2

package/common/cpp/core/AudioParam.cpp

@@ -1,23 +1,19 @@
 #include "AudioParam.h"
+
+#include "AudioUtils.h"
 #include "BaseAudioContext.h"
 
 namespace audioapi {
 
-AudioParam::AudioParam(
-    BaseAudioContext *context,
-    float defaultValue,
-    float minValue,
-    float maxValue)
+AudioParam::AudioParam(float defaultValue, float minValue, float maxValue)
     : value_(defaultValue),
       defaultValue_(defaultValue),
       minValue_(minValue),
-      maxValue_(maxValue),
-      context_(context),
-      changesQueue_() {
+      maxValue_(maxValue) {
   startTime_ = 0;
   endTime_ = 0;
-  startValue_ = 0;
-  endValue_ = 0;
+  startValue_ = value_;
+  endValue_ = value_;
   calculateValue_ = [this](double, double, float, float, double) {
     return value_;
   };
@@ -40,94 +36,258 @@ float AudioParam::getMaxValue() const {
 }
 
 void AudioParam::setValue(float value) {
-  value_ = checkValue(value);
+  value_ = std::clamp(value, minValue_, maxValue_);
 }
 
 float AudioParam::getValueAtTime(double time) {
-  if (!changesQueue_.empty()) {
-    if (endTime_ < time) {
-      auto change = *changesQueue_.begin();
-      startTime_ = change.getStartTime();
-      endTime_ = change.getEndTime();
-      startValue_ = change.getStartValue();
-      endValue_ = change.getEndValue();
-      calculateValue_ = change.getCalculateValue();
-      changesQueue_.erase(changesQueue_.begin());
-    }
+  if (endTime_ < time && !eventsQueue_.empty()) {
+    auto event = eventsQueue_.front();
+    startTime_ = event.getStartTime();
+    endTime_ = event.getEndTime();
+    startValue_ = event.getStartValue();
+    endValue_ = event.getEndValue();
+    calculateValue_ = event.getCalculateValue();
+    eventsQueue_.pop_front();
   }
 
-  if (startTime_ <= time) {
-    value_ =
-        calculateValue_(startTime_, endTime_, startValue_, endValue_, time);
-  }
+  setValue(calculateValue_(startTime_, endTime_, startValue_, endValue_, time));
 
   return value_;
 }
 
-void AudioParam::setValueAtTime(float value, double time) {
-  value = checkValue(value);
-  auto calculateValue = [](double, double, float, float endValue, double) {
+void AudioParam::setValueAtTime(float value, double startTime) {
+  if (startTime <= getQueueEndTime()) {
+    return;
+  }
+
+  auto calculateValue = [](double startTime,
+                           double,
+                           float startValue,
+                           float endValue,
+                           double time) {
+    if (time < startTime) {
+      return startValue;
+    }
+
     return endValue;
   };
 
-  auto paramChange = ParamChange(time, time, value, value, calculateValue);
-  changesQueue_.insert(paramChange);
+  auto event = ParamChangeEvent(
+      startTime,
+      startTime,
+      getQueueEndValue(),
+      value,
+      calculateValue,
+      ParamChangeEventType::SET_VALUE);
+  updateQueue(event);
 }
 
-void AudioParam::linearRampToValueAtTime(float value, double time) {
-  value = checkValue(value);
+void AudioParam::linearRampToValueAtTime(float value, double endTime) {
+  if (endTime <= getQueueEndTime()) {
+    return;
+  }
+
   auto calculateValue = [](double startTime,
                            double endTime,
                            float startValue,
                            float endValue,
                            double time) {
-    return time >= endTime ? endValue
-                           : startValue +
-            (endValue - startValue) * (time - startTime) /
-                (endTime - startTime);
+    if (time < startTime) {
+      return startValue;
+    }
+
+    if (time < endTime) {
+      return static_cast<float>(
+          startValue +
+          (endValue - startValue) * (time - startTime) / (endTime - startTime));
+    }
+
+    return endValue;
   };
 
-  auto paramChange =
-      ParamChange(getStartTime(), time, getStartValue(), value, calculateValue);
-  changesQueue_.emplace(paramChange);
+  auto event = ParamChangeEvent(
+      getQueueEndTime(),
+      endTime,
+      getQueueEndValue(),
+      value,
+      calculateValue,
+      ParamChangeEventType::LINEAR_RAMP);
+  updateQueue(event);
 }
 
-void AudioParam::exponentialRampToValueAtTime(float value, double time) {
-  value = checkValue(value);
+void AudioParam::exponentialRampToValueAtTime(float value, double endTime) {
+  if (endTime <= getQueueEndTime()) {
+    return;
+  }
+
   auto calculateValue = [](double startTime,
                            double endTime,
                            float startValue,
                            float endValue,
                            double time) {
-    return time >= endTime ? endValue
-                           : startValue *
-            pow(endValue / startValue,
-                (time - startTime) / (endTime - startTime));
+    if (time < startTime) {
+      return startValue;
+    }
+
+    if (time < endTime) {
+      return static_cast<float>(
+          startValue *
+          pow(endValue / startValue,
+              (time - startTime) / (endTime - startTime)));
+    }
+
+    return endValue;
   };
 
-  auto paramChange =
-      ParamChange(getStartTime(), time, getStartValue(), value, calculateValue);
-  changesQueue_.emplace(paramChange);
+  auto event = ParamChangeEvent(
+      getQueueEndTime(),
+      endTime,
+      getQueueEndValue(),
+      value,
+      calculateValue,
+      ParamChangeEventType::EXPONENTIAL_RAMP);
+  updateQueue(event);
 }
 
-float AudioParam::checkValue(float value) const {
-  return std::clamp(value, minValue_, maxValue_);
+void AudioParam::setTargetAtTime(
+    float target,
+    double startTime,
+    double timeConstant) {
+  if (startTime <= getQueueEndTime()) {
+    return;
+  }
+
+  auto calculateValue =
+      [timeConstant, target](
+          double startTime, double, float startValue, float, double time) {
+        if (time < startTime) {
+          return startValue;
+        }
+
+        return static_cast<float>(
+            target +
+            (startValue - target) * exp(-(time - startTime) / timeConstant));
+      };
+
+  auto event = ParamChangeEvent(
+      startTime,
+      startTime,
+      getQueueEndValue(),
+      getQueueEndValue(),
+      calculateValue,
+      ParamChangeEventType::SET_TARGET);
+  updateQueue(event);
 }
 
-double AudioParam::getStartTime() {
-  if (changesQueue_.empty()) {
-    return context_->getCurrentTime();
+void AudioParam::setValueCurveAtTime(
+    const float *values,
+    int length,
+    double startTime,
+    double duration) {
+  if (startTime <= getQueueEndTime()) {
+    return;
   }
 
-  return changesQueue_.rbegin()->getEndTime();
+  auto calculateValue = [&values, length](
+                            double startTime,
+                            double endTime,
+                            float startValue,
+                            float endValue,
+                            double time) {
+    if (time < startTime) {
+      return startValue;
+    }
+
+    if (time < endTime) {
+      auto k = static_cast<int>(std::floor(
+          (length - 1) / (endTime - startTime) * (time - startTime)));
+      auto factor = static_cast<float>(
+          k - (time - startTime) * (length - 1) / (endTime - startTime));
+
+      return AudioUtils::linearInterpolate(values, k, k + 1, factor);
+    }
+
+    return endValue;
+  };
+
+  auto event = ParamChangeEvent(
+      startTime,
+      startTime + duration,
+      getQueueEndValue(),
+      values[length - 1],
+      calculateValue,
+      ParamChangeEventType::SET_VALUE_CURVE);
+  updateQueue(event);
+}
+
+void AudioParam::cancelScheduledValues(double cancelTime) {
+  auto it = eventsQueue_.rbegin();
+  while (it->getEndTime() >= cancelTime) {
+    if (it->getStartTime() >= cancelTime ||
+        it->getType() == ParamChangeEventType::SET_VALUE_CURVE) {
+      eventsQueue_.pop_back();
+    }
+
+    it++;
+  }
 }
 
-float AudioParam::getStartValue() {
-  if (changesQueue_.empty()) {
-    return this->value_;
+void AudioParam::cancelAndHoldAtTime(double cancelTime) {
+  auto it = eventsQueue_.rbegin();
+  while (it->getEndTime() >= cancelTime) {
+    if (it->getStartTime() >= cancelTime) {
+      eventsQueue_.pop_back();
+    }
+
+    it++;
+  }
+
+  if (eventsQueue_.empty()) {
+    endTime_ = cancelTime;
+  }
+
+  if (!eventsQueue_.empty()) {
+    auto lastEvent = eventsQueue_.rbegin();
+    if (lastEvent->getEndTime() > cancelTime) {
+      lastEvent->setEndTime(cancelTime);
+    }
+  }
+}
+
+double AudioParam::getQueueEndTime() {
+  if (eventsQueue_.empty()) {
+    return endTime_;
+  }
+
+  return eventsQueue_.back().getEndTime();
+}
+
+float AudioParam::getQueueEndValue() {
+  if (eventsQueue_.empty()) {
+    return this->endValue_;
+  }
+
+  return eventsQueue_.back().getEndValue();
+}
+
+void AudioParam::updateQueue(ParamChangeEvent &event) {
+  if (!eventsQueue_.empty()) {
+    auto prev = eventsQueue_.back();
+
+    if (prev.getType() == ParamChangeEventType::SET_TARGET) {
+      prev.setEndTime(event.getStartTime());
+      prev.setEndValue(prev.getCalculateValue()(
+          prev.getStartTime(),
+          prev.getEndTime(),
+          prev.getStartValue(),
+          prev.getEndValue(),
+          event.getStartTime()));
+    }
+
+    event.setStartValue(prev.getEndValue());
   }
 
-  return changesQueue_.rbegin()->getEndValue();
+  eventsQueue_.push_back(event);
 }
 
 } // namespace audioapi

package/common/cpp/core/AudioParam.h

@@ -1,40 +1,44 @@
 #pragma once
 
+#include <deque>
 #include <memory>
-#include <set>
 #include <vector>
 
-#include "ParamChange.h"
+#include "ParamChangeEvent.h"
+#include "ParamChangeEventType.h"
 
 namespace audioapi {
 
-class BaseAudioContext;
-
 class AudioParam {
  public:
-  explicit AudioParam(
-      BaseAudioContext *context,
-      float defaultValue,
-      float minValue,
-      float maxValue);
+  explicit AudioParam(float defaultValue, float minValue, float maxValue);
 
   [[nodiscard]] float getValue() const;
   float getValueAtTime(double time);
-  void setValue(float value);
   [[nodiscard]] float getDefaultValue() const;
   [[nodiscard]] float getMinValue() const;
   [[nodiscard]] float getMaxValue() const;
+
+  void setValue(float value);
+
   void setValueAtTime(float value, double startTime);
   void linearRampToValueAtTime(float value, double endTime);
   void exponentialRampToValueAtTime(float value, double endTime);
+  void setTargetAtTime(float target, double startTime, double timeConstant);
+  void setValueCurveAtTime(
+      const float *values,
+      int length,
+      double startTime,
+      double duration);
+  void cancelScheduledValues(double cancelTime);
+  void cancelAndHoldAtTime(double cancelTime);
 
  private:
   float value_;
   float defaultValue_;
   float minValue_;
   float maxValue_;
-  BaseAudioContext *context_;
-  std::set<ParamChange> changesQueue_;
+  std::deque<ParamChangeEvent> eventsQueue_;
 
   double startTime_;
   double endTime_;
@@ -42,9 +46,9 @@ class AudioParam {
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
 
-  float checkValue(float value) const;
-  double getStartTime();
-  float getStartValue();
+  double getQueueEndTime();
+  float getQueueEndValue();
+  void updateQueue(ParamChangeEvent &event);
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -86,7 +86,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
     nonSilentFramesToProcess =
-        std::min(lastFrame, stopFrame) - startFrame - startOffset;
+        std::min(lastFrame, stopFrame) - startFrame;
     processingBus->zero(0, startOffset);
     return;
   }
@@ -107,6 +107,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     startOffset = 0;
     nonSilentFramesToProcess = 0;
     playbackState_ = PlaybackState::FINISHED;
+    disable();
     return;
   }
 
@@ -115,4 +116,11 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   nonSilentFramesToProcess = framesToProcess;
 }
 
+void AudioScheduledSourceNode::handleStopScheduled() {
+  if (isPlaying() && stopTime_ > 0 && context_->getCurrentTime() >= stopTime_) {
+    playbackState_ = PlaybackState::FINISHED;
+    disable();
+  }
+}
+
 } // namespace audioapi

package/common/cpp/core/AudioScheduledSourceNode.h

@@ -27,13 +27,16 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
 
  protected:
-  std::atomic<PlaybackState> playbackState_;
+  PlaybackState playbackState_;
+
   void updatePlaybackInfo(
       AudioBus *processingBus,
       int framesToProcess,
       size_t &startOffset,
       size_t &nonSilentFramesToProcess);
 
+  void handleStopScheduled();
+
  private:
   double startTime_;
   double stopTime_;

package/common/cpp/core/BaseAudioContext.cpp

@@ -1,8 +1,6 @@
 #ifdef ANDROID
-#include "AudioDecoder.h"
 #include "AudioPlayer.h"
 #else
-#include "IOSAudioDecoder.h"
 #include "IOSAudioPlayer.h"
 #endif
 
@@ -12,6 +10,7 @@
 #include "AudioBuffer.h"
 #include "AudioBufferSourceNode.h"
 #include "AudioBus.h"
+#include "AudioDecoder.h"
 #include "AudioDestinationNode.h"
 #include "AudioNodeManager.h"
 #include "BiquadFilterNode.h"
@@ -25,13 +24,12 @@ namespace audioapi {
 BaseAudioContext::BaseAudioContext() {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
-  audioDecoder_ = std::make_shared<AudioDecoder>(audioPlayer_->getSampleRate());
 #else
   audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
-  audioDecoder_ =
-      std::make_shared<IOSAudioDecoder>(audioPlayer_->getSampleRate());
 #endif
 
+  audioDecoder_ = std::make_shared<AudioDecoder>(audioPlayer_->getSampleRate());
+
   sampleRate_ = audioPlayer_->getSampleRate();
   bufferSizeInFrames_ = audioPlayer_->getBufferSizeInFrames();
 
@@ -108,19 +106,11 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
       sampleRate_, real, imag, length, disableNormalization);
 }
 
-#ifdef ANDROID
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
     const std::string &path) {
   auto audioBus = audioDecoder_->decodeWithFilePath(path);
   return std::make_shared<AudioBuffer>(audioBus);
 }
-#else
-std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
-    const std::string &path) {
-  auto audioBus = audioDecoder_->decodeWithFilePath(path);
-  return std::make_shared<AudioBuffer>(audioBus);
-}
-#endif
 
 std::function<void(AudioBus *, int)> BaseAudioContext::renderAudio() {
   if (!isRunning()) {

package/common/cpp/core/BaseAudioContext.h

@@ -21,13 +21,12 @@ class AudioNodeManager;
 class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
+class AudioDecoder;
 
 #ifdef ANDROID
 class AudioPlayer;
-class AudioDecoder;
 #else
 class IOSAudioPlayer;
-class IOSAudioDecoder;
 #endif
 
 class BaseAudioContext {
@@ -65,13 +64,12 @@ class BaseAudioContext {
  protected:
   static std::string toString(ContextState state);
   std::shared_ptr<AudioDestinationNode> destination_;
+  std::shared_ptr<AudioDecoder> audioDecoder_;
 
 #ifdef ANDROID
   std::shared_ptr<AudioPlayer> audioPlayer_;
-  std::shared_ptr<AudioDecoder> audioDecoder_;
 #else
   std::shared_ptr<IOSAudioPlayer> audioPlayer_;
-  std::shared_ptr<IOSAudioDecoder> audioDecoder_;
 #endif
 
   int sampleRate_;

package/common/cpp/core/BiquadFilterNode.cpp

@@ -11,13 +11,11 @@ namespace audioapi {
 BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
     : AudioNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      context, 350.0, MIN_FILTER_FREQUENCY, MAX_FILTER_FREQUENCY);
-  detuneParam_ =
-      std::make_shared<AudioParam>(context, 0.0, -MAX_DETUNE, MAX_DETUNE);
-  QParam_ =
-      std::make_shared<AudioParam>(context, 1.0, -MAX_FILTER_Q, MAX_FILTER_Q);
-  gainParam_ = std::make_shared<AudioParam>(
-      context, 0.0, MIN_FILTER_GAIN, MAX_FILTER_GAIN);
+      350.0, MIN_FILTER_FREQUENCY, MAX_FILTER_FREQUENCY);
+  detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
+  QParam_ = std::make_shared<AudioParam>(1.0, -MAX_FILTER_Q, MAX_FILTER_Q);
+  gainParam_ =
+      std::make_shared<AudioParam>(0.0, MIN_FILTER_GAIN, MAX_FILTER_GAIN);
   type_ = BiquadFilterType::LOWPASS;
   isInitialized_ = true;
 }

package/common/cpp/{HostObjects → core}/Constants.h

@@ -8,10 +8,8 @@
 namespace audioapi {
 constexpr int SAMPLE_RATE = 44100;
 constexpr int CHANNEL_COUNT = 2;
-constexpr float MOST_POSITIVE_SINGLE_FLOAT =
-    static_cast<float>(std::numeric_limits<float>::max());
-constexpr float MOST_NEGATIVE_SINGLE_FLOAT =
-    static_cast<float>(std::numeric_limits<float>::lowest());
+constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
+constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
 constexpr float NYQUIST_FREQUENCY = SAMPLE_RATE / 2.0;
 static float MAX_DETUNE = 1200 * std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 constexpr float MAX_GAIN = MOST_POSITIVE_SINGLE_FLOAT;

package/common/cpp/core/GainNode.cpp

@@ -6,7 +6,7 @@
 namespace audioapi {
 
 GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
-  gainParam_ = std::make_shared<AudioParam>(context, 1.0, -MAX_GAIN, MAX_GAIN);
+  gainParam_ = std::make_shared<AudioParam>(1.0, -MAX_GAIN, MAX_GAIN);
   isInitialized_ = true;
 }
 

package/common/cpp/core/OscillatorNode.cpp

@@ -8,9 +8,8 @@ namespace audioapi {
 OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      context, 444.0, -NYQUIST_FREQUENCY, NYQUIST_FREQUENCY);
-  detuneParam_ =
-      std::make_shared<AudioParam>(context, 0.0, -MAX_DETUNE, MAX_DETUNE);
+      444.0, -NYQUIST_FREQUENCY, NYQUIST_FREQUENCY);
+  detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
   isInitialized_ = true;
@@ -75,6 +74,8 @@ void OscillatorNode::processNode(AudioBus *processingBus, int framesToProcess) {
 
     time += deltaTime;
   }
+
+  handleStopScheduled();
 }
 
 } // namespace audioapi

package/common/cpp/core/ParamChangeEvent.cpp

@@ -0,0 +1,58 @@
+#include "ParamChangeEvent.h"
+
+#include <utility>
+
+namespace audioapi {
+
+ParamChangeEvent::ParamChangeEvent(
+    double startTime,
+    double endTime,
+    float startValue,
+    float endValue,
+    std::function<float(double, double, float, float, double)> calculateValue,
+    ParamChangeEventType type)
+    : startTime_(startTime),
+      endTime_(endTime),
+      startValue_(startValue),
+      endValue_(endValue),
+      calculateValue_(std::move(calculateValue)),
+      type_(type) {}
+
+double ParamChangeEvent::getEndTime() const {
+  return endTime_;
+}
+
+double ParamChangeEvent::getStartTime() const {
+  return startTime_;
+}
+
+float ParamChangeEvent::getEndValue() const {
+  return endValue_;
+}
+
+float ParamChangeEvent::getStartValue() const {
+  return startValue_;
+}
+
+std::function<float(double, double, float, float, double)>
+ParamChangeEvent::getCalculateValue() const {
+  return calculateValue_;
+}
+
+ParamChangeEventType ParamChangeEvent::getType() const {
+  return type_;
+}
+
+void ParamChangeEvent::setEndTime(double endTime) {
+  endTime_ = endTime;
+}
+
+void ParamChangeEvent::setStartValue(float startValue) {
+  startValue_ = startValue;
+}
+
+void ParamChangeEvent::setEndValue(float endValue) {
+  endValue_ = endValue;
+}
+
+} // namespace audioapi