Home | History | Annotate | Download | only in webaudio 
      1 /*
      2  * Copyright (C) 2012, Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1.  Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2.  Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
     17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
     20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     23  */
     24 
     25 #include "config.h"
     26 
     27 #if ENABLE(WEB_AUDIO)
     28 
     29 #include "modules/webaudio/OscillatorNode.h"
     30 
     31 #include "core/platform/audio/AudioUtilities.h"
     32 #include "core/platform/audio/VectorMath.h"
     33 #include "modules/webaudio/AudioContext.h"
     34 #include "modules/webaudio/AudioNodeOutput.h"
     35 #include "modules/webaudio/PeriodicWave.h"
     36 #include <algorithm>
     37 #include "wtf/MathExtras.h"
     38 
     39 using namespace std;
     40 
     41 namespace WebCore {
     42 
     43 using namespace VectorMath;
     44 
     45 PeriodicWave* OscillatorNode::s_periodicWaveSine = 0;
     46 PeriodicWave* OscillatorNode::s_periodicWaveSquare = 0;
     47 PeriodicWave* OscillatorNode::s_periodicWaveSawtooth = 0;
     48 PeriodicWave* OscillatorNode::s_periodicWaveTriangle = 0;
     49 
     50 PassRefPtr<OscillatorNode> OscillatorNode::create(AudioContext* context, float sampleRate)
     51 {
     52     return adoptRef(new OscillatorNode(context, sampleRate));
     53 }
     54 
     55 OscillatorNode::OscillatorNode(AudioContext* context, float sampleRate)
     56     : AudioScheduledSourceNode(context, sampleRate)
     57     , m_type(SINE)
     58     , m_firstRender(true)
     59     , m_virtualReadIndex(0)
     60     , m_phaseIncrements(AudioNode::ProcessingSizeInFrames)
     61     , m_detuneValues(AudioNode::ProcessingSizeInFrames)
     62 {
     63     ScriptWrappable::init(this);
     64     setNodeType(NodeTypeOscillator);
     65 
     66     // Use musical pitch standard A440 as a default.
     67     m_frequency = AudioParam::create(context, "frequency", 440, 0, 100000);
     68     // Default to no detuning.
     69     m_detune = AudioParam::create(context, "detune", 0, -4800, 4800);
     70 
     71     // Sets up default wavetable.
     72     setType(m_type);
     73 
     74     // An oscillator is always mono.
     75     addOutput(adoptPtr(new AudioNodeOutput(this, 1)));
     76 
     77     initialize();
     78 }
     79 
     80 OscillatorNode::~OscillatorNode()
     81 {
     82     uninitialize();
     83 }
     84 
     85 String OscillatorNode::type() const
     86 {
     87     switch (m_type) {
     88     case SINE:
     89         return "sine";
     90     case SQUARE:
     91         return "square";
     92     case SAWTOOTH:
     93         return "sawtooth";
     94     case TRIANGLE:
     95         return "triangle";
     96     case CUSTOM:
     97         return "custom";
     98     default:
     99         ASSERT_NOT_REACHED();
    100         return "custom";
    101     }
    102 }
    103 
    104 void OscillatorNode::setType(const String& type)
    105 {
    106     if (type == "sine")
    107         setType(SINE);
    108     else if (type == "square")
    109         setType(SQUARE);
    110     else if (type == "sawtooth")
    111         setType(SAWTOOTH);
    112     else if (type == "triangle")
    113         setType(TRIANGLE);
    114     else
    115         ASSERT_NOT_REACHED();
    116 }
    117 
    118 bool OscillatorNode::setType(unsigned type)
    119 {
    120     PeriodicWave* periodicWave = 0;
    121     float sampleRate = this->sampleRate();
    122 
    123     switch (type) {
    124     case SINE:
    125         if (!s_periodicWaveSine)
    126             s_periodicWaveSine = PeriodicWave::createSine(sampleRate).leakRef();
    127         periodicWave = s_periodicWaveSine;
    128         break;
    129     case SQUARE:
    130         if (!s_periodicWaveSquare)
    131             s_periodicWaveSquare = PeriodicWave::createSquare(sampleRate).leakRef();
    132         periodicWave = s_periodicWaveSquare;
    133         break;
    134     case SAWTOOTH:
    135         if (!s_periodicWaveSawtooth)
    136             s_periodicWaveSawtooth = PeriodicWave::createSawtooth(sampleRate).leakRef();
    137         periodicWave = s_periodicWaveSawtooth;
    138         break;
    139     case TRIANGLE:
    140         if (!s_periodicWaveTriangle)
    141             s_periodicWaveTriangle = PeriodicWave::createTriangle(sampleRate).leakRef();
    142         periodicWave = s_periodicWaveTriangle;
    143         break;
    144     case CUSTOM:
    145     default:
    146         // Return error for invalid types, including CUSTOM since setPeriodicWave() method must be
    147         // called explicitly.
    148         return false;
    149     }
    150 
    151     setPeriodicWave(periodicWave);
    152     m_type = type;
    153     return true;
    154 }
    155 
    156 bool OscillatorNode::calculateSampleAccuratePhaseIncrements(size_t framesToProcess)
    157 {
    158     bool isGood = framesToProcess <= m_phaseIncrements.size() && framesToProcess <= m_detuneValues.size();
    159     ASSERT(isGood);
    160     if (!isGood)
    161         return false;
    162 
    163     if (m_firstRender) {
    164         m_firstRender = false;
    165         m_frequency->resetSmoothedValue();
    166         m_detune->resetSmoothedValue();
    167     }
    168 
    169     bool hasSampleAccurateValues = false;
    170     bool hasFrequencyChanges = false;
    171     float* phaseIncrements = m_phaseIncrements.data();
    172 
    173     float finalScale = m_periodicWave->rateScale();
    174 
    175     if (m_frequency->hasSampleAccurateValues()) {
    176         hasSampleAccurateValues = true;
    177         hasFrequencyChanges = true;
    178 
    179         // Get the sample-accurate frequency values and convert to phase increments.
    180         // They will be converted to phase increments below.
    181         m_frequency->calculateSampleAccurateValues(phaseIncrements, framesToProcess);
    182     } else {
    183         // Handle ordinary parameter smoothing/de-zippering if there are no scheduled changes.
    184         m_frequency->smooth();
    185         float frequency = m_frequency->smoothedValue();
    186         finalScale *= frequency;
    187     }
    188 
    189     if (m_detune->hasSampleAccurateValues()) {
    190         hasSampleAccurateValues = true;
    191 
    192         // Get the sample-accurate detune values.
    193         float* detuneValues = hasFrequencyChanges ? m_detuneValues.data() : phaseIncrements;
    194         m_detune->calculateSampleAccurateValues(detuneValues, framesToProcess);
    195 
    196         // Convert from cents to rate scalar.
    197         float k = 1.0 / 1200;
    198         vsmul(detuneValues, 1, &k, detuneValues, 1, framesToProcess);
    199         for (unsigned i = 0; i < framesToProcess; ++i)
    200             detuneValues[i] = powf(2, detuneValues[i]); // FIXME: converting to expf() will be faster.
    201 
    202         if (hasFrequencyChanges) {
    203             // Multiply frequencies by detune scalings.
    204             vmul(detuneValues, 1, phaseIncrements, 1, phaseIncrements, 1, framesToProcess);
    205         }
    206     } else {
    207         // Handle ordinary parameter smoothing/de-zippering if there are no scheduled changes.
    208         m_detune->smooth();
    209         float detune = m_detune->smoothedValue();
    210         float detuneScale = powf(2, detune / 1200);
    211         finalScale *= detuneScale;
    212     }
    213 
    214     if (hasSampleAccurateValues) {
    215         // Convert from frequency to wavetable increment.
    216         vsmul(phaseIncrements, 1, &finalScale, phaseIncrements, 1, framesToProcess);
    217     }
    218 
    219     return hasSampleAccurateValues;
    220 }
    221 
    222 void OscillatorNode::process(size_t framesToProcess)
    223 {
    224     AudioBus* outputBus = output(0)->bus();
    225 
    226     if (!isInitialized() || !outputBus->numberOfChannels()) {
    227         outputBus->zero();
    228         return;
    229     }
    230 
    231     ASSERT(framesToProcess <= m_phaseIncrements.size());
    232     if (framesToProcess > m_phaseIncrements.size())
    233         return;
    234 
    235     // The audio thread can't block on this lock, so we call tryLock() instead.
    236     MutexTryLocker tryLocker(m_processLock);
    237     if (!tryLocker.locked()) {
    238         // Too bad - the tryLock() failed. We must be in the middle of changing wave-tables.
    239         outputBus->zero();
    240         return;
    241     }
    242 
    243     // We must access m_periodicWave only inside the lock.
    244     if (!m_periodicWave.get()) {
    245         outputBus->zero();
    246         return;
    247     }
    248 
    249     size_t quantumFrameOffset;
    250     size_t nonSilentFramesToProcess;
    251 
    252     updateSchedulingInfo(framesToProcess, outputBus, quantumFrameOffset, nonSilentFramesToProcess);
    253 
    254     if (!nonSilentFramesToProcess) {
    255         outputBus->zero();
    256         return;
    257     }
    258 
    259     unsigned periodicWaveSize = m_periodicWave->periodicWaveSize();
    260     double invPeriodicWaveSize = 1.0 / periodicWaveSize;
    261 
    262     float* destP = outputBus->channel(0)->mutableData();
    263 
    264     ASSERT(quantumFrameOffset <= framesToProcess);
    265 
    266     // We keep virtualReadIndex double-precision since we're accumulating values.
    267     double virtualReadIndex = m_virtualReadIndex;
    268 
    269     float rateScale = m_periodicWave->rateScale();
    270     float invRateScale = 1 / rateScale;
    271     bool hasSampleAccurateValues = calculateSampleAccuratePhaseIncrements(framesToProcess);
    272 
    273     float frequency = 0;
    274     float* higherWaveData = 0;
    275     float* lowerWaveData = 0;
    276     float tableInterpolationFactor;
    277 
    278     if (!hasSampleAccurateValues) {
    279         frequency = m_frequency->smoothedValue();
    280         float detune = m_detune->smoothedValue();
    281         float detuneScale = powf(2, detune / 1200);
    282         frequency *= detuneScale;
    283         m_periodicWave->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
    284     }
    285 
    286     float incr = frequency * rateScale;
    287     float* phaseIncrements = m_phaseIncrements.data();
    288 
    289     unsigned readIndexMask = periodicWaveSize - 1;
    290 
    291     // Start rendering at the correct offset.
    292     destP += quantumFrameOffset;
    293     int n = nonSilentFramesToProcess;
    294 
    295     while (n--) {
    296         unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
    297         unsigned readIndex2 = readIndex + 1;
    298 
    299         // Contain within valid range.
    300         readIndex = readIndex & readIndexMask;
    301         readIndex2 = readIndex2 & readIndexMask;
    302 
    303         if (hasSampleAccurateValues) {
    304             incr = *phaseIncrements++;
    305 
    306             frequency = invRateScale * incr;
    307             m_periodicWave->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
    308         }
    309 
    310         float sample1Lower = lowerWaveData[readIndex];
    311         float sample2Lower = lowerWaveData[readIndex2];
    312         float sample1Higher = higherWaveData[readIndex];
    313         float sample2Higher = higherWaveData[readIndex2];
    314 
    315         // Linearly interpolate within each table (lower and higher).
    316         float interpolationFactor = static_cast<float>(virtualReadIndex) - readIndex;
    317         float sampleHigher = (1 - interpolationFactor) * sample1Higher + interpolationFactor * sample2Higher;
    318         float sampleLower = (1 - interpolationFactor) * sample1Lower + interpolationFactor * sample2Lower;
    319 
    320         // Then interpolate between the two tables.
    321         float sample = (1 - tableInterpolationFactor) * sampleHigher + tableInterpolationFactor * sampleLower;
    322 
    323         *destP++ = sample;
    324 
    325         // Increment virtual read index and wrap virtualReadIndex into the range 0 -> periodicWaveSize.
    326         virtualReadIndex += incr;
    327         virtualReadIndex -= floor(virtualReadIndex * invPeriodicWaveSize) * periodicWaveSize;
    328     }
    329 
    330     m_virtualReadIndex = virtualReadIndex;
    331 
    332     outputBus->clearSilentFlag();
    333 }
    334 
    335 void OscillatorNode::reset()
    336 {
    337     m_virtualReadIndex = 0;
    338 }
    339 
    340 void OscillatorNode::setPeriodicWave(PeriodicWave* periodicWave)
    341 {
    342     ASSERT(isMainThread());
    343 
    344     // This synchronizes with process().
    345     MutexLocker processLocker(m_processLock);
    346     m_periodicWave = periodicWave;
    347     m_type = CUSTOM;
    348 }
    349 
    350 bool OscillatorNode::propagatesSilence() const
    351 {
    352     return !isPlayingOrScheduled() || hasFinished() || !m_periodicWave.get();
    353 }
    354 
    355 } // namespace WebCore
    356 
    357 #endif // ENABLE(WEB_AUDIO)
    358