WaveTable name has changed to PeriodicWave

Source/modules/webaudio/OscillatorNode.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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 15 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 
 #include "modules/webaudio/OscillatorNode.h"
 
 #include "core/dom/ExceptionCode.h"
 #include "core/platform/audio/AudioUtilities.h"
 #include "core/platform/audio/VectorMath.h"
 #include "modules/webaudio/AudioContext.h"
 #include "modules/webaudio/AudioNodeOutput.h"
-#include "modules/webaudio/WaveTable.h"
+#include "modules/webaudio/PeriodicWave.h"
 #include <algorithm>
 #include "wtf/MathExtras.h"
 
 using namespace std;
 
 namespace WebCore {
 
 using namespace VectorMath;
 
-WaveTable* OscillatorNode::s_waveTableSine = 0;
-WaveTable* OscillatorNode::s_waveTableSquare = 0;
-WaveTable* OscillatorNode::s_waveTableSawtooth = 0;
-WaveTable* OscillatorNode::s_waveTableTriangle = 0;
+PeriodicWave* OscillatorNode::s_periodicWaveSine = 0;
+PeriodicWave* OscillatorNode::s_periodicWaveSquare = 0;
+PeriodicWave* OscillatorNode::s_periodicWaveSawtooth = 0;
+PeriodicWave* OscillatorNode::s_periodicWaveTriangle = 0;
 
 PassRefPtr<OscillatorNode> OscillatorNode::create(AudioContext* context, float sampleRate)
 {
     return adoptRef(new OscillatorNode(context, sampleRate));
 }
 
 OscillatorNode::OscillatorNode(AudioContext* context, float sampleRate)
     : AudioScheduledSourceNode(context, sampleRate)
     , m_type(SINE)
     , m_firstRender(true)
@@ skipping 51 matching lines @@
     else if (type == "sawtooth")
         setType(SAWTOOTH);
     else if (type == "triangle")
         setType(TRIANGLE);
     else
         ASSERT_NOT_REACHED();
 }
 
 bool OscillatorNode::setType(unsigned type)
 {
-    WaveTable* waveTable = 0;
+    PeriodicWave* periodicWave = 0;
     float sampleRate = this->sampleRate();
 
     switch (type) {
     case SINE:
-        if (!s_waveTableSine)
-            s_waveTableSine = WaveTable::createSine(sampleRate).leakRef();
-        waveTable = s_waveTableSine;
+        if (!s_periodicWaveSine)
+            s_periodicWaveSine = PeriodicWave::createSine(sampleRate).leakRef();
+        periodicWave = s_periodicWaveSine;
         break;
     case SQUARE:
-        if (!s_waveTableSquare)
-            s_waveTableSquare = WaveTable::createSquare(sampleRate).leakRef();
-        waveTable = s_waveTableSquare;
+        if (!s_periodicWaveSquare)
+            s_periodicWaveSquare = PeriodicWave::createSquare(sampleRate).leakRef();
+        periodicWave = s_periodicWaveSquare;
         break;
     case SAWTOOTH:
-        if (!s_waveTableSawtooth)
-            s_waveTableSawtooth = WaveTable::createSawtooth(sampleRate).leakRef();
-        waveTable = s_waveTableSawtooth;
+        if (!s_periodicWaveSawtooth)
+            s_periodicWaveSawtooth = PeriodicWave::createSawtooth(sampleRate).leakRef();
+        periodicWave = s_periodicWaveSawtooth;
         break;
     case TRIANGLE:
-        if (!s_waveTableTriangle)
-            s_waveTableTriangle = WaveTable::createTriangle(sampleRate).leakRef();
-        waveTable = s_waveTableTriangle;
+        if (!s_periodicWaveTriangle)
+            s_periodicWaveTriangle = PeriodicWave::createTriangle(sampleRate).leakRef();
+        periodicWave = s_periodicWaveTriangle;
         break;
     case CUSTOM:
     default:
-        // Return error for invalid types, including CUSTOM since setWaveTable() method must be
+        // Return error for invalid types, including CUSTOM since setPeriodicWave() method must be
         // called explicitly.
         return false;
     }
 
-    setWaveTable(waveTable);
+    setPeriodicWave(periodicWave);
     m_type = type;
     return true;
 }
 
 bool OscillatorNode::calculateSampleAccuratePhaseIncrements(size_t framesToProcess)
 {
     bool isGood = framesToProcess <= m_phaseIncrements.size() && framesToProcess <= m_detuneValues.size();
     ASSERT(isGood);
     if (!isGood)
         return false;
 
     if (m_firstRender) {
         m_firstRender = false;
         m_frequency->resetSmoothedValue();
         m_detune->resetSmoothedValue();
     }
 
     bool hasSampleAccurateValues = false;
     bool hasFrequencyChanges = false;
     float* phaseIncrements = m_phaseIncrements.data();
 
-    float finalScale = m_waveTable->rateScale();
+    float finalScale = m_periodicWave->rateScale();
 
     if (m_frequency->hasSampleAccurateValues()) {
         hasSampleAccurateValues = true;
         hasFrequencyChanges = true;
 
         // Get the sample-accurate frequency values and convert to phase increments.
         // They will be converted to phase increments below.
         m_frequency->calculateSampleAccurateValues(phaseIncrements, framesToProcess);
     } else {
         // Handle ordinary parameter smoothing/de-zippering if there are no scheduled changes.
@@ skipping 49 matching lines @@
         return;
 
     // The audio thread can't block on this lock, so we call tryLock() instead.
     MutexTryLocker tryLocker(m_processLock);
     if (!tryLocker.locked()) {
         // Too bad - the tryLock() failed. We must be in the middle of changing wave-tables.
         outputBus->zero();
         return;
     }
 
-    // We must access m_waveTable only inside the lock.
-    if (!m_waveTable.get()) {
+    // We must access m_periodicWave only inside the lock.
+    if (!m_periodicWave.get()) {
         outputBus->zero();
         return;
     }
 
     size_t quantumFrameOffset;
     size_t nonSilentFramesToProcess;
 
     updateSchedulingInfo(framesToProcess, outputBus, quantumFrameOffset, nonSilentFramesToProcess);
 
     if (!nonSilentFramesToProcess) {
         outputBus->zero();
         return;
     }
 
-    unsigned waveTableSize = m_waveTable->waveTableSize();
-    double invWaveTableSize = 1.0 / waveTableSize;
+    unsigned periodicWaveSize = m_periodicWave->periodicWaveSize();
+    double invPeriodicWaveSize = 1.0 / periodicWaveSize;
 
     float* destP = outputBus->channel(0)->mutableData();
 
     ASSERT(quantumFrameOffset <= framesToProcess);
 
     // We keep virtualReadIndex double-precision since we're accumulating values.
     double virtualReadIndex = m_virtualReadIndex;
 
-    float rateScale = m_waveTable->rateScale();
+    float rateScale = m_periodicWave->rateScale();
     float invRateScale = 1 / rateScale;
     bool hasSampleAccurateValues = calculateSampleAccuratePhaseIncrements(framesToProcess);
 
     float frequency = 0;
     float* higherWaveData = 0;
     float* lowerWaveData = 0;
     float tableInterpolationFactor;
 
     if (!hasSampleAccurateValues) {
         frequency = m_frequency->smoothedValue();
         float detune = m_detune->smoothedValue();
         float detuneScale = powf(2, detune / 1200);
         frequency *= detuneScale;
-        m_waveTable->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
+        m_periodicWave->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
     }
 
     float incr = frequency * rateScale;
     float* phaseIncrements = m_phaseIncrements.data();
 
-    unsigned readIndexMask = waveTableSize - 1;
+    unsigned readIndexMask = periodicWaveSize - 1;
 
     // Start rendering at the correct offset.
     destP += quantumFrameOffset;
     int n = nonSilentFramesToProcess;
 
     while (n--) {
         unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
         unsigned readIndex2 = readIndex + 1;
 
         // Contain within valid range.
         readIndex = readIndex & readIndexMask;
         readIndex2 = readIndex2 & readIndexMask;
 
         if (hasSampleAccurateValues) {
             incr = *phaseIncrements++;
 
             frequency = invRateScale * incr;
-            m_waveTable->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
+            m_periodicWave->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
         }
 
         float sample1Lower = lowerWaveData[readIndex];
         float sample2Lower = lowerWaveData[readIndex2];
         float sample1Higher = higherWaveData[readIndex];
         float sample2Higher = higherWaveData[readIndex2];
 
         // Linearly interpolate within each table (lower and higher).
         float interpolationFactor = static_cast<float>(virtualReadIndex) - readIndex;
         float sampleHigher = (1 - interpolationFactor) * sample1Higher + interpolationFactor * sample2Higher;
         float sampleLower = (1 - interpolationFactor) * sample1Lower + interpolationFactor * sample2Lower;
 
         // Then interpolate between the two tables.
         float sample = (1 - tableInterpolationFactor) * sampleHigher + tableInterpolationFactor * sampleLower;
 
         *destP++ = sample;
 
-        // Increment virtual read index and wrap virtualReadIndex into the range 0 -> waveTableSize.
+        // Increment virtual read index and wrap virtualReadIndex into the range 0 -> periodicWaveSize.
         virtualReadIndex += incr;
-        virtualReadIndex -= floor(virtualReadIndex * invWaveTableSize) * waveTableSize;
+        virtualReadIndex -= floor(virtualReadIndex * invPeriodicWaveSize) * periodicWaveSize;
     }
 
     m_virtualReadIndex = virtualReadIndex;
 
     outputBus->clearSilentFlag();
 }
 
 void OscillatorNode::reset()
 {
     m_virtualReadIndex = 0;
 }
 
-void OscillatorNode::setWaveTable(WaveTable* waveTable)
+void OscillatorNode::setPeriodicWave(PeriodicWave* periodicWave)
 {
     ASSERT(isMainThread());
 
     // This synchronizes with process().
     MutexLocker processLocker(m_processLock);
-    m_waveTable = waveTable;
+    m_periodicWave = periodicWave;
     m_type = CUSTOM;
 }
 
 bool OscillatorNode::propagatesSilence() const
 {
-    return !isPlayingOrScheduled() || hasFinished() || !m_waveTable.get();
+    return !isPlayingOrScheduled() || hasFinished() || !m_periodicWave.get();
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)