react-native-audio-api 0.4.12 → 0.4.14

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -2,10 +2,10 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -14,18 +14,15 @@ AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
       loop_(false),
       loopStart_(0),
       loopEnd_(0),
-      timeStretchType_(TimeStretchType::LINEAR),
       vReadIndex_(0.0) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+  alignedBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
-  detuneParam_ = std::make_shared<AudioParam>(
-      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+  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);
 
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
-
   isInitialized_ = true;
 }
 
@@ -54,10 +51,6 @@ std::shared_ptr<AudioBuffer> AudioBufferSourceNode::getBuffer() const {
   return buffer_;
 }
 
-std::string AudioBufferSourceNode::getTimeStretchType() const {
-  return toString(timeStretchType_);
-}
-
 void AudioBufferSourceNode::setLoop(bool loop) {
   loop_ = loop;
 }
@@ -76,6 +69,8 @@ void AudioBufferSourceNode::setBuffer(
 
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+    alignedBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
     loopEnd_ = 0;
     return;
   }
@@ -83,18 +78,17 @@ void AudioBufferSourceNode::setBuffer(
   buffer_ = buffer;
   channelCount_ = buffer_->getNumberOfChannels();
 
+  alignedBus_ = std::make_shared<AudioBus>(
+      buffer_->getLength(), channelCount_, context_->getSampleRate());
+  alignedBus_->zero();
+  alignedBus_->sum(buffer_->bus_.get());
+
   audioBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
 
   loopEnd_ = buffer_->getDuration();
 }
 
-void AudioBufferSourceNode::setTimeStretchType(const std::string &type) {
-  timeStretchType_ = fromString(type);
-}
-
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
   AudioScheduledSourceNode::start(when);
 
@@ -123,7 +117,7 @@ void AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   // No audio data to fill, zero the output and return.
-  if (!buffer_ || !buffer_->bus_) {
+  if (!buffer_) {
     processingBus->zero();
     return;
   }
@@ -136,58 +130,26 @@ void AudioBufferSourceNode::processNode(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  if (timeStretchType_ == TimeStretchType::LINEAR) {
-    auto computedPlaybackRate = getComputedPlaybackRateValue();
-    updatePlaybackInfo(
-        processingBus, framesToProcess, startOffset, offsetLength);
-
-    if (computedPlaybackRate == 0.0f || !isPlaying()) {
-      processingBus->zero();
-      return;
-    } else if (std::fabs(computedPlaybackRate) == 1.0) {
-      processWithoutInterpolation(
-          processingBus, startOffset, offsetLength, computedPlaybackRate);
-    } else {
-      processWithInterpolation(
-          processingBus, startOffset, offsetLength, computedPlaybackRate);
-    }
-  } else {
-    auto time = context_->getCurrentTime();
-    auto playbackRate =
-        std::clamp(playbackRateParam_->getValueAtTime(time), 0.0f, 3.0f);
-    auto detune =
-        std::clamp(detuneParam_->getValueAtTime(time) / 100.0f, -12.0f, 12.0f);
-
-    playbackRateBus_->zero();
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+  float playbackRate = getPlaybackRateValue(startOffset);
 
-    auto framesNeededToStretch =
-        static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
-
-    updatePlaybackInfo(
-        playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
+  assert(alignedBus_ != nullptr);
+  assert(alignedBus_->getSize() > 0);
 
+  if (playbackRate == 0.0f || !isPlaying()) {
+    processingBus->zero();
+    return;
+  } else if (std::fabs(playbackRate) == 1.0) {
     processWithoutInterpolation(
-        playbackRateBus_, startOffset, offsetLength, playbackRate);
-
-    auto stretch = buffer_->stretch_;
-
-    stretch->process(
-        playbackRateBus_.get()[0],
-        framesNeededToStretch,
-        processingBus.get()[0],
-        framesToProcess);
-
-    stretch->setTransposeSemitones(detune);
+        processingBus, startOffset, offsetLength, playbackRate);
+  } else {
+    processWithInterpolation(
+        processingBus, startOffset, offsetLength, playbackRate);
   }
 
   handleStopScheduled();
 }
 
-double AudioBufferSourceNode::getStopTime() const {
-  return dsp::sampleFrameToTime(
-      static_cast<int>(vReadIndex_), buffer_->getSampleRate());
-}
-
 /**
  * Helper functions
  */
@@ -220,12 +182,12 @@ void AudioBufferSourceNode::processWithoutInterpolation(
     // Direction is forward, we can normally copy the data
     if (direction == 1) {
       processingBus->copy(
-          buffer_->bus_.get(), readIndex, writeIndex, framesToCopy);
+          alignedBus_.get(), readIndex, writeIndex, framesToCopy);
     } else {
       for (int i = 0; i < framesToCopy; i += 1) {
         for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
           (*processingBus->getChannel(j))[writeIndex + i] =
-              (*buffer_->bus_->getChannel(j))[readIndex - i];
+              (*alignedBus_->getChannel(j))[readIndex - i];
         }
       }
     }
@@ -286,10 +248,10 @@ void AudioBufferSourceNode::processWithInterpolation(
 
     for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
       float *destination = processingBus->getChannel(i)->getData();
-      const float *source = buffer_->bus_->getChannel(i)->getData();
+      const float *source = alignedBus_->getChannel(i)->getData();
 
-      destination[writeIndex] =
-          dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
+      destination[writeIndex] = AudioUtils::linearInterpolate(
+          source, readIndex, nextReadIndex, factor);
     }
 
     writeIndex += 1;
@@ -309,12 +271,13 @@ void AudioBufferSourceNode::processWithInterpolation(
   }
 }
 
