react-native-audio-api 0.3.2 → 0.4.1

package/common/cpp/core/AudioContext.cpp

@@ -5,16 +5,56 @@
 #endif
 
 #include "AudioContext.h"
+#include "AudioDecoder.h"
+#include "AudioDestinationNode.h"
 
 namespace audioapi {
-
 AudioContext::AudioContext() : BaseAudioContext() {
+#ifdef ANDROID
+  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+#else
+  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
+#endif
+  sampleRate_ = audioPlayer_->getSampleRate();
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
+
+  audioPlayer_->start();
+}
+
+AudioContext::AudioContext(int sampleRate) : BaseAudioContext() {
+#ifdef ANDROID
+  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio(), sampleRate);
+#else
+  audioPlayer_ =
+      std::make_shared<IOSAudioPlayer>(this->renderAudio(), sampleRate);
+#endif
+  sampleRate_ = audioPlayer_->getSampleRate();
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
+
   audioPlayer_->start();
 }
 
+AudioContext::~AudioContext() {
+  if (isRunning()) {
+    return;
+  }
+
+  close();
+}
+
 void AudioContext::close() {
   state_ = ContextState::CLOSED;
   audioPlayer_->stop();
 }
 
+std::function<void(AudioBus *, int)> AudioContext::renderAudio() {
+  if (!isRunning()) {
+    return [](AudioBus *, int) {};
+  }
+
+  return [this](AudioBus *data, int frames) {
+    destination_->renderAudio(data, frames);
+  };
+}
+
 } // namespace audioapi

package/common/cpp/core/AudioContext.h

@@ -1,16 +1,33 @@
 #pragma once
 
 #include <memory>
