react-native-audio-api 0.4.8-rc2 → 0.4.9

package/android/src/main/cpp/libs/pffft.h

@@ -0,0 +1,198 @@
+/* Copyright (c) 2013  Julien Pommier ( pommier@modartt.com )
+
+   Based on original fortran 77 code from FFTPACKv4 from NETLIB,
+   authored by Dr Paul Swarztrauber of NCAR, in 1985.
+
+   As confirmed by the NCAR fftpack software curators, the following
+   FFTPACKv5 license applies to FFTPACKv4 sources. My changes are
+   released under the same terms.
+
+   FFTPACK license:
+
+   http://www.cisl.ucar.edu/css/software/fftpack5/ftpk.html
+
+   Copyright (c) 2004 the University Corporation for Atmospheric
+   Research ("UCAR"). All rights reserved. Developed by NCAR's
+   Computational and Information Systems Laboratory, UCAR,
+   www.cisl.ucar.edu.
+
+   Redistribution and use of the Software in source and binary forms,
+   with or without modification, is permitted provided that the
+   following conditions are met:
+
+   - Neither the names of NCAR's Computational and Information Systems
+   Laboratory, the University Corporation for Atmospheric Research,
+   nor the names of its sponsors or contributors may be used to
+   endorse or promote products derived from this Software without
+   specific prior written permission.
+
+   - Redistributions of source code must retain the above copyright
+   notices, this list of conditions, and the disclaimer below.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions, and the disclaimer below in the
+   documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+   SOFTWARE.
+*/
+
+/*
+  PFFFT : a Pretty Fast FFT.
+
+  This is basically an adaptation of the single precision fftpack
+  (v4) as found on netlib taking advantage of SIMD instruction found
+  on cpus such as intel x86 (SSE1), powerpc (Altivec), and arm (NEON).
+
+  For architectures where no SIMD instruction is available, the code
+  falls back to a scalar version.
+
+  Restrictions:
+
+  - 1D transforms only, with 32-bit single precision.
+
+  - supports only transforms for inputs of length N of the form
+  N=(2^a)*(3^b)*(5^c), a >= 5, b >=0, c >= 0 (32, 48, 64, 96, 128,
+  144, 160, etc are all acceptable lengths). Performance is best for
+  128<=N<=8192.
+
+  - all (float*) pointers in the functions below are expected to
+  have an "simd-compatible" alignment, that is 16 bytes on x86 and
+  powerpc CPUs.
+
+  You can allocate such buffers with the functions
+  pffft_aligned_malloc / pffft_aligned_free (or with stuff like
+  posix_memalign..)
+
+*/
+
+#pragma once
+
+#include <stddef.h> // for size_t
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   Opaque struct holding internal stuff (precomputed twiddle factors)
+   this struct can be shared by many threads as it contains only
+   read-only data.
+*/
+typedef struct PFFFT_Setup PFFFT_Setup;
+
+/** Direction of the transform */
+typedef enum { PFFFT_FORWARD, PFFFT_BACKWARD } pffft_direction_t;
+
+/** Type of transform */
+typedef enum { PFFFT_REAL, PFFFT_COMPLEX } pffft_transform_t;
+
+/**
+  Prepare for performing transforms of size N -- the returned
+  PFFFT_Setup structure is read-only so it can safely be shared by
+  multiple concurrent threads.
+
+  Will return NULL if N is not suitable (too large / no decomposable with simple
+  integer factors..)
+*/
+PFFFT_Setup *pffft_new_setup(int N, pffft_transform_t transform);
+void pffft_destroy_setup(PFFFT_Setup *);
+/**
+  Perform a Fourier transform , The z-domain data is stored in the
+  most efficient order for transforming it back, or using it for
+  convolution. If you need to have its content sorted in the
+  "usual" way, that is as an array of interleaved complex numbers,
+  either use pffft_transform_ordered , or call pffft_zreorder after
+  the forward fft, and before the backward fft.
+
+  Transforms are not scaled: PFFFT_BACKWARD(PFFFT_FORWARD(x)) = N*x.
+  Typically you will want to scale the backward transform by 1/N.
+
+  The 'work' pointer should point to an area of N (2*N for complex
+  fft) floats, properly aligned. If 'work' is NULL, then stack will
+  be used instead (this is probably the best strategy for small
+  FFTs, say for N < 16384).
+
+  input and output may alias.
+*/
+void pffft_transform(
+    PFFFT_Setup *setup,
+    const float *input,
+    float *output,
+    float *work,
+    pffft_direction_t direction);
+
+/**
+  Similar to pffft_transform, but makes sure that the output is
+  ordered as expected (interleaved complex numbers).  This is
+  similar to calling pffft_transform and then pffft_zreorder.
+
+  input and output may alias.
+*/
+void pffft_transform_ordered(
+    PFFFT_Setup *setup,
+    const float *input,
+    float *output,
+    float *work,
+    pffft_direction_t direction);
+
+/**
+  call pffft_zreorder(.., PFFFT_FORWARD) after pffft_transform(...,
+  PFFFT_FORWARD) if you want to have the frequency components in
+  the correct "canonical" order, as interleaved complex numbers.
+
+  (for real transforms, both 0-frequency and half frequency
+  components, which are real, are assembled in the first entry as
+  F(0)+i*F(n/2+1). Note that the original fftpack did place
+  F(n/2+1) at the end of the arrays).
+
+  input and output should not alias.
+*/
+void pffft_zreorder(
+    PFFFT_Setup *setup,
+    const float *input,
+    float *output,
+    pffft_direction_t direction);
+
+/**
+  Perform a multiplication of the frequency components of dft_a and
+  dft_b and accumulate them into dft_ab. The arrays should have
+  been obtained with pffft_transform(.., PFFFT_FORWARD) and should
+  *not* have been reordered with pffft_zreorder (otherwise just
+  perform the operation yourself as the dft coefs are stored as
+  interleaved complex numbers).
+
+  the operation performed is: dft_ab += (dft_a * fdt_b)*scaling
+
+  The dft_a, dft_b and dft_ab pointers may alias.
+*/
+void pffft_zconvolve_accumulate(
+    PFFFT_Setup *setup,
+    const float *dft_a,
+    const float *dft_b,
+    float *dft_ab,
+    float scaling);
+
+/**
+  the float buffers must have the correct alignment (16-byte boundary
+  on intel and powerpc). This function may be used to obtain such
+  correctly aligned buffers.
+*/
+void *pffft_aligned_malloc(size_t nb_bytes);
+void pffft_aligned_free(void *);
+
+/** return 4 or 1 wether support SSE/Altivec instructions was enable when
+ * building pffft.c */
+int pffft_simd_size(void);
+
+#ifdef __cplusplus
+}
+#endif