-float AudioBufferSourceNode::getComputedPlaybackRateValue() {
-  auto time = context_->getCurrentTime();
+float AudioBufferSourceNode::getPlaybackRateValue(size_t &startOffset) {
+  auto time = context_->getCurrentTime() +
+      static_cast<double>(startOffset) / context_->getSampleRate();
 
   auto sampleRateFactor = buffer_->getSampleRate() / context_->getSampleRate();
-  auto playbackRate = playbackRateParam_->getValueAtTime(time);
   auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+  auto playbackRate = playbackRateParam_->getValueAtTime(time);
 
   return playbackRate * sampleRateFactor * detune;
 }
@@ -327,7 +290,7 @@ double AudioBufferSourceNode::getVirtualStartFrame() {
 }
 
 double AudioBufferSourceNode::getVirtualEndFrame() {
-  auto inputBufferLength = static_cast<double>(buffer_->bus_->getSize());
+  auto inputBufferLength = static_cast<double>(alignedBus_->getSize());
   auto loopEndFrame = loopEnd_ * context_->getSampleRate();
 
   return loop_ && loopEndFrame > 0 && loopStart_ < loopEnd_

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h

@@ -2,12 +2,11 @@
 
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
-#include <audioapi/core/types/TimeStretchType.h>
 
 #include <memory>
 #include <cstddef>
 #include <algorithm>
-#include <string>
+#include <cassert>
 
 namespace audioapi {
 
@@ -23,68 +22,41 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] double getLoopEnd() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
-  [[nodiscard]] std::shared_ptr<AudioParam> getSemitonesParam() const;
   [[nodiscard]] std::shared_ptr<AudioBuffer> getBuffer() const;
-  [[nodiscard]] std::string getTimeStretchType() const;
 
   void setLoop(bool loop);
   void setLoopStart(double loopStart);
   void setLoopEnd(double loopEnd);
   void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
-  void setTimeStretchType(const std::string &type);
 
   void start(double when, double offset, double duration = -1);
 
  protected:
   std::mutex &getBufferLock();
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-  double getStopTime() const override;
 
  private:
-  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-music")
-        return TimeStretchType::SPEECH_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_MUSIC:
-        return "speech-music";
-    }
-
-    throw std::invalid_argument("Unknown time stretch type");
-  }
-
   // Looping related properties
   bool loop_;
   double loopStart_;
   double loopEnd_;
   std::mutex bufferLock_;
 
-  // time-stretching and pitch-shifting
-  TimeStretchType timeStretchType_;
-
-  // k-rate params
+  // playback rate aka pitch change params
   std::shared_ptr<AudioParam> detuneParam_;
   std::shared_ptr<AudioParam> playbackRateParam_;
 
-  std::shared_ptr<AudioBus> playbackRateBus_;
-
   // internal helper
   double vReadIndex_;
 
   // User provided buffer
   std::shared_ptr<AudioBuffer> buffer_;
+  std::shared_ptr<AudioBus> alignedBus_;
+
+  float getPlaybackRateValue(size_t &startOffset);
+
+  double getVirtualStartFrame();
+  double getVirtualEndFrame();
 
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus>& processingBus,
@@ -97,11 +69,6 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
       size_t startOffset,
       size_t offsetLength,
       float playbackRate);