+#include <functional>
 
 #include "BaseAudioContext.h"
 
 namespace audioapi {
+#ifdef ANDROID
+class AudioPlayer;
+#else
+class IOSAudioPlayer;
+#endif
 
 class AudioContext : public BaseAudioContext {
  public:
   AudioContext();
+  explicit AudioContext(int sampleRate);
+  ~AudioContext() override;
 
   void close();
+
+  std::function<void(AudioBus *, int)> renderAudio();
+
+ private:
+#ifdef ANDROID
+    std::shared_ptr<AudioPlayer> audioPlayer_;
+#else
+    std::shared_ptr<IOSAudioPlayer> audioPlayer_;
+#endif
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioNode.cpp

@@ -9,9 +9,7 @@ namespace audioapi {
 
 AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
   audioBus_ = std::make_shared<AudioBus>(
-      context->getSampleRate(),
-      context->getBufferSizeInFrames(),
-      channelCount_);
+      context->getSampleRate(), RENDER_QUANTUM_SIZE, channelCount_);
 }
 
 AudioNode::~AudioNode() {
@@ -49,6 +47,12 @@ void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
   node->onInputConnected(this);
 }
 
+void AudioNode::disconnect() {
+  for (auto &outputNode : outputNodes_) {
+    disconnectNode(outputNode);
+  }
+}
+
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
   context_->getNodeManager()->addPendingConnection(
       shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
@@ -126,7 +130,7 @@ AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
   // - it has more than one output, so each output node can get the processed
   // data without re-calculating the node.
   bool canUseOutputBus =
-      outputBus != 0 && inputNodes_.size() < 2 && outputNodes_.size() < 2;
+      outputBus != nullptr && inputNodes_.size() < 2 && outputNodes_.size() < 2;
 
   if (isAlreadyProcessed) {
     // If it was already processed in the rendering quantum, return it.
@@ -144,8 +148,9 @@ AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
   }
 
   if (inputNodes_.empty()) {
-    // If there are no connected inputs, process the node just to advance the
-    // audio params. The node will output silence anyway.
+    // If there are no connected inputs, if processing node is the source node,
+    // it will fill processing bus with the audio data, otherwise it will return
+    // silence.
     processNode(processingBus, framesToProcess);
     return processingBus;
   }
@@ -200,6 +205,10 @@ void AudioNode::onInputDisabled() {
 }
 
 void AudioNode::onInputConnected(AudioNode *node) {
+  if (!isInitialized_) {
+    return;
+  }
+
   inputNodes_.push_back(node);
 
   if (node->isEnabled()) {
@@ -208,13 +217,17 @@ void AudioNode::onInputConnected(AudioNode *node) {
 }
 
 void AudioNode::onInputDisconnected(AudioNode *node) {
+  if (!isInitialized_) {
+    return;
+  }
+
   auto position = std::find(inputNodes_.begin(), inputNodes_.end(), node);
 
   if (position != inputNodes_.end()) {
     inputNodes_.erase(position);
   }
 
-  if (inputNodes_.size() > 0) {
+  if (!inputNodes_.empty()) {
     return;
   }
 
@@ -222,7 +235,7 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
     node->onInputDisabled();
   }
 
-  for (auto outputNode : outputNodes_) {
+  for (const auto &outputNode : outputNodes_) {
     disconnectNode(outputNode);
   }
 }

package/common/cpp/core/AudioNode.h

@@ -23,6 +23,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   std::string getChannelCountMode() const;
   std::string getChannelInterpretation() const;
   void connect(const std::shared_ptr<AudioNode> &node);
+  void disconnect();
   void disconnect(const std::shared_ptr<AudioNode> &node);
 
   bool isEnabled() const;

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -85,8 +85,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     startOffset = std::max(startFrame, firstFrame) - firstFrame > 0
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
-    nonSilentFramesToProcess =
-        std::min(lastFrame, stopFrame) - startFrame;
+    nonSilentFramesToProcess = std::min(lastFrame, stopFrame) - startFrame;
     processingBus->zero(0, startOffset);
     return;
   }

package/common/cpp/core/BaseAudioContext.cpp

@@ -1,11 +1,6 @@
-#ifdef ANDROID
-#include "AudioPlayer.h"
-#else
-#include "IOSAudioPlayer.h"
-#endif
-
 #include "BaseAudioContext.h"
 
+#include "AnalyserNode.h"
 #include "AudioArray.h"
 #include "AudioBuffer.h"
 #include "AudioBufferSourceNode.h"
@@ -22,30 +17,10 @@
 namespace audioapi {
 
 BaseAudioContext::BaseAudioContext() {
-#ifdef ANDROID
-  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
-#else
-  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
-#endif
-
-  audioDecoder_ = std::make_shared<AudioDecoder>(audioPlayer_->getSampleRate());
-
-  sampleRate_ = audioPlayer_->getSampleRate();
-  bufferSizeInFrames_ = audioPlayer_->getBufferSizeInFrames();
-
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
 }
 
-BaseAudioContext::~BaseAudioContext() {
-  if (isRunning()) {
-    return;
-  }
-
-  state_ = ContextState::CLOSED;
-  audioPlayer_->stop();
-}
-
 std::string BaseAudioContext::getState() {
   return BaseAudioContext::toString(state_);
 }
@@ -54,10 +29,6 @@ int BaseAudioContext::getSampleRate() const {
   return sampleRate_;
 }
 
-int BaseAudioContext::getBufferSizeInFrames() const {
-  return bufferSizeInFrames_;
-}
-
 std::size_t BaseAudioContext::getCurrentSampleFrame() const {
   return destination_->getCurrentSampleFrame();
 }
@@ -106,22 +77,16 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
       sampleRate_, real, imag, length, disableNormalization);
 }
 
+std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
+  return std::make_shared<AnalyserNode>(this);
+}
+
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
     const std::string &path) {
   auto audioBus = audioDecoder_->decodeWithFilePath(path);
   return std::make_shared<AudioBuffer>(audioBus);
 }
 
-std::function<void(AudioBus *, int)> BaseAudioContext::renderAudio() {
-  if (!isRunning()) {
-    return [](AudioBus *, int) {};
-  }
-
-  return [this](AudioBus *data, int frames) {
-    destination_->renderAudio(data, frames);
-  };
-}
-
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }

package/common/cpp/core/BaseAudioContext.h