package/common/cpp/core/AnalyserNode.cpp

@@ -21,9 +21,11 @@ AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
   inputBuffer_ = std::make_unique<AudioArray>(MAX_FFT_SIZE * 2);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
   downMixBus_ = std::make_unique<AudioBus>(
-      context_->getSampleRate(), RENDER_QUANTUM_SIZE, 1);
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  realData_ = std::make_shared<AudioArray>(fftSize_);
+  imaginaryData_ = std::make_shared<AudioArray>(fftSize_);
 
   isInitialized_ = true;
 }
@@ -59,6 +61,8 @@ void AnalyserNode::setFftSize(int fftSize) {
 
   fftSize_ = fftSize;
   fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  realData_ = std::make_shared<AudioArray>(fftSize_);
+  imaginaryData_ = std::make_shared<AudioArray>(fftSize_);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
 }
 
@@ -145,14 +149,10 @@ void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
 void AnalyserNode::processNode(
     audioapi::AudioBus *processingBus,
     int framesToProcess) {
-  if (!isInitialized_) {
-    processingBus->zero();
-    return;
-  }
-
   // Analyser should behave like a sniffer node, it should not modify the
   // processingBus but instead copy the data to its own input buffer.
 
+  // Down mix the input bus to mono
   downMixBus_->copy(processingBus);
 
   if (vWriteIndex_ + framesToProcess > inputBuffer_->getSize()) {
@@ -215,11 +215,12 @@ void AnalyserNode::doFFTAnalysis() {
       break;
   }
 
-  // do fft analysis - get frequency domain data
-  fftFrame_->doFFT(tempBuffer.getData());
+  auto *realFFTFrameData = realData_->getData();
+  auto *imaginaryFFTFrameData = imaginaryData_->getData();
 
-  auto *realFFTFrameData = fftFrame_->getRealData();
-  auto *imaginaryFFTFrameData = fftFrame_->getImaginaryData();
+  // do fft analysis - get frequency domain data
+  fftFrame_->doFFT(
+      tempBuffer.getData(), realFFTFrameData, imaginaryFFTFrameData);
 
   // Zero out nquist component
   imaginaryFFTFrameData[0] = 0.0f;

package/common/cpp/core/AnalyserNode.h

@@ -50,6 +50,8 @@ class AnalyserNode : public AudioNode {
   int vWriteIndex_;
 
   std::unique_ptr<FFTFrame> fftFrame_;
+  std::shared_ptr<AudioArray> realData_;
+  std::shared_ptr<AudioArray> imaginaryData_;
   std::unique_ptr<AudioArray> magnitudeBuffer_;
   bool shouldDoFFTAnalysis_ { true };
 

package/common/cpp/core/AudioBuffer.cpp

@@ -8,7 +8,7 @@ AudioBuffer::AudioBuffer(
     int numberOfChannels,
     size_t length,
     float sampleRate) {
-  bus_ = std::make_shared<AudioBus>(sampleRate, length, numberOfChannels);
+  bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
 }
 
 AudioBuffer::AudioBuffer(AudioBus *bus) {

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <cassert>
 
 #include "AudioArray.h"
 #include "AudioBufferSourceNode.h"
@@ -17,7 +18,8 @@ AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
       loopEnd_(0),
       vReadIndex_(0.0) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
-  alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
+  alignedBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   detuneParam_ = std::make_shared<AudioParam>(0.0, MIN_DETUNE, MAX_DETUNE);
   playbackRateParam_ = std::make_shared<AudioParam>(
@@ -67,26 +69,33 @@ void AudioBufferSourceNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer) {
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
-    alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
+    alignedBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
     loopEnd_ = 0;
     return;
   }
 
   buffer_ = buffer;
-  alignedBus_ = std::make_shared<AudioBus>(
-      context_->getSampleRate(),
-      buffer_->getLength(),
-      buffer_->getNumberOfChannels());
+  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());
+
   loopEnd_ = buffer_->getDuration();
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
   AudioScheduledSourceNode::start(when);
 
+  if (duration > 0) {
+    AudioScheduledSourceNode::stop(when + duration);
+  }
+
   if (!buffer_) {
     return;
   }
@@ -98,29 +107,30 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
   }
 
   vReadIndex_ = static_cast<double>(buffer_->getSampleRate() * offset);
-
-  if (duration > 0) {
-    AudioScheduledSourceNode::stop(when + duration);
-  }
 }
 
 void AudioBufferSourceNode::processNode(
     AudioBus *processingBus,
     int framesToProcess) {
+  // No audio data to fill, zero the output and return.
+  if (!buffer_) {
+    processingBus->zero();
+    return;
+  }
+
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
   float playbackRate = getPlaybackRateValue(startOffset);
 
-  // No audio data to fill, zero the output and return.
-  if (!isPlaying() || !alignedBus_ || alignedBus_->getSize() == 0 ||
-      playbackRate == 0.0f) {
+  assert(alignedBus_ != nullptr);
+  assert(alignedBus_->getSize() > 0);
+
+  if (playbackRate == 0.0f || !isPlaying()) {
     processingBus->zero();
     return;
-  }
-
-  if (std::fabs(playbackRate) == 1.0) {
+  } else if (std::fabs(playbackRate) == 1.0) {
     processWithoutInterpolation(
         processingBus, startOffset, offsetLength, playbackRate);
   } else {

package/common/cpp/core/AudioBus.cpp

@@ -18,7 +18,7 @@ namespace audioapi {
  * Public interfaces - memory management
  */
 
-AudioBus::AudioBus(float sampleRate, size_t size, int numberOfChannels)
+AudioBus::AudioBus(size_t size, int numberOfChannels, float sampleRate)
     : numberOfChannels_(numberOfChannels),
       sampleRate_(sampleRate),
       size_(size) {
@@ -161,19 +161,26 @@ float AudioBus::maxAbsValue() const {
   return maxAbsValue;
 }
 
-void AudioBus::sum(const AudioBus *source) {
-  sum(source, 0, 0, getSize());
+void AudioBus::sum(
+    const AudioBus *source,
+    ChannelInterpretation interpretation) {
+  sum(source, 0, 0, getSize(), interpretation);
 }
 
-void AudioBus::sum(const AudioBus *source, size_t start, size_t length) {
-  sum(source, start, start, length);
+void AudioBus::sum(
+    const AudioBus *source,
+    size_t start,
+    size_t length,
+    ChannelInterpretation interpretation) {
+  sum(source, start, start, length, interpretation);
 }
 
 void AudioBus::sum(
     const AudioBus *source,
     size_t sourceStart,
     size_t destinationStart,
-    size_t length) {
+    size_t length,
+    ChannelInterpretation interpretation) {
   if (source == this) {
     return;
   }
@@ -181,9 +188,12 @@ void AudioBus::sum(
   int numberOfSourceChannels = source->getNumberOfChannels();
   int numberOfChannels = getNumberOfChannels();
 
-  // TODO: consider adding ability to enforce discrete summing (if/when it will
-  // be useful). Source channel count is smaller than current bus, we need to
-  // up-mix.
+  if (interpretation == ChannelInterpretation::DISCRETE) {
+    discreteSum(source, sourceStart, destinationStart, length);
+    return;
+  }
+
+  // Source channel count is smaller than current bus, we need to up-mix.
   if (numberOfSourceChannels < numberOfChannels) {
     sumByUpMixing(source, sourceStart, destinationStart, length);
     return;
@@ -373,8 +383,9 @@ void AudioBus::sumByDownMixing(
     return;
   }
 
-  // Stereo 4 to mono: output += 0.25 * (input.left + input.right +
-  // input.surroundLeft + input.surroundRight)
+  // Stereo 4 to mono (4 -> 1):
+  // output += 0.25 * (input.left + input.right + input.surroundLeft +
+  // input.surroundRight)
   if (numberOfSourceChannels == 4 && numberOfChannels == 1) {
     float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
     float *sourceRight = source->getChannelByType(ChannelRight)->getData();
@@ -408,7 +419,88 @@ void AudioBus::sumByDownMixing(
     return;
   }
 
-  // 5.1 to stereo:
+  // 5.1 to mono (6 -> 1):
+  // output += sqrt(1/2) * (input.left + input.right) + input.center + 0.5 *
+  // (input.surroundLeft + input.surroundRight)
+  if (numberOfSourceChannels == 6 && numberOfChannels == 1) {
+    float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
+    float *sourceRight = source->getChannelByType(ChannelRight)->getData();
+    float *sourceCenter = source->getChannelByType(ChannelCenter)->getData();
+    float *sourceSurroundLeft =
+        source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight =
+        source->getChannelByType(ChannelSurroundRight)->getData();
+
+    float *destinationData = getChannelByType(ChannelMono)->getData();
+
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceLeft + sourceStart,
+        SQRT_HALF,
+        destinationData + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceRight + sourceStart,
+        SQRT_HALF,
+        destinationData + destinationStart,
+        length);
+    VectorMath::add(
+        sourceCenter + sourceStart,
+        destinationData + destinationStart,
+        destinationData + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundLeft + sourceStart,
+        0.5f,
+        destinationData + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundRight + sourceStart,
+        0.5f,
+        destinationData + destinationStart,
+        length);
+
+    return;
+  }
+
+  // Stereo 4 to stereo 2 (4 -> 2):
+  // output.left += 0.5 * (input.left +  input.surroundLeft)
+  // output.right += 0.5 * (input.right + input.surroundRight)
+  if (numberOfSourceChannels == 4 && numberOfChannels == 2) {
+    float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
+    float *sourceRight = source->getChannelByType(ChannelRight)->getData();
+    float *sourceSurroundLeft =
+        source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight =
+        source->getChannelByType(ChannelSurroundRight)->getData();
+
+    float *destinationLeft = getChannelByType(ChannelLeft)->getData();
+    float *destinationRight = getChannelByType(ChannelRight)->getData();
+
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceLeft + sourceStart,
+        0.5f,
+        destinationLeft + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundLeft + sourceStart,
+        0.5f,
+        destinationLeft + destinationStart,
+        length);
+
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceRight + sourceStart,
+        0.5f,
+        destinationRight + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundRight + sourceStart,
+        0.5f,
+        destinationRight + destinationStart,
+        length);
+    return;
+  }
+
+  // 5.1 to stereo (6 -> 2):
   // output.left += input.left + sqrt(1/2) * (input.center + input.surroundLeft)
   // output.right += input.right + sqrt(1/2) * (input.center +
   // input.surroundRight)
@@ -458,7 +550,7 @@ void AudioBus::sumByDownMixing(
     return;
   }
 
-  // 5.1 to stereo 4:
+  // 5.1 to stereo 4 (6 -> 4):
   // output.left += input.left + sqrt(1/2) * input.center
   // output.right += input.right + sqrt(1/2) * input.center
   // output.surroundLeft += input.surroundLeft

package/common/cpp/core/AudioBus.h

@@ -5,6 +5,8 @@
 #include <vector>
 #include <cstddef>
 
+#include "ChannelInterpretation.h"
+
 namespace audioapi {
 
 class BaseAudioContext;
@@ -22,7 +24,7 @@ class AudioBus {
     ChannelSurroundRight = 5,
   };
 
-  explicit AudioBus(float sampleRate, size_t size, int numberOfChannels);
+  explicit AudioBus(size_t size, int numberOfChannels, float sampleRate);
 
   ~AudioBus();
 
@@ -39,13 +41,13 @@ class AudioBus {
   void zero();
   void zero(size_t start, size_t length);
 
-  void sum(const AudioBus *source);
-  void sum(const AudioBus *source, size_t start, size_t length);
+  void sum(const AudioBus *source, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
+  void sum(const AudioBus *source, size_t start, size_t length, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
   void sum(
       const AudioBus *source,
       size_t sourceStart,
       size_t destinationStart,
-      size_t length);
+      size_t length, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
 
   void copy(const AudioBus *source);
   void copy(const AudioBus *source, size_t start, size_t length);

package/common/cpp/core/AudioContext.cpp

@@ -7,6 +7,7 @@
 #include "AudioContext.h"
 #include "AudioDecoder.h"
 #include "AudioDestinationNode.h"
+#include "AudioNodeManager.h"
 
 namespace audioapi {
 AudioContext::AudioContext() : BaseAudioContext() {
@@ -35,11 +36,11 @@ AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
 }
 
 AudioContext::~AudioContext() {
-  if (isClosed()) {
-    return;
+  if (!isClosed()) {
+    close();
   }
 
-  close();
+  nodeManager_->cleanup();
 }
 
 void AudioContext::close() {

package/common/cpp/core/AudioContext.h

@@ -20,14 +20,14 @@ class AudioContext : public BaseAudioContext {
 
   void close();
 
-  std::function<void(AudioBus *, int)> renderAudio();
-
  private:
 #ifdef ANDROID
-    std::shared_ptr<AudioPlayer> audioPlayer_;
+  std::shared_ptr<AudioPlayer> audioPlayer_;
 #else
-    std::shared_ptr<IOSAudioPlayer> audioPlayer_;
+  std::shared_ptr<IOSAudioPlayer> audioPlayer_;
 #endif
+
+  std::function<void(AudioBus *, int)> renderAudio();
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -3,14 +3,13 @@
 #include "AudioNode.h"
 #include "AudioNodeManager.h"
 #include "BaseAudioContext.h"
-#include "VectorMath.h"
 
 namespace audioapi {
 
 AudioDestinationNode::AudioDestinationNode(BaseAudioContext *context)
     : AudioNode(context), currentSampleFrame_(0) {
   numberOfOutputs_ = 0;
-  numberOfInputs_ = INT_MAX;
+  numberOfInputs_ = 1;
   channelCountMode_ = ChannelCountMode::EXPLICIT;
   isInitialized_ = true;
 }
@@ -26,7 +25,7 @@ double AudioDestinationNode::getCurrentTime() const {
 void AudioDestinationNode::renderAudio(
     AudioBus *destinationBus,
     int numFrames) {
-  if (!numFrames || !destinationBus || !isInitialized_) {
+  if (numFrames < 0 || !destinationBus || !isInitialized_) {
     return;
   }