зеркало из https://github.com/mozilla/gecko-dev.git
185 строки
5.5 KiB
JavaScript
185 строки
5.5 KiB
JavaScript
// Use a power of two to eliminate round-off when converting frames to time and
|
|
// vice versa.
|
|
let sampleRate = 32768;
|
|
|
|
let numberOfChannels = 1;
|
|
|
|
// Time step when each panner node starts. Make sure it starts on a frame
|
|
// boundary.
|
|
let timeStep = Math.floor(0.001 * sampleRate) / sampleRate;
|
|
|
|
// Length of the impulse signal.
|
|
let pulseLengthFrames = Math.round(timeStep * sampleRate);
|
|
|
|
// How many panner nodes to create for the test
|
|
let nodesToCreate = 100;
|
|
|
|
// Be sure we render long enough for all of our nodes.
|
|
let renderLengthSeconds = timeStep * (nodesToCreate + 1);
|
|
|
|
// These are global mostly for debugging.
|
|
let context;
|
|
let impulse;
|
|
let bufferSource;
|
|
let panner;
|
|
let position;
|
|
let time;
|
|
|
|
let renderedBuffer;
|
|
let renderedLeft;
|
|
let renderedRight;
|
|
|
|
function createGraph(context, nodeCount, positionSetter) {
|
|
bufferSource = new Array(nodeCount);
|
|
panner = new Array(nodeCount);
|
|
position = new Array(nodeCount);
|
|
time = new Array(nodeCount);
|
|
// Angle between panner locations. (nodeCount - 1 because we want
|
|
// to include both 0 and 180 deg.
|
|
let angleStep = Math.PI / (nodeCount - 1);
|
|
|
|
if (numberOfChannels == 2) {
|
|
impulse = createStereoImpulseBuffer(context, pulseLengthFrames);
|
|
} else
|
|
impulse = createImpulseBuffer(context, pulseLengthFrames);
|
|
|
|
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 = 'linear';
|
|
|
|
let angle = angleStep * k;
|
|
position[k] = {angle: angle, x: Math.cos(angle), z: Math.sin(angle)};
|
|
positionSetter(panner[k], position[k].x, 0, position[k].z);
|
|
|
|
bufferSource[k].connect(panner[k]);
|
|
panner[k].connect(context.destination);
|
|
|
|
// Start the source
|
|
time[k] = k * timeStep;
|
|
bufferSource[k].start(time[k]);
|
|
}
|
|
}
|
|
|
|
function createTestAndRun(
|
|
context, should, nodeCount, numberOfSourceChannels, positionSetter) {
|
|
numberOfChannels = numberOfSourceChannels;
|
|
|
|
createGraph(context, nodeCount, positionSetter);
|
|
|
|
return context.startRendering().then(buffer => checkResult(buffer, should));
|
|
}
|
|
|
|
// Map our position angle to the azimuth angle (in degrees).
|
|
//
|
|
// An angle of 0 corresponds to an azimuth of 90 deg; pi, to -90 deg.
|
|
function angleToAzimuth(angle) {
|
|
return 90 - angle * 180 / Math.PI;
|
|
}
|
|
|
|
// The gain caused by the EQUALPOWER panning model
|
|
function equalPowerGain(angle) {
|
|
let azimuth = angleToAzimuth(angle);
|
|
|
|
if (numberOfChannels == 1) {
|
|
let panPosition = (azimuth + 90) / 180;
|
|
|
|
let gainL = Math.cos(0.5 * Math.PI * panPosition);
|
|
let gainR = Math.sin(0.5 * Math.PI * panPosition);
|
|
|
|
return {left: gainL, right: gainR};
|
|
} else {
|
|
if (azimuth <= 0) {
|
|
let panPosition = (azimuth + 90) / 90;
|
|
|
|
let gainL = 1 + Math.cos(0.5 * Math.PI * panPosition);
|
|
let gainR = Math.sin(0.5 * Math.PI * panPosition);
|
|
|
|
return {left: gainL, right: gainR};
|
|
} else {
|
|
let panPosition = azimuth / 90;
|
|
|
|
let gainL = Math.cos(0.5 * Math.PI * panPosition);
|
|
let gainR = 1 + Math.sin(0.5 * Math.PI * panPosition);
|
|
|
|
return {left: gainL, right: gainR};
|
|
}
|
|
}
|
|
}
|
|
|
|
function checkResult(renderedBuffer, should) {
|
|
renderedLeft = renderedBuffer.getChannelData(0);
|
|
renderedRight = renderedBuffer.getChannelData(1);
|
|
|
|
// The max error we allow between the rendered impulse and the
|
|
// expected value. This value is experimentally determined. Set
|
|
// to 0 to make the test fail to see what the actual error is.
|
|
let maxAllowedError = 1.1597e-6;
|
|
|
|
let success = true;
|
|
|
|
// Number of impulses found in the rendered result.
|
|
let impulseCount = 0;
|
|
|
|
// Max (relative) error and the index of the maxima for the left
|
|
// and right channels.
|
|
let maxErrorL = 0;
|
|
let maxErrorIndexL = 0;
|
|
let maxErrorR = 0;
|
|
let maxErrorIndexR = 0;
|
|
|
|
// Number of impulses that don't match our expected locations.
|
|
let timeCount = 0;
|
|
|
|
// Locations of where the impulses aren't at the expected locations.
|
|
let timeErrors = new Array();
|
|
|
|
for (let k = 0; k < renderedLeft.length; ++k) {
|
|
// We assume that the left and right channels start at the same instant.
|
|
if (renderedLeft[k] != 0 || renderedRight[k] != 0) {
|
|
// The expected gain for the left and right channels.
|
|
let pannerGain = equalPowerGain(position[impulseCount].angle);
|
|
let expectedL = pannerGain.left;
|
|
let expectedR = pannerGain.right;
|
|
|
|
// Absolute error in the gain.
|
|
let errorL = Math.abs(renderedLeft[k] - expectedL);
|
|
let errorR = Math.abs(renderedRight[k] - expectedR);
|
|
|
|
if (Math.abs(errorL) > maxErrorL) {
|
|
maxErrorL = Math.abs(errorL);
|
|
maxErrorIndexL = impulseCount;
|
|
}
|
|
if (Math.abs(errorR) > maxErrorR) {
|
|
maxErrorR = Math.abs(errorR);
|
|
maxErrorIndexR = impulseCount;
|
|
}
|
|
|
|
// Keep track of the impulses that didn't show up where we
|
|
// expected them to be.
|
|
let expectedOffset = timeToSampleFrame(time[impulseCount], sampleRate);
|
|
if (k != expectedOffset) {
|
|
timeErrors[timeCount] = {actual: k, expected: expectedOffset};
|
|
++timeCount;
|
|
}
|
|
++impulseCount;
|
|
}
|
|
}
|
|
|
|
should(impulseCount, 'Number of impulses found').beEqualTo(nodesToCreate);
|
|
|
|
should(
|
|
timeErrors.map(x => x.actual),
|
|
'Offsets of impulses at the wrong position')
|
|
.beEqualToArray(timeErrors.map(x => x.expected));
|
|
|
|
should(maxErrorL, 'Error in left channel gain values')
|
|
.beLessThanOrEqualTo(maxAllowedError);
|
|
|
|
should(maxErrorR, 'Error in right channel gain values')
|
|
.beLessThanOrEqualTo(maxAllowedError);
|
|
}
|