#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "HRTFPanner.h"
#include "AudioBus.h"
#include "FFTConvolver.h"
#include "HRTFDatabase.h"
#include "HRTFDatabaseLoader.h"
#include <algorithm>
#include <wtf/MathExtras.h>
#include <wtf/RefPtr.h>
using namespace std;
namespace WebCore {
const double MaxDelayTimeSeconds = 0.002;
HRTFPanner::HRTFPanner(double sampleRate)
: Panner(PanningModelHRTF)
, m_sampleRate(sampleRate)
, m_isFirstRender(true)
, m_azimuthIndex(0)
, m_convolverL(fftSizeForSampleRate(sampleRate))
, m_convolverR(fftSizeForSampleRate(sampleRate))
, m_delayLineL(MaxDelayTimeSeconds, sampleRate)
, m_delayLineR(MaxDelayTimeSeconds, sampleRate)
{
}
HRTFPanner::~HRTFPanner()
{
}
size_t HRTFPanner::fftSizeForSampleRate(double sampleRate)
{
ASSERT(sampleRate >= 44100 && sampleRate <= 96000.0);
return (sampleRate <= 48000.0) ? 512 : 1024;
}
void HRTFPanner::reset()
{
m_isFirstRender = true;
m_convolverL.reset();
m_convolverR.reset();
m_delayLineL.reset();
m_delayLineR.reset();
}
static bool wrapDistance(int i, int j, int length)
{
int directDistance = abs(i - j);
int indirectDistance = length - directDistance;
return indirectDistance < directDistance;
}
int HRTFPanner::calculateDesiredAzimuthIndexAndBlend(double azimuth, double& azimuthBlend)
{
if (azimuth < 0)
azimuth += 360.0;
HRTFDatabase* database = HRTFDatabaseLoader::defaultHRTFDatabase();
ASSERT(database);
int numberOfAzimuths = database->numberOfAzimuths();
const double angleBetweenAzimuths = 360.0 / numberOfAzimuths;
double desiredAzimuthIndexFloat = azimuth / angleBetweenAzimuths;
int desiredAzimuthIndex = static_cast<int>(desiredAzimuthIndexFloat);
azimuthBlend = desiredAzimuthIndexFloat - static_cast<double>(desiredAzimuthIndex);
desiredAzimuthIndex = max(0, desiredAzimuthIndex);
desiredAzimuthIndex = min(numberOfAzimuths - 1, desiredAzimuthIndex);
return desiredAzimuthIndex;
}
void HRTFPanner::pan(double desiredAzimuth, double elevation, AudioBus* inputBus, AudioBus* outputBus, size_t framesToProcess)
{
unsigned numInputChannels = inputBus ? inputBus->numberOfChannels() : 0;
bool isInputGood = inputBus && numInputChannels >= 1 && numInputChannels <= 2;
ASSERT(isInputGood);
bool isOutputGood = outputBus && outputBus->numberOfChannels() == 2 && framesToProcess <= outputBus->length();
ASSERT(isOutputGood);
if (!isInputGood || !isOutputGood) {
if (outputBus)
outputBus->zero();
return;
}
HRTFDatabase* database = HRTFDatabaseLoader::defaultHRTFDatabase();
ASSERT(database);
if (!database) {
outputBus->zero();
return;
}
double azimuth = -desiredAzimuth;
bool isAzimuthGood = azimuth >= -180.0 && azimuth <= 180.0;
ASSERT(isAzimuthGood);
if (!isAzimuthGood) {
outputBus->zero();
return;
}
AudioChannel* inputChannelL = inputBus->channelByType(AudioBus::ChannelLeft);
AudioChannel* inputChannelR = numInputChannels > 1 ? inputBus->channelByType(AudioBus::ChannelRight) : 0;
float* sourceL = inputChannelL->data();
float* sourceR = numInputChannels > 1 ? inputChannelR->data() : sourceL;
float* destinationL = outputBus->channelByType(AudioBus::ChannelLeft)->data();
float* destinationR = outputBus->channelByType(AudioBus::ChannelRight)->data();
double azimuthBlend;
int desiredAzimuthIndex = calculateDesiredAzimuthIndexAndBlend(azimuth, azimuthBlend);
ASSERT(1UL << static_cast<int>(log2(framesToProcess)) == framesToProcess);
ASSERT(framesToProcess >= 128);
const unsigned framesPerSegment = 128;
const unsigned numberOfSegments = framesToProcess / framesPerSegment;
for (unsigned segment = 0; segment < numberOfSegments; ++segment) {
if (m_isFirstRender) {
m_azimuthIndex = desiredAzimuthIndex;
m_isFirstRender = false;
} else {
int numberOfAzimuths = database->numberOfAzimuths();
bool wrap = wrapDistance(m_azimuthIndex, desiredAzimuthIndex, numberOfAzimuths);
if (wrap) {
if (m_azimuthIndex < desiredAzimuthIndex)
m_azimuthIndex = (m_azimuthIndex - 1 + numberOfAzimuths) % numberOfAzimuths;
else if (m_azimuthIndex > desiredAzimuthIndex)
m_azimuthIndex = (m_azimuthIndex + 1) % numberOfAzimuths;
} else {
if (m_azimuthIndex < desiredAzimuthIndex)
m_azimuthIndex = (m_azimuthIndex + 1) % numberOfAzimuths;
else if (m_azimuthIndex > desiredAzimuthIndex)
m_azimuthIndex = (m_azimuthIndex - 1 + numberOfAzimuths) % numberOfAzimuths;
}
}
HRTFKernel* kernelL;
HRTFKernel* kernelR;
double frameDelayL;
double frameDelayR;
database->getKernelsFromAzimuthElevation(azimuthBlend, m_azimuthIndex, elevation, kernelL, kernelR, frameDelayL, frameDelayR);
ASSERT(kernelL && kernelR);
if (!kernelL || !kernelR) {
outputBus->zero();
return;
}
ASSERT(frameDelayL / sampleRate() < MaxDelayTimeSeconds && frameDelayR / sampleRate() < MaxDelayTimeSeconds);
unsigned offset = segment * framesPerSegment;
float* segmentSourceL = sourceL + offset;
float* segmentSourceR = sourceR + offset;
float* segmentDestinationL = destinationL + offset;
float* segmentDestinationR = destinationR + offset;
m_delayLineL.setDelayFrames(frameDelayL);
m_delayLineR.setDelayFrames(frameDelayR);
m_delayLineL.process(segmentSourceL, segmentDestinationL, framesPerSegment);
m_delayLineR.process(segmentSourceR, segmentDestinationR, framesPerSegment);
m_convolverL.process(kernelL->fftFrame(), segmentDestinationL, segmentDestinationL, framesPerSegment);
m_convolverR.process(kernelR->fftFrame(), segmentDestinationR, segmentDestinationR, framesPerSegment);
}
}
}
#endif // ENABLE(WEB_AUDIO)