Source code

Revision control

Other Tools

/*
* Copyright (C) 2010, 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
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "HRTFPanner.h"
#include "HRTFDatabaseLoader.h"
#include "FFTConvolver.h"
#include "HRTFDatabase.h"
#include "AudioBlock.h"
using namespace mozilla;
using dom::ChannelInterpretation;
namespace WebCore {
// The value of 2 milliseconds is larger than the largest delay which exists in
// any HRTFKernel from the default HRTFDatabase (0.0136 seconds). We ASSERT the
// delay values used in process() with this value.
const float MaxDelayTimeSeconds = 0.002f;
const int UninitializedAzimuth = -1;
const unsigned RenderingQuantum = WEBAUDIO_BLOCK_SIZE;
HRTFPanner::HRTFPanner(float sampleRate,
already_AddRefed<HRTFDatabaseLoader> databaseLoader)
: m_databaseLoader(databaseLoader),
m_sampleRate(sampleRate),
m_crossfadeSelection(CrossfadeSelection1),
m_azimuthIndex1(UninitializedAzimuth),
m_azimuthIndex2(UninitializedAzimuth)
// m_elevation1 and m_elevation2 are initialized in pan()
,
m_crossfadeX(0),
m_crossfadeIncr(0),
m_convolverL1(HRTFElevation::fftSizeForSampleRate(sampleRate)),
m_convolverR1(m_convolverL1.fftSize()),
m_convolverL2(m_convolverL1.fftSize()),
m_convolverR2(m_convolverL1.fftSize()),
m_delayLine(MaxDelayTimeSeconds * sampleRate) {
MOZ_ASSERT(m_databaseLoader);
MOZ_COUNT_CTOR(HRTFPanner);
}
HRTFPanner::~HRTFPanner() { MOZ_COUNT_DTOR(HRTFPanner); }
size_t HRTFPanner::sizeOfIncludingThis(
mozilla::MallocSizeOf aMallocSizeOf) const {
size_t amount = aMallocSizeOf(this);
// NB: m_databaseLoader can be shared, so it is not measured here
amount += m_convolverL1.sizeOfExcludingThis(aMallocSizeOf);
amount += m_convolverR1.sizeOfExcludingThis(aMallocSizeOf);
amount += m_convolverL2.sizeOfExcludingThis(aMallocSizeOf);
amount += m_convolverR2.sizeOfExcludingThis(aMallocSizeOf);
amount += m_delayLine.SizeOfExcludingThis(aMallocSizeOf);
return amount;
}
void HRTFPanner::reset() {
m_azimuthIndex1 = UninitializedAzimuth;
m_azimuthIndex2 = UninitializedAzimuth;
// m_elevation1 and m_elevation2 are initialized in pan()
m_crossfadeSelection = CrossfadeSelection1;
m_crossfadeX = 0.0f;
m_crossfadeIncr = 0.0f;
m_convolverL1.reset();
m_convolverR1.reset();
m_convolverL2.reset();
m_convolverR2.reset();
m_delayLine.Reset();
}
int HRTFPanner::calculateDesiredAzimuthIndexAndBlend(double azimuth,
double& azimuthBlend) {
// Convert the azimuth angle from the range -180 -> +180 into the range 0 ->
// 360. The azimuth index may then be calculated from this positive value.
if (azimuth < 0) azimuth += 360.0;
int numberOfAzimuths = HRTFDatabase::numberOfAzimuths();
const double angleBetweenAzimuths = 360.0 / numberOfAzimuths;
// Calculate the azimuth index and the blend (0 -> 1) for interpolation.
double desiredAzimuthIndexFloat = azimuth / angleBetweenAzimuths;
int desiredAzimuthIndex = static_cast<int>(desiredAzimuthIndexFloat);
azimuthBlend =
desiredAzimuthIndexFloat - static_cast<double>(desiredAzimuthIndex);
// We don't immediately start using this azimuth index, but instead approach
// this index from the last index we rendered at. This minimizes the clicks
// and graininess for moving sources which occur otherwise.
desiredAzimuthIndex = std::max(0, desiredAzimuthIndex);
desiredAzimuthIndex = std::min(numberOfAzimuths - 1, desiredAzimuthIndex);
return desiredAzimuthIndex;
}
void HRTFPanner::pan(double desiredAzimuth, double elevation,
const AudioBlock* inputBus, AudioBlock* outputBus) {
#ifdef DEBUG
unsigned numInputChannels = inputBus->IsNull() ? 0 : inputBus->ChannelCount();
MOZ_ASSERT(numInputChannels <= 2);
MOZ_ASSERT(inputBus->GetDuration() == WEBAUDIO_BLOCK_SIZE);
#endif
bool isOutputGood = outputBus && outputBus->ChannelCount() == 2 &&
outputBus->GetDuration() == WEBAUDIO_BLOCK_SIZE;
MOZ_ASSERT(isOutputGood);
if (!isOutputGood) {
if (outputBus) outputBus->SetNull(outputBus->GetDuration());
return;
}
HRTFDatabase* database = m_databaseLoader->database();
if (!database) { // not yet loaded
outputBus->SetNull(outputBus->GetDuration());
return;
}
// IRCAM HRTF azimuths values from the loaded database is reversed from the
// panner's notion of azimuth.
double azimuth = -desiredAzimuth;
bool isAzimuthGood = azimuth >= -180.0 && azimuth <= 180.0;
MOZ_ASSERT(isAzimuthGood);
if (!isAzimuthGood) {
outputBus->SetNull(outputBus->GetDuration());
return;
}
// Normally, we'll just be dealing with mono sources.
// If we have a stereo input, implement stereo panning with left source
// processed by left HRTF, and right source by right HRTF.
// Get destination pointers.
float* destinationL =
static_cast<float*>(const_cast<void*>(outputBus->mChannelData[0]));
float* destinationR =
static_cast<float*>(const_cast<void*>(outputBus->mChannelData[1]));
double azimuthBlend;
int desiredAzimuthIndex =
calculateDesiredAzimuthIndexAndBlend(azimuth, azimuthBlend);
// Initially snap azimuth and elevation values to first values encountered.
if (m_azimuthIndex1 == UninitializedAzimuth) {
m_azimuthIndex1 = desiredAzimuthIndex;
m_elevation1 = elevation;
}
if (m_azimuthIndex2 == UninitializedAzimuth) {
m_azimuthIndex2 = desiredAzimuthIndex;
m_elevation2 = elevation;
}
// Cross-fade / transition over a period of around 45 milliseconds.
// This is an empirical value tuned to be a reasonable trade-off between
// smoothness and speed.
const double fadeFrames = sampleRate() <= 48000 ? 2048 : 4096;
// Check for azimuth and elevation changes, initiating a cross-fade if needed.
if (!m_crossfadeX && m_crossfadeSelection == CrossfadeSelection1) {
if (desiredAzimuthIndex != m_azimuthIndex1 || elevation != m_elevation1) {
// Cross-fade from 1 -> 2
m_crossfadeIncr = 1 / fadeFrames;
m_azimuthIndex2 = desiredAzimuthIndex;
m_elevation2 = elevation;
}
}
if (m_crossfadeX == 1 && m_crossfadeSelection == CrossfadeSelection2) {
if (desiredAzimuthIndex != m_azimuthIndex2 || elevation != m_elevation2) {
// Cross-fade from 2 -> 1
m_crossfadeIncr = -1 / fadeFrames;
m_azimuthIndex1 = desiredAzimuthIndex;
m_elevation1 = elevation;
}
}
// Get the HRTFKernels and interpolated delays.
HRTFKernel* kernelL1;
HRTFKernel* kernelR1;
HRTFKernel* kernelL2;
HRTFKernel* kernelR2;
double frameDelayL1;
double frameDelayR1;
double frameDelayL2;
double frameDelayR2;
database->getKernelsFromAzimuthElevation(azimuthBlend, m_azimuthIndex1,
m_elevation1, kernelL1, kernelR1,
frameDelayL1, frameDelayR1);
database->getKernelsFromAzimuthElevation(azimuthBlend, m_azimuthIndex2,
m_elevation2, kernelL2, kernelR2,
frameDelayL2, frameDelayR2);
bool areKernelsGood = kernelL1 && kernelR1 && kernelL2 && kernelR2;
MOZ_ASSERT(areKernelsGood);
if (!areKernelsGood) {
outputBus->SetNull(outputBus->GetDuration());
return;
}
MOZ_ASSERT(frameDelayL1 / sampleRate() < MaxDelayTimeSeconds &&
frameDelayR1 / sampleRate() < MaxDelayTimeSeconds);
MOZ_ASSERT(frameDelayL2 / sampleRate() < MaxDelayTimeSeconds &&
frameDelayR2 / sampleRate() < MaxDelayTimeSeconds);
// Crossfade inter-aural delays based on transitions.
float frameDelaysL[WEBAUDIO_BLOCK_SIZE];
float frameDelaysR[WEBAUDIO_BLOCK_SIZE];
{
float x = m_crossfadeX;
float incr = m_crossfadeIncr;
for (unsigned i = 0; i < WEBAUDIO_BLOCK_SIZE; ++i) {
frameDelaysL[i] = (1 - x) * frameDelayL1 + x * frameDelayL2;
frameDelaysR[i] = (1 - x) * frameDelayR1 + x * frameDelayR2;
x += incr;
}
}
// First run through delay lines for inter-aural time difference.
m_delayLine.Write(*inputBus);
// "Speakers" means a mono input is read into both outputs (with possibly
// different delays).
m_delayLine.ReadChannel(frameDelaysL, outputBus, 0,
ChannelInterpretation::Speakers);
m_delayLine.ReadChannel(frameDelaysR, outputBus, 1,
ChannelInterpretation::Speakers);
m_delayLine.NextBlock();
bool needsCrossfading = m_crossfadeIncr;
const float* convolutionDestinationL1;
const float* convolutionDestinationR1;
const float* convolutionDestinationL2;
const float* convolutionDestinationR2;
// Now do the convolutions.
// Note that we avoid doing convolutions on both sets of convolvers if we're
// not currently cross-fading.
if (m_crossfadeSelection == CrossfadeSelection1 || needsCrossfading) {
convolutionDestinationL1 =
m_convolverL1.process(kernelL1->fftFrame(), destinationL);
convolutionDestinationR1 =
m_convolverR1.process(kernelR1->fftFrame(), destinationR);
}
if (m_crossfadeSelection == CrossfadeSelection2 || needsCrossfading) {
convolutionDestinationL2 =
m_convolverL2.process(kernelL2->fftFrame(), destinationL);
convolutionDestinationR2 =
m_convolverR2.process(kernelR2->fftFrame(), destinationR);
}
if (needsCrossfading) {
// Apply linear cross-fade.
float x = m_crossfadeX;
float incr = m_crossfadeIncr;
for (unsigned i = 0; i < WEBAUDIO_BLOCK_SIZE; ++i) {
destinationL[i] = (1 - x) * convolutionDestinationL1[i] +
x * convolutionDestinationL2[i];
destinationR[i] = (1 - x) * convolutionDestinationR1[i] +
x * convolutionDestinationR2[i];
x += incr;
}
// Update cross-fade value from local.
m_crossfadeX = x;
if (m_crossfadeIncr > 0 && fabs(m_crossfadeX - 1) < m_crossfadeIncr) {
// We've fully made the crossfade transition from 1 -> 2.
m_crossfadeSelection = CrossfadeSelection2;
m_crossfadeX = 1;
m_crossfadeIncr = 0;
} else if (m_crossfadeIncr < 0 && fabs(m_crossfadeX) < -m_crossfadeIncr) {
// We've fully made the crossfade transition from 2 -> 1.
m_crossfadeSelection = CrossfadeSelection1;
m_crossfadeX = 0;
m_crossfadeIncr = 0;
}
} else {
const float* sourceL;
const float* sourceR;
if (m_crossfadeSelection == CrossfadeSelection1) {
sourceL = convolutionDestinationL1;
sourceR = convolutionDestinationR1;
} else {
sourceL = convolutionDestinationL2;
sourceR = convolutionDestinationR2;
}
PodCopy(destinationL, sourceL, WEBAUDIO_BLOCK_SIZE);
PodCopy(destinationR, sourceR, WEBAUDIO_BLOCK_SIZE);
}
}
int HRTFPanner::maxTailFrames() const {
// Although the ideal tail time would be the length of the impulse
// response, there is additional tail time from the approximations in the
// implementation. Because HRTFPanner is implemented with a DelayKernel
// and a FFTConvolver, the tailTime of the HRTFPanner is the sum of the
// tailTime of the DelayKernel and the tailTime of the FFTConvolver. The
// FFTs of the convolver are fftSize(), half of which is latency, but this
// is aligned with blocks and so is reduced by the one block which is
// processed immediately.
return m_delayLine.MaxDelayTicks() + m_convolverL1.fftSize() / 2 +
m_convolverL1.latencyFrames();
}
} // namespace WebCore