react-native-audio-api 0.3.0-rc2 → 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

@@ -1,24 +1,37 @@
 #include "AudioScheduledSourceNode.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
 #include "AudioNodeManager.h"
+#include "AudioUtils.h"
 #include "BaseAudioContext.h"
 
 namespace audioapi {
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
-    : AudioNode(context), playbackState_(PlaybackState::UNSCHEDULED) {
+    : AudioNode(context),
+      playbackState_(PlaybackState::UNSCHEDULED),
+      startTime_(-1.0),
+      stopTime_(-1.0) {
   numberOfInputs_ = 0;
-  isInitialized_ = true;
 }
 
 void AudioScheduledSourceNode::start(double time) {
-  context_->getNodeManager()->addSourceNode(shared_from_this());
-
   playbackState_ = PlaybackState::SCHEDULED;
-  waitAndExecute(time, [this](double time) { startPlayback(); });
+  startTime_ = time;
+
+  context_->getNodeManager()->addSourceNode(shared_from_this());
 }
 
 void AudioScheduledSourceNode::stop(double time) {
-  waitAndExecute(time, [this](double time) { stopPlayback(); });
+  stopTime_ = time;
+}
+
+bool AudioScheduledSourceNode::isUnscheduled() {
+  return playbackState_ == PlaybackState::UNSCHEDULED;
+}
+
+bool AudioScheduledSourceNode::isScheduled() {
+  return playbackState_ == PlaybackState::SCHEDULED;
 }
 
 bool AudioScheduledSourceNode::isPlaying() {
@@ -29,25 +42,85 @@ bool AudioScheduledSourceNode::isFinished() {
   return playbackState_ == PlaybackState::FINISHED;
 }
 
-void AudioScheduledSourceNode::startPlayback() {
-  playbackState_ = PlaybackState::PLAYING;
-}
+void AudioScheduledSourceNode::updatePlaybackInfo(
+    AudioBus *processingBus,
+    int framesToProcess,
+    size_t &startOffset,
+    size_t &nonSilentFramesToProcess) {
+  if (!isInitialized_) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+    return;
+  }
 
-void AudioScheduledSourceNode::stopPlayback() {
-  playbackState_ = PlaybackState::FINISHED;
-  disable();
-}
+  int sampleRate = context_->getSampleRate();
 
-void AudioScheduledSourceNode::waitAndExecute(
-    double time,
-    const std::function<void(double)> &fun) {
-  std::thread([this, time, fun]() {
-    while (context_->getCurrentTime() < time) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  size_t firstFrame = context_->getCurrentSampleFrame();
+  size_t lastFrame = firstFrame + framesToProcess;
+
+  size_t startFrame = std::max(
+      AudioUtils::timeToSampleFrame(startTime_, sampleRate), firstFrame);
+  size_t stopFrame = stopTime_ == -1.0
+      ? std::numeric_limits<size_t>::max()
+      : std::max(
+            AudioUtils::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
+
+  if (isUnscheduled() || isFinished()) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+    return;
+  }
+
+  if (isScheduled()) {
+    // not yet playing
+    if (startFrame > lastFrame) {
+      startOffset = 0;
+      nonSilentFramesToProcess = 0;
+      return;
     }
 
-    fun(time);
-  }).detach();
+    // start playing
+    // zero first frames before starting frame
+    playbackState_ = PlaybackState::PLAYING;
+    startOffset = std::max(startFrame, firstFrame) - firstFrame > 0
+        ? std::max(startFrame, firstFrame) - firstFrame
+        : 0;
+    nonSilentFramesToProcess =
+        std::min(lastFrame, stopFrame) - startFrame;
+    processingBus->zero(0, startOffset);
+    return;
+  }
+
+  // the node is playing
+
+  // stop will happen in this render quantum
+  // zero remaining frames after stop frame
+  if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+    startOffset = 0;
+    nonSilentFramesToProcess = stopFrame - firstFrame;
+    processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
+    return;
+  }
+
+  // mark as finished in first silent render quantum
+  if (stopFrame < firstFrame) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+    playbackState_ = PlaybackState::FINISHED;
+    disable();
+    return;
+  }
+
+  // normal "mid-buffer" playback
+  startOffset = 0;
+  nonSilentFramesToProcess = framesToProcess;
+}
+
+void AudioScheduledSourceNode::handleStopScheduled() {
+  if (isPlaying() && stopTime_ > 0 && context_->getCurrentTime() >= stopTime_) {
+    playbackState_ = PlaybackState::FINISHED;
+    disable();
+  }
 }
 
 } // namespace audioapi

package/common/cpp/core/AudioScheduledSourceNode.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <functional>
 #include <iostream>
+#include <limits>
 #include <memory>
 #include <thread>
 
@@ -19,16 +21,25 @@ class AudioScheduledSourceNode : public AudioNode {
   void start(double time);
   void stop(double time);
 
-  bool isFinished();
+  bool isUnscheduled();
+  bool isScheduled();
   bool isPlaying();
+  bool isFinished();
 
  protected:
-  std::atomic<PlaybackState> playbackState_;
+  PlaybackState playbackState_;
+
+  void updatePlaybackInfo(
+      AudioBus *processingBus,
+      int framesToProcess,
+      size_t &startOffset,
+      size_t &nonSilentFramesToProcess);
+
+  void handleStopScheduled();
 
  private:
-  void startPlayback();
-  void stopPlayback();
-  void waitAndExecute(double time, const std::function<void(double)> &fun);
+  double startTime_;
+  double stopTime_;
 };
 
 } // namespace audioapi

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;
 }