This source file includes following definitions.
- m_delayTimes
- m_firstTime
- bufferLengthForDelay
- hasSampleAccurateValues
- calculateSampleAccurateValues
- delayTime
- process
- reset
- tailTime
- latencyTime
#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "platform/audio/AudioDelayDSPKernel.h"
#include "platform/audio/AudioUtilities.h"
#include "wtf/MathExtras.h"
#include <algorithm>
using namespace std;
namespace WebCore {
const float SmoothingTimeConstant = 0.020f;
AudioDelayDSPKernel::AudioDelayDSPKernel(AudioDSPKernelProcessor* processor, size_t processingSizeInFrames)
: AudioDSPKernel(processor)
, m_writeIndex(0)
, m_firstTime(true)
, m_delayTimes(processingSizeInFrames)
{
}
AudioDelayDSPKernel::AudioDelayDSPKernel(double maxDelayTime, float sampleRate)
: AudioDSPKernel(sampleRate)
, m_maxDelayTime(maxDelayTime)
, m_writeIndex(0)
, m_firstTime(true)
{
ASSERT(maxDelayTime > 0.0 && !std::isnan(maxDelayTime));
if (maxDelayTime <= 0.0 || std::isnan(maxDelayTime))
return;
size_t bufferLength = bufferLengthForDelay(maxDelayTime, sampleRate);
ASSERT(bufferLength);
if (!bufferLength)
return;
m_buffer.allocate(bufferLength);
m_buffer.zero();
m_smoothingRate = AudioUtilities::discreteTimeConstantForSampleRate(SmoothingTimeConstant, sampleRate);
}
size_t AudioDelayDSPKernel::bufferLengthForDelay(double maxDelayTime, double sampleRate) const
{
return 1 + AudioUtilities::timeToSampleFrame(maxDelayTime, sampleRate);
}
bool AudioDelayDSPKernel::hasSampleAccurateValues()
{
return false;
}
void AudioDelayDSPKernel::calculateSampleAccurateValues(float*, size_t)
{
ASSERT_NOT_REACHED();
}
double AudioDelayDSPKernel::delayTime(float sampleRate)
{
return m_desiredDelayFrames / sampleRate;
}
void AudioDelayDSPKernel::process(const float* source, float* destination, size_t framesToProcess)
{
size_t bufferLength = m_buffer.size();
float* buffer = m_buffer.data();
ASSERT(bufferLength);
if (!bufferLength)
return;
ASSERT(source && destination);
if (!source || !destination)
return;
float sampleRate = this->sampleRate();
double delayTime = 0;
float* delayTimes = m_delayTimes.data();
double maxTime = maxDelayTime();
bool sampleAccurate = hasSampleAccurateValues();
if (sampleAccurate) {
calculateSampleAccurateValues(delayTimes, framesToProcess);
} else {
delayTime = this->delayTime(sampleRate);
delayTime = min(maxTime, delayTime);
delayTime = max(0.0, delayTime);
if (m_firstTime) {
m_currentDelayTime = delayTime;
m_firstTime = false;
}
}
for (unsigned i = 0; i < framesToProcess; ++i) {
if (sampleAccurate) {
delayTime = delayTimes[i];
delayTime = std::min(maxTime, delayTime);
delayTime = std::max(0.0, delayTime);
m_currentDelayTime = delayTime;
} else {
m_currentDelayTime += (delayTime - m_currentDelayTime) * m_smoothingRate;
}
double desiredDelayFrames = m_currentDelayTime * sampleRate;
double readPosition = m_writeIndex + bufferLength - desiredDelayFrames;
if (readPosition >= bufferLength)
readPosition -= bufferLength;
int readIndex1 = static_cast<int>(readPosition);
int readIndex2 = (readIndex1 + 1) % bufferLength;
double interpolationFactor = readPosition - readIndex1;
double input = static_cast<float>(*source++);
buffer[m_writeIndex] = static_cast<float>(input);
m_writeIndex = (m_writeIndex + 1) % bufferLength;
double sample1 = buffer[readIndex1];
double sample2 = buffer[readIndex2];
double output = (1.0 - interpolationFactor) * sample1 + interpolationFactor * sample2;
*destination++ = static_cast<float>(output);
}
}
void AudioDelayDSPKernel::reset()
{
m_firstTime = true;
m_buffer.zero();
}
double AudioDelayDSPKernel::tailTime() const
{
return m_maxDelayTime;
}
double AudioDelayDSPKernel::latencyTime() const
{
return 0;
}
}
#endif