@@ -22,22 +22,16 @@ class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioDecoder;
-
-#ifdef ANDROID
-class AudioPlayer;
-#else
-class IOSAudioPlayer;
-#endif
+class AnalyserNode;
 
 class BaseAudioContext {
  public:
   BaseAudioContext();
-  ~BaseAudioContext();
+  virtual ~BaseAudioContext() = default;
 
   std::string getState();
   [[nodiscard]] int getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
-  [[nodiscard]] int getBufferSizeInFrames() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
   std::shared_ptr<AudioDestinationNode> getDestination();
 
@@ -53,10 +47,10 @@ class BaseAudioContext {
       float *imag,
       bool disableNormalization,
       int length);
+  std::shared_ptr<AnalyserNode> createAnalyser();
 
   std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
-  std::function<void(AudioBus *, int)> renderAudio();
   AudioNodeManager *getNodeManager();
   [[nodiscard]] bool isRunning() const;
   [[nodiscard]] bool isClosed() const;
@@ -64,16 +58,11 @@ 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_;
-#else
-  std::shared_ptr<IOSAudioPlayer> audioPlayer_;
-#endif
+  // init in AudioContext or OfflineContext constructor
+  std::shared_ptr<AudioDecoder> audioDecoder_ {};
 
-  int sampleRate_;
-  int bufferSizeInFrames_;
+  // init in AudioContext or OfflineContext constructor
+  int sampleRate_ {};
   ContextState state_ = ContextState::RUNNING;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 

package/common/cpp/core/Constants.h

@@ -6,11 +6,14 @@
 // https://webaudio.github.io/web-audio-api/
 
 namespace audioapi {
-constexpr int SAMPLE_RATE = 44100;
+constexpr int DEFAULT_SAMPLE_RATE = 48000;
+constexpr int RENDER_QUANTUM_SIZE = 128;
 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 NYQUIST_FREQUENCY = SAMPLE_RATE / 2.0;
+
+constexpr float NYQUIST_FREQUENCY = DEFAULT_SAMPLE_RATE / 2.0;
 static float MAX_DETUNE = 1200 * std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 constexpr float MAX_GAIN = MOST_POSITIVE_SINGLE_FLOAT;
 constexpr float MAX_PAN = 1.0;
@@ -19,4 +22,10 @@ constexpr float MAX_FILTER_FREQUENCY = NYQUIST_FREQUENCY;
 constexpr float MIN_FILTER_FREQUENCY = 0.0;
 static float MAX_FILTER_GAIN = 40 * std::log10(MOST_POSITIVE_SINGLE_FLOAT);
 constexpr float MIN_FILTER_GAIN = -MAX_GAIN;
+
+constexpr int MAX_FFT_SIZE = 32768;
+constexpr int DEFAULT_FFT_SIZE = 2048;
+constexpr double DEFAULT_MAX_DECIBELS = -30;
+constexpr double DEFAULT_MIN_DECIBELS = -100;
+const double DEFAULT_SMOOTHING_TIME_CONSTANT = 0.8;
 } // namespace audioapi

package/common/cpp/core/PeriodicWave.cpp

@@ -226,7 +226,7 @@ void PeriodicWave::createBandLimitedTables(
           0.0f);
     }
 
-    // Zero out the nquist and DC components.
+    // Zero out the DC and nquist components.
     realFFTFrameData[0] = 0.0f;
     imaginaryFFTFrameData[0] = 0.0f;
 