-
-  float getComputedPlaybackRateValue();
-
-  double getVirtualStartFrame();
-  double getVirtualEndFrame();
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -1,9 +1,9 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/dsp/AudioUtils.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -40,11 +40,6 @@ bool AudioScheduledSourceNode::isFinished() {
   return playbackState_ == PlaybackState::FINISHED;
 }
 
-void AudioScheduledSourceNode::setOnendedCallback(
-    const std::function<void(double)> &onendedCallback) {
-  onendedCallback_ = onendedCallback;
-}
-
 void AudioScheduledSourceNode::updatePlaybackInfo(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess,
@@ -63,11 +58,12 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   size_t firstFrame = context_->getCurrentSampleFrame();
   size_t lastFrame = firstFrame + framesToProcess;
 
-  size_t startFrame =
-      std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
+  size_t startFrame = std::max(
+      AudioUtils::timeToSampleFrame(startTime_, sampleRate), firstFrame);
   size_t stopFrame = stopTime_ == -1.0
       ? std::numeric_limits<size_t>::max()
-      : std::max(dsp::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
+      : std::max(
+            AudioUtils::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
 
   if (isUnscheduled() || isFinished()) {
     startOffset = 0;
@@ -109,11 +105,6 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   if (stopFrame < firstFrame) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;
-
-    if (onendedCallback_) {
-      onendedCallback_(getStopTime());
-    }
-
     playbackState_ = PlaybackState::FINISHED;
     disable();
     return;
@@ -126,9 +117,6 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 
 void AudioScheduledSourceNode::handleStopScheduled() {
   if (isPlaying() && stopTime_ > 0 && context_->getCurrentTime() >= stopTime_) {
-    if (onendedCallback_) {
-      onendedCallback_(getStopTime());
-    }
     playbackState_ = PlaybackState::FINISHED;
     disable();
   }

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -12,7 +12,6 @@
 #include <thread>
 #include <cstddef>
 #include <cassert>
-#include <utility>
 
 namespace audioapi {
 
@@ -29,10 +28,6 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isPlaying();
   bool isFinished();
 
-  void setOnendedCallback(const std::function<void(double)> &onendedCallback);
-
-  virtual double getStopTime() const = 0;
-
  protected:
   PlaybackState playbackState_;
 
@@ -47,8 +42,6 @@ class AudioScheduledSourceNode : public AudioNode {
  private:
   double startTime_;
   double stopTime_;
-
-  std::function<void(double)> onendedCallback_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/OscillatorNode.cpp

@@ -1,8 +1,7 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/OscillatorNode.h>
-#include <audioapi/dsp/AudioUtils.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -10,10 +9,7 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
       444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency());
-  detuneParam_ = std::make_shared<AudioParam>(
-      0.0,
-      -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT);
+  detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
   isInitialized_ = true;
@@ -85,9 +81,4 @@ void OscillatorNode::processNode(
   handleStopScheduled();
 }
 
-double OscillatorNode::getStopTime() const {
-  return dsp::sampleFrameToTime(
-      static_cast<int>(phase_), context_->getSampleRate());
-}
-
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/OscillatorNode.h

@@ -25,7 +25,6 @@ class OscillatorNode : public AudioScheduledSourceNode {
 
  protected:
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-  double getStopTime() const override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;

package/common/cpp/audioapi/{utils → core/utils}/AudioArray.cpp

@@ -1,5 +1,5 @@
+#include <audioapi/core/utils/AudioArray.h>
 #include <audioapi/dsp/VectorMath.h>
-#include <audioapi/utils/AudioArray.h>
 
 namespace audioapi {
 
@@ -37,7 +37,7 @@ void AudioArray::normalize() {
     return;
   }
 
-  dsp::multiplyByScalar(data_, 1.0f / maxAbsValue, data_, size_);
+  VectorMath::multiplyByScalar(data_, 1.0f / maxAbsValue, data_, size_);
 }
 
 void AudioArray::resize(size_t size) {
@@ -58,11 +58,11 @@ void AudioArray::resize(size_t size) {
 }
 
 void AudioArray::scale(float value) {
-  dsp::multiplyByScalar(data_, value, data_, size_);
+  VectorMath::multiplyByScalar(data_, value, data_, size_);
 }
 
 float AudioArray::getMaxAbsValue() const {
-  return dsp::maximumMagnitude(data_, size_);
+  return VectorMath::maximumMagnitude(data_, size_);
 }
 
 void AudioArray::zero() {
@@ -86,7 +86,7 @@ void AudioArray::sum(
     size_t sourceStart,
     size_t destinationStart,
     size_t length) {
-  dsp::add(
+  VectorMath::add(
       data_ + destinationStart,
       source->getData() + sourceStart,
       data_ + destinationStart,

package/common/cpp/audioapi/{utils → core/utils}/AudioBus.cpp

@@ -1,7 +1,7 @@
 #include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/dsp/VectorMath.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
 
 // Implementation of channel summing/mixing is based on the WebKit approach,
 // source:
@@ -375,12 +375,12 @@ void AudioBus::sumByDownMixing(
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         0.5f,
         destinationData + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         0.5f,
         destinationData + destinationStart,
@@ -401,22 +401,22 @@ void AudioBus::sumByDownMixing(
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         0.25f,
         destinationData + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         0.25f,
         destinationData + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         0.25f,
         destinationData + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         0.25f,
         destinationData + destinationStart,
@@ -438,27 +438,27 @@ void AudioBus::sumByDownMixing(
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         SQRT_HALF,
         destinationData + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         SQRT_HALF,
         destinationData + destinationStart,
         length);
-    dsp::add(
+    VectorMath::add(
         sourceCenter + sourceStart,
         destinationData + destinationStart,
         destinationData + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         0.5f,
         destinationData + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         0.5f,
         destinationData + destinationStart,
@@ -481,23 +481,23 @@ void AudioBus::sumByDownMixing(
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
 
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceLeft + sourceStart,
         0.5f,
         destinationLeft + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         0.5f,
         destinationLeft + destinationStart,
         length);
 
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceRight + sourceStart,
         0.5f,
         destinationRight + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         0.5f,
         destinationRight + destinationStart,
@@ -521,33 +521,33 @@ void AudioBus::sumByDownMixing(
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
 
-    dsp::add(
+    VectorMath::add(
         sourceLeft + sourceStart,
         destinationLeft + destinationStart,
         destinationLeft + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceCenter + sourceStart,
         SQRT_HALF,
         destinationLeft + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundLeft + sourceStart,
         SQRT_HALF,
         destinationLeft + destinationStart,
         length);
 
-    dsp::add(
+    VectorMath::add(
         sourceRight + sourceStart,
         destinationRight + destinationStart,
         destinationRight + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceCenter + sourceStart,
         SQRT_HALF,
         destinationRight + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceSurroundRight + sourceStart,
         SQRT_HALF,
         destinationRight + destinationStart,
@@ -576,28 +576,28 @@ void AudioBus::sumByDownMixing(
     float *destinationSurroundRight =
         getChannelByType(ChannelSurroundRight)->getData();
 
-    dsp::add(
+    VectorMath::add(
         sourceLeft + sourceStart,
         destinationLeft + destinationStart,
         destinationLeft + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceCenter, SQRT_HALF, destinationLeft + destinationStart, length);
 
-    dsp::add(
+    VectorMath::add(
         sourceRight + sourceStart,
         destinationRight + destinationStart,
         destinationRight + destinationStart,
         length);
-    dsp::multiplyByScalarThenAddToOutput(
+    VectorMath::multiplyByScalarThenAddToOutput(
         sourceCenter, SQRT_HALF, destinationRight + destinationStart, length);
 
-    dsp::add(
+    VectorMath::add(
         sourceSurroundLeft + sourceStart,
         destinationSurroundLeft + destinationStart,
         destinationSurroundLeft + destinationStart,
         length);
-    dsp::add(
+    VectorMath::add(
         sourceSurroundRight + sourceStart,
         destinationSurroundRight + destinationStart,
         destinationSurroundRight + destinationStart,

package/common/cpp/audioapi/dsp/AudioUtils.cpp

@@ -1,6 +1,6 @@
 #include <audioapi/dsp/AudioUtils.h>
 
-namespace audioapi::dsp {
+namespace audioapi::AudioUtils {
 size_t timeToSampleFrame(double time, float sampleRate) {
   return static_cast<size_t>(time * sampleRate);
 }
@@ -30,4 +30,4 @@ float linearToDecibels(float value) {
 float decibelsToLinear(float value) {
   return powf(10, value / 20);
 }
-} // namespace audioapi::dsp
+} // namespace audioapi::AudioUtils