// Use a power of two to eliminate round-off when converting frames to time and
// vice versa.
let sampleRate = 32768;
// How many panner nodes to create for the test.
let nodesToCreate = 100;
// Time step when each panner node starts. Make sure it starts on a frame
// boundary.
let timeStep = Math.floor(0.001 * sampleRate) / sampleRate;
// Make sure we render long enough to get all of our nodes.
let renderLengthSeconds = timeStep * (nodesToCreate + 1);
// Length of an impulse signal.
let pulseLengthFrames = Math.round(timeStep * sampleRate);
// Globals to make debugging a little easier.
let context;
let impulse;
let bufferSource;
let panner;
let position;
let time;
// For the record, these distance formulas were taken from the OpenAL
// spec
// (http://connect.creativelabs.com/openal/Documentation/OpenAL%201.1%20Specification.pdf),
// not the code. The Web Audio spec follows the OpenAL formulas.
function linearDistance(panner, x, y, z) {
let distance = Math.sqrt(x * x + y * y + z * z);
distance = Math.min(distance, panner.maxDistance);
let rolloff = panner.rolloffFactor;
let gain =
(1 -
rolloff * (distance - panner.refDistance) /
(panner.maxDistance - panner.refDistance));
return gain;
}
function inverseDistance(panner, x, y, z) {
let distance = Math.sqrt(x * x + y * y + z * z);
distance = Math.min(distance, panner.maxDistance);
let rolloff = panner.rolloffFactor;
let gain = panner.refDistance /
(panner.refDistance + rolloff * (distance - panner.refDistance));
return gain;
}
function exponentialDistance(panner, x, y, z) {
let distance = Math.sqrt(x * x + y * y + z * z);
distance = Math.min(distance, panner.maxDistance);
let rolloff = panner.rolloffFactor;
let gain = Math.pow(distance / panner.refDistance, -rolloff);
return gain;
}
// Map the distance model to the function that implements the model
let distanceModelFunction = {
'linear': linearDistance,
'inverse': inverseDistance,
'exponential': exponentialDistance
};
function createGraph(context, distanceModel, nodeCount) {
bufferSource = new Array(nodeCount);
panner = new Array(nodeCount);
position = new Array(nodeCount);
time = new Array(nodesToCreate);
impulse = createImpulseBuffer(context, pulseLengthFrames);
// Create all the sources and panners.
//
// We MUST use the EQUALPOWER panning model so that we can easily
// figure out the gain introduced by the panner.
//
// We want to stay in the middle of the panning range, which means
// we want to stay on the z-axis. If we don't, then the effect of
// panning model will be much more complicated. We're not testing
// the panner, but the distance model, so we want the panner effect
// to be simple.
//
// The panners are placed at a uniform intervals between the panner
// reference distance and the panner max distance. The source is
// also started at regular intervals.
for (let k = 0; k < nodeCount; ++k) {
bufferSource[k] = context.createBufferSource();
bufferSource[k].buffer = impulse;
panner[k] = context.createPanner();
panner[k].panningModel = 'equalpower';
panner[k].distanceModel = distanceModel;
let distanceStep =
(panner[k].maxDistance - panner[k].refDistance) / nodeCount;
position[k] = distanceStep * k + panner[k].refDistance;
panner[k].setPosition(0, 0, position[k]);
bufferSource[k].connect(panner[k]);
panner[k].connect(context.destination);
time[k] = k * timeStep;
bufferSource[k].start(time[k]);
}
}
// distanceModel should be the distance model string like
// "linear", "inverse", or "exponential".
function createTestAndRun(context, distanceModel, should) {
// To test the distance models, we create a number of panners at
// uniformly spaced intervals on the z-axis. Each of these are
// started at equally spaced time intervals. After rendering the
// signals, we examine where each impulse is located and the
// attenuation of the impulse. The attenuation is compared
// against our expected attenuation.
createGraph(context, distanceModel, nodesToCreate);
return context.startRendering().then(
buffer => checkDistanceResult(buffer, distanceModel, should));
}
// The gain caused by the EQUALPOWER panning model, if we stay on the
// z axis, with the default orientations.
function equalPowerGain() {
return Math.SQRT1_2;
}
function checkDistanceResult(renderedBuffer, model, should) {
renderedData = renderedBuffer.getChannelData(0);
// The max allowed error between the actual gain and the expected
// value. This is determined experimentally. Set to 0 to see
// what the actual errors are.
let maxAllowedError = 2.2720e-6;
let success = true;
// Number of impulses we found in the rendered result.
let impulseCount = 0;
// Maximum relative error in the gain of the impulses.
let maxError = 0;
// Array of locations of the impulses that were not at the
// expected location. (Contains the actual and expected frame
// of the impulse.)
let impulsePositionErrors = new Array();
// Step through the rendered data to find all the non-zero points
// so we can find where our distance-attenuated impulses are.
// These are tested against the expected attenuations at that
// distance.
for (let k = 0; k < renderedData.length; ++k) {
if (renderedData[k] != 0) {
// Convert from string to index.
let distanceFunction = distanceModelFunction[model];
let expected =
distanceFunction(panner[impulseCount], 0, 0, position[impulseCount]);
// Adjust for the center-panning of the EQUALPOWER panning
// model that we're using.
expected *= equalPowerGain();
let error = Math.abs(renderedData[k] - expected) / Math.abs(expected);
maxError = Math.max(maxError, Math.abs(error));
should(renderedData[k]).beCloseTo(expected, {threshold: maxAllowedError});
// Keep track of any impulses that aren't where we expect them
// to be.
let expectedOffset = timeToSampleFrame(time[impulseCount], sampleRate);
if (k != expectedOffset) {
impulsePositionErrors.push({actual: k, expected: expectedOffset});
}
++impulseCount;
}
}
should(impulseCount, 'Number of impulses').beEqualTo(nodesToCreate);
should(maxError, 'Max error in distance gains')
.beLessThanOrEqualTo(maxAllowedError);
// Display any timing errors that we found.
if (impulsePositionErrors.length > 0) {
let actual = impulsePositionErrors.map(x => x.actual);
let expected = impulsePositionErrors.map(x => x.expected);
should(actual, 'Actual impulse positions found').beEqualToArray(expected);
}
}
Codebase Browser
chromium