OscillatorNode.cpp [plain text]
#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "OscillatorNode.h"
#include "AudioNodeOutput.h"
#include "AudioParam.h"
#include "PeriodicWave.h"
#include "VectorMath.h"
namespace WebCore {
using namespace VectorMath;
PeriodicWave* OscillatorNode::s_periodicWaveSine = nullptr;
PeriodicWave* OscillatorNode::s_periodicWaveSquare = nullptr;
PeriodicWave* OscillatorNode::s_periodicWaveSawtooth = nullptr;
PeriodicWave* OscillatorNode::s_periodicWaveTriangle = nullptr;
Ref<OscillatorNode> OscillatorNode::create(AudioContext& context, float sampleRate)
{
return adoptRef(*new OscillatorNode(context, sampleRate));
}
OscillatorNode::OscillatorNode(AudioContext& context, float sampleRate)
: AudioScheduledSourceNode(context, sampleRate)
, m_firstRender(true)
, m_virtualReadIndex(0)
, m_phaseIncrements(AudioNode::ProcessingSizeInFrames)
, m_detuneValues(AudioNode::ProcessingSizeInFrames)
{
setNodeType(NodeTypeOscillator);
m_frequency = AudioParam::create(context, "frequency", 440, 0, 100000);
m_detune = AudioParam::create(context, "detune", 0, -4800, 4800);
setType(m_type);
addOutput(std::make_unique<AudioNodeOutput>(this, 1));
initialize();
}
OscillatorNode::~OscillatorNode()
{
uninitialize();
}
ExceptionOr<void> OscillatorNode::setType(Type type)
{
PeriodicWave* periodicWave = nullptr;
switch (type) {
case Type::Sine:
if (!s_periodicWaveSine)
s_periodicWaveSine = &PeriodicWave::createSine(sampleRate()).leakRef();
periodicWave = s_periodicWaveSine;
break;
case Type::Square:
if (!s_periodicWaveSquare)
s_periodicWaveSquare = &PeriodicWave::createSquare(sampleRate()).leakRef();
periodicWave = s_periodicWaveSquare;
break;
case Type::Sawtooth:
if (!s_periodicWaveSawtooth)
s_periodicWaveSawtooth = &PeriodicWave::createSawtooth(sampleRate()).leakRef();
periodicWave = s_periodicWaveSawtooth;
break;
case Type::Triangle:
if (!s_periodicWaveTriangle)
s_periodicWaveTriangle = &PeriodicWave::createTriangle(sampleRate()).leakRef();
periodicWave = s_periodicWaveTriangle;
break;
case Type::Custom:
if (m_type != Type::Custom)
return Exception { InvalidStateError };
return { };
}
setPeriodicWave(periodicWave);
m_type = type;
return { };
}
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_periodicWave->rateScale();
if (m_frequency->hasSampleAccurateValues()) {
hasSampleAccurateValues = true;
hasFrequencyChanges = true;
m_frequency->calculateSampleAccurateValues(phaseIncrements, framesToProcess);
} else {
m_frequency->smooth();
float frequency = m_frequency->smoothedValue();
finalScale *= frequency;
}
if (m_detune->hasSampleAccurateValues()) {
hasSampleAccurateValues = true;
float* detuneValues = hasFrequencyChanges ? m_detuneValues.data() : phaseIncrements;
m_detune->calculateSampleAccurateValues(detuneValues, framesToProcess);
float k = 1.0 / 1200;
vsmul(detuneValues, 1, &k, detuneValues, 1, framesToProcess);
for (unsigned i = 0; i < framesToProcess; ++i)
detuneValues[i] = powf(2, detuneValues[i]);
if (hasFrequencyChanges) {
vmul(detuneValues, 1, phaseIncrements, 1, phaseIncrements, 1, framesToProcess);
}
} else {
m_detune->smooth();
float detune = m_detune->smoothedValue();
float detuneScale = powf(2, detune / 1200);
finalScale *= detuneScale;
}
if (hasSampleAccurateValues) {
vsmul(phaseIncrements, 1, &finalScale, phaseIncrements, 1, framesToProcess);
}
return hasSampleAccurateValues;
}
void OscillatorNode::process(size_t framesToProcess)
{
auto& outputBus = *output(0)->bus();
if (!isInitialized() || !outputBus.numberOfChannels()) {
outputBus.zero();
return;
}
ASSERT(framesToProcess <= m_phaseIncrements.size());
if (framesToProcess > m_phaseIncrements.size())
return;
std::unique_lock<Lock> lock(m_processMutex, std::try_to_lock);
if (!lock.owns_lock()) {
outputBus.zero();
return;
}
if (!m_periodicWave.get()) {
outputBus.zero();
return;
}
size_t quantumFrameOffset = 0;
size_t nonSilentFramesToProcess = 0;
updateSchedulingInfo(framesToProcess, outputBus, quantumFrameOffset, nonSilentFramesToProcess);
if (!nonSilentFramesToProcess) {
outputBus.zero();
return;
}
unsigned periodicWaveSize = m_periodicWave->periodicWaveSize();
double invPeriodicWaveSize = 1.0 / periodicWaveSize;
float* destP = outputBus.channel(0)->mutableData();
ASSERT(quantumFrameOffset <= framesToProcess);
double virtualReadIndex = m_virtualReadIndex;
float rateScale = m_periodicWave->rateScale();
float invRateScale = 1 / rateScale;
bool hasSampleAccurateValues = calculateSampleAccuratePhaseIncrements(framesToProcess);
float frequency = 0;
float* higherWaveData = nullptr;
float* lowerWaveData = nullptr;
float tableInterpolationFactor = 0;
if (!hasSampleAccurateValues) {
frequency = m_frequency->smoothedValue();
float detune = m_detune->smoothedValue();
float detuneScale = powf(2, detune / 1200);
frequency *= detuneScale;
m_periodicWave->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
}
float incr = frequency * rateScale;
float* phaseIncrements = m_phaseIncrements.data();
unsigned readIndexMask = periodicWaveSize - 1;
destP += quantumFrameOffset;
int n = nonSilentFramesToProcess;
while (n--) {
unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
unsigned readIndex2 = readIndex + 1;
readIndex = readIndex & readIndexMask;
readIndex2 = readIndex2 & readIndexMask;
if (hasSampleAccurateValues) {
incr = *phaseIncrements++;
frequency = invRateScale * incr;
m_periodicWave->waveDataForFundamentalFrequency(frequency, lowerWaveData, higherWaveData, tableInterpolationFactor);
}
float sample1Lower = lowerWaveData[readIndex];
float sample2Lower = lowerWaveData[readIndex2];
float sample1Higher = higherWaveData[readIndex];
float sample2Higher = higherWaveData[readIndex2];
float interpolationFactor = static_cast<float>(virtualReadIndex) - readIndex;
float sampleHigher = (1 - interpolationFactor) * sample1Higher + interpolationFactor * sample2Higher;
float sampleLower = (1 - interpolationFactor) * sample1Lower + interpolationFactor * sample2Lower;
float sample = (1 - tableInterpolationFactor) * sampleHigher + tableInterpolationFactor * sampleLower;
*destP++ = sample;
virtualReadIndex += incr;
virtualReadIndex -= floor(virtualReadIndex * invPeriodicWaveSize) * periodicWaveSize;
}
m_virtualReadIndex = virtualReadIndex;
outputBus.clearSilentFlag();
}
void OscillatorNode::reset()
{
m_virtualReadIndex = 0;
}
void OscillatorNode::setPeriodicWave(PeriodicWave* periodicWave)
{
ASSERT(isMainThread());
std::lock_guard<Lock> lock(m_processMutex);
m_periodicWave = periodicWave;
m_type = Type::Custom;
}
bool OscillatorNode::propagatesSilence() const
{
return !isPlayingOrScheduled() || hasFinished() || !m_periodicWave.get();
}
}
#endif // ENABLE(WEB_AUDIO)