Allow larger arrays up to size 8192 for PeriodicWave

Source/modules/webaudio/PeriodicWave.cpp

 /*
  * Copyright (C) 2012 Google 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
@@ skipping 19 matching lines @@
 #if ENABLE(WEB_AUDIO)
 #include "modules/webaudio/PeriodicWave.h"
 
 #include "modules/webaudio/OscillatorNode.h"
 #include "platform/audio/FFTFrame.h"
 #include "platform/audio/VectorMath.h"
 #include <algorithm>
 
 namespace blink {
 
-const unsigned PeriodicWaveSize = 4096; // This must be a power of two.
-const unsigned NumberOfRanges = 36; // There should be 3 * log2(PeriodicWaveSize) 1/3 octave ranges.
-const float CentsPerRange = 1200 / 3; // 1/3 Octave.
+// The number of bands per octave.  Each octave will have this many entries in the wave tables.
+const unsigned kNumberOfOctaveBands = 3;
 
-const unsigned PeriodicWave::kMaxPeriodicWaveArraySize = PeriodicWaveSize / 2;
+// The max length of a periodic wave. This must be a power of two greater than or equal to 2048 and
+// must be supported by the FFT routines.
+const unsigned kMaxPeriodicWaveSize = 16384;
+
+const float CentsPerRange = 1200 / kNumberOfOctaveBands;
 
 using namespace VectorMath;
 
 PeriodicWave* PeriodicWave::create(float sampleRate, DOMFloat32Array* real, DOMFloat32Array* imag)
 {
     bool isGood = real && imag && real->length() == imag->length();
     ASSERT(isGood);
     if (isGood) {
         PeriodicWave* periodicWave = new PeriodicWave(sampleRate);
         size_t numberOfComponents = real->length();
@@ skipping 26 matching lines @@
 
 PeriodicWave* PeriodicWave::createTriangle(float sampleRate)
 {
     PeriodicWave* periodicWave = new PeriodicWave(sampleRate);
     periodicWave->generateBasicWaveform(OscillatorHandler::TRIANGLE);
     return periodicWave;
 }
 
 PeriodicWave::PeriodicWave(float sampleRate)
     : m_sampleRate(sampleRate)
-    , m_periodicWaveSize(PeriodicWaveSize)
-    , m_numberOfRanges(NumberOfRanges)
     , m_centsPerRange(CentsPerRange)
 {
     float nyquist = 0.5 * m_sampleRate;
     m_lowestFundamentalFrequency = nyquist / maxNumberOfPartials();
-    m_rateScale = m_periodicWaveSize / m_sampleRate;
+    m_rateScale = periodicWaveSize() / m_sampleRate;
+    // Compute the number of ranges needed to cover the entire frequency range, assuming
+    // kNumberOfOctaveBands per octave.
+    m_numberOfRanges = 0.5 + kNumberOfOctaveBands * log2f(periodicWaveSize());
+}
+
+unsigned PeriodicWave::periodicWaveSize() const
+{
+    // Choose an appropriate wave size for the given sample rate.  This allows us to use shorter
+    // FFTs when possible to limit the complexity.  The breakpoints here are somewhat arbitrary, but
+    // we want sample rates around 44.1 kHz or so to have a size of 4096 to preserve backward
+    // compatibility.
+    if (m_sampleRate <= 24000) {
+        return 2048;
+    }
+
+    if (m_sampleRate <= 88200) {
+        return 4096;
+    }
+
+    return kMaxPeriodicWaveSize;
+}
+
+unsigned PeriodicWave::maxNumberOfPartials() const
+{
+    return periodicWaveSize() / 2;
 }
 
 void PeriodicWave::waveDataForFundamentalFrequency(float fundamentalFrequency, float*& lowerWaveData, float*& higherWaveData, float& tableInterpolationFactor)
 {
     // Negative frequencies are allowed, in which case we alias to the positive frequency.
     fundamentalFrequency = fabsf(fundamentalFrequency);
 
     // Calculate the pitch range.
     float ratio = fundamentalFrequency > 0 ? fundamentalFrequency / m_lowestFundamentalFrequency : 0.5;
     float centsAboveLowestFrequency = log2f(ratio) * 1200;
 
     // Add one to round-up to the next range just in time to truncate partials before aliasing occurs.
     float pitchRange = 1 + centsAboveLowestFrequency / m_centsPerRange;
 
     pitchRange = std::max(pitchRange, 0.0f);
-    pitchRange = std::min(pitchRange, static_cast<float>(m_numberOfRanges - 1));
+    pitchRange = std::min(pitchRange, static_cast<float>(numberOfRanges() - 1));
 
     // The words "lower" and "higher" refer to the table data having the lower and higher numbers of partials.
     // It's a little confusing since the range index gets larger the more partials we cull out.
     // So the lower table data will have a larger range index.
     unsigned rangeIndex1 = static_cast<unsigned>(pitchRange);
-    unsigned rangeIndex2 = rangeIndex1 < m_numberOfRanges - 1 ? rangeIndex1 + 1 : rangeIndex1;
+    unsigned rangeIndex2 = rangeIndex1 < numberOfRanges() - 1 ? rangeIndex1 + 1 : rangeIndex1;
 
     lowerWaveData = m_bandLimitedTables[rangeIndex2]->data();
     higherWaveData = m_bandLimitedTables[rangeIndex1]->data();
 
     // Ranges from 0 -> 1 to interpolate between lower -> higher.
     tableInterpolationFactor = pitchRange - rangeIndex1;
 }
 
-unsigned PeriodicWave::maxNumberOfPartials() const
-{
-    return m_periodicWaveSize / 2;
-}
-
 unsigned PeriodicWave::numberOfPartialsForRange(unsigned rangeIndex) const
 {
     // Number of cents below nyquist where we cull partials.
     float centsToCull = rangeIndex * m_centsPerRange;
 
     // A value from 0 -> 1 representing what fraction of the partials to keep.
     float cullingScale = pow(2, -centsToCull / 1200);
 
     // The very top range will have all the partials culled.
     unsigned numberOfPartials = cullingScale * maxNumberOfPartials();
 
     return numberOfPartials;
 }
 
 // Convert into time-domain wave buffers.
 // One table is created for each range for non-aliasing playback at different playback rates.
 // Thus, higher ranges have more high-frequency partials culled out.
 void PeriodicWave::createBandLimitedTables(const float* realData, const float* imagData, unsigned numberOfComponents)
 {
     float normalizationScale = 1;
 
-    unsigned fftSize = m_periodicWaveSize;
+    unsigned fftSize = periodicWaveSize();
     unsigned halfSize = fftSize / 2;
     unsigned i;
 
     numberOfComponents = std::min(numberOfComponents, halfSize);
 
-    m_bandLimitedTables.reserveCapacity(m_numberOfRanges);
+    m_bandLimitedTables.reserveCapacity(numberOfRanges());
 
-    for (unsigned rangeIndex = 0; rangeIndex < m_numberOfRanges; ++rangeIndex) {
+    for (unsigned rangeIndex = 0; rangeIndex < numberOfRanges(); ++rangeIndex) {
         // This FFTFrame is used to cull partials (represented by frequency bins).
         FFTFrame frame(fftSize);
         float* realP = frame.realData();
         float* imagP = frame.imagData();
 
-        // Copy from loaded frequency data and scale.
-        float scale = fftSize;
-        vsmul(realData, 1, &scale, realP, 1, numberOfComponents);
-        vsmul(imagData, 1, &scale, imagP, 1, numberOfComponents);
+        // Copy from loaded frequency data and generate the complex conjugate because of the way the
+        // inverse FFT is defined versus the values in the arrays.  Note also that although the IFFT
+        // does a scaling by 1/N, we take care of this when the normalization scaling is done.
+        float minusOne = -1;
+        memcpy(realP, realData, numberOfComponents * sizeof(*realP));
+        vsmul(imagData, 1, &minusOne, imagP, 1, numberOfComponents);
+
+        // Find the starting bin where we should start culling.  We need to clear out the highest
+        // frequencies to band-limit the waveform.
+        unsigned numberOfPartials = numberOfPartialsForRange(rangeIndex);
 
         // If fewer components were provided than 1/2 FFT size, then clear the remaining bins.
-        for (i = numberOfComponents; i < halfSize; ++i) {
+        // We also need to cull the aliasing partials for this pitch range.
+        for (i = std::min(numberOfComponents, numberOfPartials + 1); i < halfSize; ++i) {
             realP[i] = 0;
             imagP[i] = 0;
         }
 
-        // Generate complex conjugate because of the way the inverse FFT is defined.
-        float minusOne = -1;
-        vsmul(imagP, 1, &minusOne, imagP, 1, halfSize);
-
-        // Find the starting bin where we should start culling.
-        // We need to clear out the highest frequencies to band-limit the waveform.
-        unsigned numberOfPartials = numberOfPartialsForRange(rangeIndex);
-
-        // Cull the aliasing partials for this pitch range.
-        for (i = numberOfPartials + 1; i < halfSize; ++i) {
-            realP[i] = 0;
-            imagP[i] = 0;
-        }
-        // Clear packed-nyquist if necessary.
-        if (numberOfPartials < halfSize)
-            imagP[0] = 0;
-
-        // Clear any DC-offset.
+        // Clear packed-nyquist and any DC-offset.
         realP[0] = 0;
+        imagP[0] = 0;
 
         // Create the band-limited table.
-        OwnPtr<AudioFloatArray> table = adoptPtr(new AudioFloatArray(m_periodicWaveSize));
+        OwnPtr<AudioFloatArray> table = adoptPtr(new AudioFloatArray(periodicWaveSize()));
         m_bandLimitedTables.append(table.release());

[hongchan, 2015/07/22 22:30:32]

I am aware that it is not a critical or relevant change in this CL, but do we
need adoptPtr/OwnPtr/.release() thing here?
I believe PeriodicWave is covered by Oilpan already. (GarbageCollectedFinalized)

It seems that the code here is creating an object and pass the ownership to
|m_bandLimitedtables|.

[Raymond Toy, 2015/07/23 18:23:05]

Despite what I said (offline), I don't want to do that here.  It should be a
separate CL to isolate the two independent changes.

 
         // Apply an inverse FFT to generate the time-domain table data.
         float* data = m_bandLimitedTables[rangeIndex]->data();
         frame.doInverseFFT(data);
 
         // For the first range (which has the highest power), calculate its peak value then compute normalization scale.
         if (!rangeIndex) {
             float maxValue;
-            vmaxmgv(data, 1, &maxValue, m_periodicWaveSize);
+            vmaxmgv(data, 1, &maxValue, fftSize);
 
             if (maxValue)
                 normalizationScale = 1.0f / maxValue;
         }
 
         // Apply normalization scale.
-        vsmul(data, 1, &normalizationScale, data, 1, m_periodicWaveSize);
+        vsmul(data, 1, &normalizationScale, data, 1, fftSize);
     }
 }
 
 void PeriodicWave::generateBasicWaveform(int shape)
 {
     unsigned fftSize = periodicWaveSize();
     unsigned halfSize = fftSize / 2;
 
     AudioFloatArray real(halfSize);
     AudioFloatArray imag(halfSize);
@@ skipping 67 matching lines @@
         realP[n] = 0;
         imagP[n] = b;
     }
 
     createBandLimitedTables(realP, imagP, halfSize);
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)