react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/utils/VectorMath.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2010, Google Inc. All rights reserved.
+ * Copyright (C) 2020, Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1.  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+// Defines the interface for several vector math functions whose implementation
+// will ideally be optimized.
+
+#include <cstddef>
+
+namespace audioapi::VectorMath {
+
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+
+void multiplyByScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void addScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void add(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void subtract(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void multiply(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+
+// Finds the maximum magnitude of a float vector.
+float maximumMagnitude(
+    const float *inputVector,
+    size_t numberOfElementsToProcess);
+} // namespace audioapi::VectorMath

package/common/cpp/utils/android/FFTFrame.cpp

@@ -0,0 +1,22 @@
+#if defined(ANDROID)
+#include "FFTFrame.h"
+#include <fftw3.h>
+
+namespace audioapi {
+void FFTFrame::inverse(float *timeDomainData) {
+    fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
+    for(int i = 0; i < size_ / 2; i++) {
+        freqDomainData[i][0] = realData_[i];
+        freqDomainData[i][1] = imaginaryData_[i];
+    }
+
+    auto plan = fftwf_plan_dft_c2r_1d(size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
+    fftwf_execute(plan);
+    fftwf_destroy_plan(plan);
+    fftwf_free(freqDomainData);
+
+    VectorMath::multiplyByScalar(
+            timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+}
+} // namespace audioapi
+#endif

package/common/cpp/utils/ios/FFTFrame.cpp

@@ -0,0 +1,24 @@
+#if defined(HAVE_ACCELERATE)
+#include "FFTFrame.h"
+#include "Accelerate/Accelerate.h"
+
+namespace audioapi {
+
+void FFTFrame::inverse(float *timeDomainData) {
+  FFTSetup fftSetup_ = vDSP_create_fftsetup(log2Size_, FFT_RADIX2);
+  DSPSplitComplex freqDomainData;
+  freqDomainData.realp = realData_;
+  freqDomainData.imagp = imaginaryData_;
+
+  vDSP_fft_zrip(fftSetup_, &freqDomainData, 1, log2Size_, FFT_INVERSE);
+  vDSP_ztoc(&freqDomainData, 1, reinterpret_cast<DSPComplex *>(timeDomainData), 2, size_ / 2);
+
+  // Scale the FFT data, beacuse of
+  // https://developer.apple.com/library/archive/documentation/Performance/Conceptual/vDSP_Programming_Guide/UsingFourierTransforms/UsingFourierTransforms.html#//apple_ref/doc/uid/TP40005147-CH3-15892
+  VectorMath::multiplyByScalar(
+      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+
+  vDSP_destroy_fftsetup(fftSetup_);
+}
+} // namespace audioapi
+#endif

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.cpp

@@ -0,0 +1,45 @@
+#include "AudioBufferSourceNodeWrapper.h"
+
+namespace audioapi {
+
+AudioBufferSourceNodeWrapper::AudioBufferSourceNodeWrapper(
+    const std::shared_ptr<AudioBufferSourceNode> &audioBufferSourceNode)
+    : AudioScheduledSourceNodeWrapper(audioBufferSourceNode) {}
+
+std::shared_ptr<AudioBufferSourceNode>
+AudioBufferSourceNodeWrapper::getAudioBufferSourceNodeFromAudioNode() {
+  return std::static_pointer_cast<AudioBufferSourceNode>(node_);
+}
+
+bool AudioBufferSourceNodeWrapper::getLoop() {
+  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
+  return audioBufferSourceNode->getLoop();
+}
+
+void AudioBufferSourceNodeWrapper::setLoop(bool loop) {
+  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
+  audioBufferSourceNode->setLoop(loop);
+}
+
+std::shared_ptr<AudioBufferWrapper> AudioBufferSourceNodeWrapper::getBuffer() {
+  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
+  auto buffer = audioBufferSourceNode->getBuffer();
+
+  if (!buffer) {
+    return {nullptr};
+  }
+
+  return std::make_shared<AudioBufferWrapper>(buffer);
+}
+
+void AudioBufferSourceNodeWrapper::setBuffer(
+    const std::shared_ptr<AudioBufferWrapper> &buffer) {
+  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
+  if (!buffer) {
+    audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
+    return;
+  }
+
+  audioBufferSourceNode->setBuffer(buffer->audioBuffer_);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include "AudioBufferSourceNode.h"
+#include "AudioBufferWrapper.h"
+#include "AudioScheduledSourceNodeWrapper.h"
+
+namespace audioapi {
+
+class AudioBufferSourceNodeWrapper : public AudioScheduledSourceNodeWrapper {
+ public:
+  explicit AudioBufferSourceNodeWrapper(
+      const std::shared_ptr<AudioBufferSourceNode> &audioBufferSourceNode);
+
+  void setLoop(bool loop);
+  [[nodiscard]] bool getLoop();
+  [[nodiscard]] std::shared_ptr<AudioBufferWrapper> getBuffer();
+  void setBuffer(const std::shared_ptr<AudioBufferWrapper> &buffer);
+
+ private:
+  std::shared_ptr<AudioBufferSourceNode>
+  getAudioBufferSourceNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioBufferWrapper.cpp

@@ -0,0 +1,46 @@
+#include "AudioBufferWrapper.h"
+
+namespace audioapi {
+
+AudioBufferWrapper::AudioBufferWrapper(
+    const std::shared_ptr<AudioBuffer> &audioBuffer)
+    : audioBuffer_(audioBuffer) {}
+
+int AudioBufferWrapper::getSampleRate() const {
+  return audioBuffer_->getSampleRate();
+}
+
+int AudioBufferWrapper::getLength() const {
+  return audioBuffer_->getLength();
+}
+
+double AudioBufferWrapper::getDuration() const {
+  return audioBuffer_->getDuration();
+}
+
+int AudioBufferWrapper::getNumberOfChannels() const {
+  return audioBuffer_->getNumberOfChannels();
+}
+
+float *AudioBufferWrapper::getChannelData(int channel) const {
+  return audioBuffer_->getChannelData(channel);
+}
+
+void AudioBufferWrapper::copyFromChannel(
+    float *destination,
+    int destinationLength,
+    int channelNumber,
+    int startInChannel) const {
+  audioBuffer_->copyFromChannel(
+      destination, destinationLength, channelNumber, startInChannel);
+}
+
+void AudioBufferWrapper::copyToChannel(
+    float *source,
+    int sourceLength,
+    int channelNumber,
+    int startInChannel) const {
+  audioBuffer_->copyToChannel(
+      source, sourceLength, channelNumber, startInChannel);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioBufferWrapper.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioBuffer.h"
+
+namespace audioapi {
+
+class AudioBufferWrapper {
+ public:
+  explicit AudioBufferWrapper(const std::shared_ptr<AudioBuffer> &audioBuffer);
+
+  std::shared_ptr<AudioBuffer> audioBuffer_;
+  [[nodiscard]] int getNumberOfChannels() const;
+  [[nodiscard]] int getLength() const;
+  [[nodiscard]] double getDuration() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] float *getChannelData(int channel) const;
+  void copyFromChannel(
+      float *destination,
+      int destinationLength,
+      int channelNumber,
+      int startInChannel = 0) const;
+  void copyToChannel(
+      float *source,
+      int sourceLength,
+      int channelNumber,
+      int startInChannel = 0) const;
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.cpp

@@ -0,0 +1,17 @@
+#include "AudioContextWrapper.h"
+
+namespace audioapi {
+
+AudioContextWrapper::AudioContextWrapper(
+    const std::shared_ptr<AudioContext> &context)
+    : BaseAudioContextWrapper(context) {}
+
+void AudioContextWrapper::close() {
+  getAudioContextFromBaseAudioContext()->close();
+}
+
+std::shared_ptr<AudioContext>
+AudioContextWrapper::getAudioContextFromBaseAudioContext() {
+  return std::static_pointer_cast<AudioContext>(context_);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioContext.h"
+#include "BaseAudioContextWrapper.h"
+
+namespace audioapi {
+
+class AudioContextWrapper : public BaseAudioContextWrapper {
+ public:
+  explicit AudioContextWrapper(const std::shared_ptr<AudioContext> &context);
+
+  void close();
+
+ private:
+  std::shared_ptr<AudioContext> getAudioContextFromBaseAudioContext();
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioDestinationNodeWrapper.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioDestinationNode.h"
+#include "AudioNodeWrapper.h"
+
+namespace audioapi {
+
+class AudioDestinationNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit AudioDestinationNodeWrapper(
+      const std::shared_ptr<AudioDestinationNode> &destinationNode)
+      : AudioNodeWrapper(destinationNode) {}
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.cpp

@@ -0,0 +1,37 @@
+#include "AudioNodeWrapper.h"
+
+namespace audioapi {
+
+AudioNodeWrapper::AudioNodeWrapper(const std::shared_ptr<AudioNode> &node)
+    : node_(node) {}
+
+int AudioNodeWrapper::getNumberOfInputs() const {
+  return node_->getNumberOfInputs();
+}
+
+int AudioNodeWrapper::getNumberOfOutputs() const {
+  return node_->getNumberOfOutputs();
+}
+
+int AudioNodeWrapper::getChannelCount() const {
+  return node_->getChannelCount();
+}
+
+std::string AudioNodeWrapper::getChannelCountMode() const {
+  return node_->getChannelCountMode();
+}
+
+std::string AudioNodeWrapper::getChannelInterpretation() const {
+  return node_->getChannelInterpretation();
+}
+
+void AudioNodeWrapper::connect(
+    const std::shared_ptr<AudioNodeWrapper> &node) const {
+  node_->connect(node->node_);
+}
+
+void AudioNodeWrapper::disconnect(
+    const std::shared_ptr<AudioNodeWrapper> &node) const {
+  node_->disconnect(node->node_);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "AudioNode.h"
+
+namespace audioapi {
+
+class AudioNodeWrapper {
+ public:
+  explicit AudioNodeWrapper(const std::shared_ptr<AudioNode> &node);
+
+  [[nodiscard]] int getNumberOfInputs() const;
+  [[nodiscard]] int getNumberOfOutputs() const;
+  [[nodiscard]] int getChannelCount() const;
+  [[nodiscard]] std::string getChannelCountMode() const;
+  [[nodiscard]] std::string getChannelInterpretation() const;
+  void connect(const std::shared_ptr<AudioNodeWrapper> &node) const;
+  void disconnect(const std::shared_ptr<AudioNodeWrapper> &node) const;
+
+ protected:
+  std::shared_ptr<AudioNode> node_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioParamWrapper.cpp

@@ -0,0 +1,42 @@
+#include "AudioParamWrapper.h"
+
+namespace audioapi {
+
+AudioParamWrapper::AudioParamWrapper(const std::shared_ptr<AudioParam> &param)
+    : param_(param) {}
+
+float AudioParamWrapper::getValue() const {
+  return param_->getValue();
+}
+
+void AudioParamWrapper::setValue(float value) const {
+  param_->setValue(value);
+}
+
+float AudioParamWrapper::getDefaultValue() const {
+  return param_->getDefaultValue();
+}
+
+float AudioParamWrapper::getMinValue() const {
+  return param_->getMinValue();
+}
+
+float AudioParamWrapper::getMaxValue() const {
+  return param_->getMaxValue();
+}
+
+void AudioParamWrapper::setValueAtTime(float value, double startTime) const {
+  param_->setValueAtTime(value, startTime);
+}
+
+void AudioParamWrapper::linearRampToValueAtTime(float value, double endTime)
+    const {
+  param_->linearRampToValueAtTime(value, endTime);
+}
+
+void AudioParamWrapper::exponentialRampToValueAtTime(
+    float value,
+    double endTime) const {
+  param_->exponentialRampToValueAtTime(value, endTime);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioParamWrapper.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioParam.h"
+
+namespace audioapi {
+
+class AudioParamWrapper {
+ public:
+  explicit AudioParamWrapper(const std::shared_ptr<AudioParam> &param);
+
+  [[nodiscard]] float getValue() const;
+  void setValue(float value) const;
+  [[nodiscard]] float getDefaultValue() const;
+  [[nodiscard]] float getMinValue() const;
+  [[nodiscard]] float getMaxValue() const;
+  void setValueAtTime(float value, double startTime) const;
+  void linearRampToValueAtTime(float value, double endTime) const;
+  void exponentialRampToValueAtTime(float value, double endTime) const;
+
+ private:
+  std::shared_ptr<AudioParam> param_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioScheduledSourceNodeWrapper.cpp

@@ -0,0 +1,23 @@
+#include "AudioScheduledSourceNodeWrapper.h"
+
+namespace audioapi {
+
+AudioScheduledSourceNodeWrapper::AudioScheduledSourceNodeWrapper(
+    const std::shared_ptr<AudioScheduledSourceNode> &audioScheduledSourceNode)
+    : AudioNodeWrapper(audioScheduledSourceNode) {}
+
+std::shared_ptr<AudioScheduledSourceNode>
+AudioScheduledSourceNodeWrapper::getAudioScheduledSourceNodeFromAudioNode() {
+  return std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+}
+
+void AudioScheduledSourceNodeWrapper::start(double time) {
+  auto audioScheduledSourceNode = getAudioScheduledSourceNodeFromAudioNode();
+  audioScheduledSourceNode->start(time);
+}
+
+void AudioScheduledSourceNodeWrapper::stop(double time) {
+  auto audioScheduledSourceNode = getAudioScheduledSourceNodeFromAudioNode();
+  audioScheduledSourceNode->stop(time);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioScheduledSourceNodeWrapper.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNodeWrapper.h"
+#include "AudioScheduledSourceNode.h"
+
+namespace audioapi {
+
+class AudioScheduledSourceNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit AudioScheduledSourceNodeWrapper(
+      const std::shared_ptr<AudioScheduledSourceNode>
+          &audioScheduledSourceNode);
+
+  void start(double time);
+  void stop(double time);
+
+ private:
+  std::shared_ptr<AudioScheduledSourceNode>
+  getAudioScheduledSourceNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.cpp

@@ -0,0 +1,76 @@
+#include "BaseAudioContextWrapper.h"
+
+namespace audioapi {
+
+BaseAudioContextWrapper::BaseAudioContextWrapper(
+    const std::shared_ptr<BaseAudioContext> &context)
+    : context_(context) {
+  auto destination = context_->getDestination();
+  destination_ = std::make_shared<AudioDestinationNodeWrapper>(destination);
+}
+
+std::shared_ptr<AudioDestinationNodeWrapper>
+BaseAudioContextWrapper::getDestination() const {
+  return destination_;
+}
+
+std::string BaseAudioContextWrapper::getState() const {
+  return context_->getState();
+}
+
+int BaseAudioContextWrapper::getSampleRate() const {
+  return context_->getSampleRate();
+}
+
+double BaseAudioContextWrapper::getCurrentTime() const {
+  return context_->getCurrentTime();
+}
+
+std::shared_ptr<OscillatorNodeWrapper>
+BaseAudioContextWrapper::createOscillator() const {
+  auto oscillator = context_->createOscillator();
+  return std::make_shared<OscillatorNodeWrapper>(oscillator);
+}
+
+std::shared_ptr<GainNodeWrapper> BaseAudioContextWrapper::createGain() const {
+  auto gain = context_->createGain();
+  return std::make_shared<GainNodeWrapper>(gain);
+}
+
+std::shared_ptr<StereoPannerNodeWrapper>
+BaseAudioContextWrapper::createStereoPanner() const {
+  auto panner = context_->createStereoPanner();
+  return std::make_shared<StereoPannerNodeWrapper>(panner);
+}
+
+std::shared_ptr<BiquadFilterNodeWrapper>
+BaseAudioContextWrapper::createBiquadFilter() const {
+  auto filter = context_->createBiquadFilter();
+  return std::make_shared<BiquadFilterNodeWrapper>(filter);
+}
+
+std::shared_ptr<AudioBufferSourceNodeWrapper>
+BaseAudioContextWrapper::createBufferSource() const {
+  auto bufferSource = context_->createBufferSource();
+  return std::make_shared<AudioBufferSourceNodeWrapper>(bufferSource);
+}
+
+std::shared_ptr<AudioBufferWrapper> BaseAudioContextWrapper::createBuffer(
+    int numberOfChannels,
+    int length,
+    int sampleRate) const {
+  auto buffer = context_->createBuffer(numberOfChannels, length, sampleRate);
+  return std::make_shared<AudioBufferWrapper>(buffer);
+}
+
+std::shared_ptr<PeriodicWaveWrapper>
+BaseAudioContextWrapper::createPeriodicWave(
+    float *real,
+    float *imag,
+    bool disableNormalization,
+    int length) {
+  auto periodicWave =
+      context_->createPeriodicWave(real, imag, disableNormalization, length);
+  return std::make_shared<PeriodicWaveWrapper>(periodicWave);
+}
+} // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "AudioBufferSourceNodeWrapper.h"
+#include "AudioBufferWrapper.h"
+#include "AudioDestinationNodeWrapper.h"
+#include "BaseAudioContext.h"
+#include "BiquadFilterNodeWrapper.h"
+#include "GainNodeWrapper.h"
+#include "OscillatorNodeWrapper.h"
+#include "PeriodicWaveWrapper.h"
+#include "StereoPannerNodeWrapper.h"
+
+namespace audioapi {
+
+class BaseAudioContextWrapper {
+ public:
+  explicit BaseAudioContextWrapper(
+      const std::shared_ptr<BaseAudioContext> &context);
+
+  [[nodiscard]] std::shared_ptr<AudioDestinationNodeWrapper> getDestination()
+      const;
+  [[nodiscard]] std::string getState() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] double getCurrentTime() const;
+  [[nodiscard]] std::shared_ptr<OscillatorNodeWrapper> createOscillator() const;
+  [[nodiscard]] std::shared_ptr<GainNodeWrapper> createGain() const;
+  [[nodiscard]] std::shared_ptr<StereoPannerNodeWrapper> createStereoPanner()
+      const;
+  [[nodiscard]] std::shared_ptr<BiquadFilterNodeWrapper> createBiquadFilter()
+      const;
+  [[nodiscard]] std::shared_ptr<AudioBufferSourceNodeWrapper>
+  createBufferSource() const;
+  [[nodiscard]] std::shared_ptr<AudioBufferWrapper>
+  createBuffer(int numberOfChannels, int length, int sampleRate) const;
+  [[nodiscard]] std::shared_ptr<PeriodicWaveWrapper> createPeriodicWave(
+      float *real,
+      float *imag,
+      bool disableNormalization,
+      int length);
+
+ protected:
+  std::shared_ptr<AudioDestinationNodeWrapper> destination_;
+  std::shared_ptr<BaseAudioContext> context_;
+};
+} // namespace audioapi