@@ -234,7 +234,7 @@ void PeriodicWave::createBandLimitedTables(
 
     // Perform the inverse FFT to get the time domain representation of the
     // band-limited waveform.
-    fftFrame.inverse(bandLimitedTables_[rangeIndex]);
+    fftFrame.doInverseFFT(bandLimitedTables_[rangeIndex]);
 
     if (!disableNormalization_ && rangeIndex == 0) {
       float maxValue =

package/common/cpp/jsi/JsiHostObject.h

@@ -13,7 +13,7 @@
 #define JSI_HOST_FUNCTION(NAME)  \
   jsi::Value NAME(               \
       jsi::Runtime &runtime,     \
-      const jsi::Value &thisVal, \
+      const jsi::Value &thisValue, \
       const jsi::Value *args,    \
       size_t count)
 

package/common/cpp/jsi/JsiPromise.h

@@ -5,6 +5,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <functional>
 
 namespace audioapi {
 

package/common/cpp/utils/AudioUtils.cpp

@@ -23,4 +23,11 @@ float linearInterpolate(
       factor * (source[secondIndex] - source[firstIndex]);
 }
 
+float linearToDecibels(float value) {
+  return 20 * log10f(value);
+}
+
+float decibelsToLinear(float value) {
+  return powf(10, value / 20);
+}
 } // namespace audioapi::AudioUtils

package/common/cpp/utils/AudioUtils.h

@@ -1,12 +1,16 @@
 #pragma once
 
 #include <cstddef>
+#include <cstdint>
+#include <cmath>
 
 namespace audioapi::AudioUtils {
-size_t timeToSampleFrame(double time, int sampleRate);
 
+size_t timeToSampleFrame(double time, int sampleRate);
 double sampleFrameToTime(int sampleFrame, int sampleRate);
 
 float linearInterpolate(const float *source, size_t firstIndex, size_t secondIndex, float factor);
 
+float linearToDecibels(float value);
+float decibelsToLinear(float value);
 } // namespace audioapi::AudioUtils

package/common/cpp/utils/FFTFrame.cpp

@@ -10,46 +10,92 @@
 
 namespace audioapi {
 #if defined(HAVE_ACCELERATE)
+static std::unordered_map<size_t, FFTSetup> fftSetups_;
 
-void FFTFrame::inverse(float *timeDomainData) {
-  FFTSetup fftSetup_ = vDSP_create_fftsetup(log2Size_, FFT_RADIX2);
-  DSPSplitComplex freqDomainData;
-  freqDomainData.realp = realData_;
-  freqDomainData.imagp = imaginaryData_;
+FFTFrame::FFTFrame(int size)
+    : size_(size),
+      log2Size_(static_cast<int>(log2(size))),
+      realData_(new float[size]),
+      imaginaryData_(new float[size]) {
+  fftSetup_ = getFFTSetupForSize(log2Size_);
+  frame_.realp = realData_;
+  frame_.imagp = imaginaryData_;
+}
+
+FFTFrame::~FFTFrame() {
+  delete[] realData_;
+  delete[] imaginaryData_;
+}
 
-  vDSP_fft_zrip(fftSetup_, &freqDomainData, 1, log2Size_, FFT_INVERSE);
-  vDSP_ztoc(
-      &freqDomainData,
-      1,
-      reinterpret_cast<DSPComplex *>(timeDomainData),
-      2,
-      size_ / 2);
+FFTSetup FFTFrame::getFFTSetupForSize(size_t log2FFTSize) {
+  if (!fftSetups_.contains(log2FFTSize)) {
+    fftSetups_.emplace(
+        log2FFTSize, vDSP_create_fftsetup(log2FFTSize, FFT_RADIX2));
+  }
+
+  return fftSetups_.at(log2FFTSize);
+}
+
+void FFTFrame::doFFT(float *data) {
+  vDSP_ctoz(reinterpret_cast<DSPComplex *>(data), 2, &frame_, 1, size_ / 2);
+  vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_FORWARD);
+
+  VectorMath::multiplyByScalar(realData_, 0.5f, realData_, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData_, 0.5f, imaginaryData_, size_ / 2);
+}
+
+void FFTFrame::doInverseFFT(float *data) {
+  vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_INVERSE);
+  vDSP_ztoc(&frame_, 1, reinterpret_cast<DSPComplex *>(data), 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_);
+      data, 1.0f / static_cast<float>(size_), data, size_);
 }
 
 #elif defined(ANDROID)
 
-void FFTFrame::inverse(float *timeDomainData) {
-  fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
+FFTFrame::FFTFrame(int size)
+    : size_(size),
+      log2Size_(static_cast<int>(log2(size))),
+      realData_(new float[size]),
+      imaginaryData_(new float[size]) {
+  frame_ = fftwf_alloc_complex(size / 2);
+}
+
+FFTFrame::~FFTFrame() {
+  delete[] realData_;
+  delete[] imaginaryData_;
+  fftwf_free(frame_);
+}
+
+void FFTFrame::doFFT(float *data) {
+  auto plan = fftwf_plan_dft_r2c_1d(size_, data, frame_, FFTW_ESTIMATE);
+  fftwf_execute(plan);
+  fftwf_destroy_plan(plan);
+
+  for (int i = 0; i < size_ / 2; ++i) {
+    realData_[i] = frame_[i][0];
+    imaginaryData_[i] = frame_[i][1];
+  }
+
+  VectorMath::multiplyByScalar(realData_, 0.5f, realData_, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData_, 0.5f, imaginaryData_, size_ / 2);
+}
+
+void FFTFrame::doInverseFFT(float *data) {
   for (int i = 0; i < size_ / 2; i++) {
-    freqDomainData[i][0] = realData_[i];
-    freqDomainData[i][1] = imaginaryData_[i];
+    frame_[i][0] = realData_[i];
+    frame_[i][1] = imaginaryData_[i];
   }
 
-  auto plan = fftwf_plan_dft_c2r_1d(
-      size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
+  auto plan = fftwf_plan_dft_c2r_1d(size_, frame_, data, FFTW_ESTIMATE);
   fftwf_execute(plan);
   fftwf_destroy_plan(plan);
-  fftwf_free(freqDomainData);
 
   VectorMath::multiplyByScalar(
-      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+      data, 1.0f / static_cast<float>(size_), data, size_);
 }
 
 #endif

package/common/cpp/utils/FFTFrame.h

@@ -31,22 +31,24 @@
 #include <algorithm>
 #include <cmath>
 #include <utility>
+#include <unordered_map>
 
 #include "VectorMath.h"
 
+#if defined(HAVE_ACCELERATE)
+#include <Accelerate/Accelerate.h>
+#endif
+
+#if defined(ANDROID)
+#include <fftw3.h>
+#endif
+
 namespace audioapi {
 
 class FFTFrame {
  public:
-  explicit FFTFrame(int size)
-      : size_(size),
-        log2Size_(static_cast<int>(log2(size))),
-        realData_(new float[size]),
-        imaginaryData_(new float[size]) {}
-  ~FFTFrame() {
-    delete[] realData_;
-    delete[] imaginaryData_;
-  }
+  explicit FFTFrame(int size);
+  ~FFTFrame();
 
   [[nodiscard]] float *getRealData() const {
     return realData_;
@@ -55,13 +57,26 @@ class FFTFrame {
     return imaginaryData_;
   }
 
-  void inverse(float *data);
+  void doFFT(float *data);
+
+  void doInverseFFT(float *data);
 
  private:
   int size_;
   int log2Size_;
   float *realData_;
   float *imaginaryData_;
+
+#if defined(HAVE_ACCELERATE)
+    FFTSetup fftSetup_;
+    DSPSplitComplex frame_;
+
+    static FFTSetup getFFTSetupForSize(size_t log2FFTSize);
+#endif
+
+#if defined(ANDROID)
+    fftwf_complex *frame_;
+#endif
 };
 
 } // namespace audioapi

package/common/cpp/utils/VectorMath.cpp

@@ -24,6 +24,7 @@
  */
 
 #include "VectorMath.h"
+#include "AudioUtils.h"
 
 #if defined(HAVE_ACCELERATE)
 #include <Accelerate/Accelerate.h>
@@ -691,4 +692,13 @@ void multiplyByScalarThenAddToOutput(
 }
 
 #endif
+
+void linearToDecibels(
+    const float *inputVector,
+    float *outputVector,
+    size_t numberOfElementsToProcess) {
+  for (int i = 0; i < numberOfElementsToProcess; i++) {
+    outputVector[i] = AudioUtils::linearToDecibels(inputVector[i]);
+  }
+}
 } // namespace audioapi::VectorMath

package/common/cpp/utils/VectorMath.h

@@ -42,4 +42,6 @@ void multiply(const float *inputVector1, const float *inputVector2, float *outpu
 
 // Finds the maximum magnitude of a float vector.
 float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess);
+
+void linearToDecibels(const float *inputVector, float *outputVector, size_t numberOfElementsToProcess);
 } // namespace audioapi::VectorMath

package/ios/core/AudioPlayer.h

@@ -12,12 +12,13 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 @property (nonatomic, strong) AVAudioFormat *format;
 @property (nonatomic, strong) AVAudioSourceNode *sourceNode;
 @property (nonatomic, copy) RenderAudioBlock renderAudio;
+@property (nonatomic, assign) int sampleRate;
 
 - (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio;
 
-- (int)getSampleRate;
+- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio sampleRate:(int)sampleRate;
 
-- (int)getBufferSizeInFrames;
+- (int)getSampleRate;
 
 - (void)start;