<!DOCTYPE html>
<html>
<head>
<title>
Test Automation of PannerNode Positions
</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="../../resources/audit-util.js"></script>
<script src="../../resources/audit.js"></script>
<script src="../../resources/panner-formulas.js"></script>
</head>
<body>
<script id="layout-test-code">
let sampleRate = 48000;
// These tests are quite slow, so don't run for many frames. 256 frames
// should be enough to demonstrate that automations are working.
let renderFrames = 256;
let renderDuration = renderFrames / sampleRate;
let context;
let panner;
let audit = Audit.createTaskRunner();
// Set of tests for the panner node with automations applied to the
// position of the source.
let testConfigs = [
{
// Distance model parameters for the panner
distanceModel: {model: 'inverse', rolloff: 1},
// Initial location of the source
startPosition: [0, 0, 1],
// Final position of the source. For this test, we only want to move
// on the z axis which
// doesn't change the azimuth angle.
endPosition: [0, 0, 10000],
},
{
distanceModel: {model: 'inverse', rolloff: 1},
startPosition: [0, 0, 1],
// An essentially random end position, but it should be such that
// azimuth angle changes as
// we move from the start to the end.
endPosition: [20000, 30000, 10000],
errorThreshold: [
{
// Error threshold for 1-channel case
relativeThreshold: 4.8124e-7
},
{
// Error threshold for 2-channel case
relativeThreshold: 4.3267e-7
}
],
},
{
distanceModel: {model: 'exponential', rolloff: 1.5},
startPosition: [0, 0, 1],
endPosition: [20000, 30000, 10000],
errorThreshold:
[{relativeThreshold: 5.0783e-7}, {relativeThreshold: 5.2180e-7}]
},
{
distanceModel: {model: 'linear', rolloff: 1},
startPosition: [0, 0, 1],
endPosition: [20000, 30000, 10000],
errorThreshold: [
{relativeThreshold: 6.5324e-6}, {relativeThreshold: 6.5756e-6}
]
}
];
for (let k = 0; k < testConfigs.length; ++k) {
let config = testConfigs[k];
let tester = function(c, channelCount) {
return (task, should) => {
runTest(should, c, channelCount).then(() => task.done());
}
};
let baseTestName = config.distanceModel.model +
' rolloff: ' + config.distanceModel.rolloff;
// Define tasks for both 1-channel and 2-channel
audit.define(k + ': 1-channel ' + baseTestName, tester(config, 1));
audit.define(k + ': 2-channel ' + baseTestName, tester(config, 2));
}
audit.run();
function runTest(should, options, channelCount) {
// Output has 5 channels: channels 0 and 1 are for the stereo output of
// the panner node. Channels 2-5 are the for automation of the x,y,z
// coordinate so that we have actual coordinates used for the panner
// automation.
context = new OfflineAudioContext(5, renderFrames, sampleRate);
// Stereo source for the panner.
let source = context.createBufferSource();
source.buffer = createConstantBuffer(
context, renderFrames, channelCount == 1 ? 1 : [1, 2]);
panner = context.createPanner();
panner.distanceModel = options.distanceModel.model;
panner.rolloffFactor = options.distanceModel.rolloff;
panner.panningModel = 'equalpower';
// Source and gain node for the z-coordinate calculation.
let dist = context.createBufferSource();
dist.buffer = createConstantBuffer(context, 1, 1);
dist.loop = true;
let gainX = context.createGain();
let gainY = context.createGain();
let gainZ = context.createGain();
dist.connect(gainX);
dist.connect(gainY);
dist.connect(gainZ);
// Set the gain automation to match the z-coordinate automation of the
// panner.
// End the automation some time before the end of the rendering so we
// can verify that automation has the correct end time and value.
let endAutomationTime = 0.75 * renderDuration;
gainX.gain.setValueAtTime(options.startPosition[0], 0);
gainX.gain.linearRampToValueAtTime(
options.endPosition[0], endAutomationTime);
gainY.gain.setValueAtTime(options.startPosition[1], 0);
gainY.gain.linearRampToValueAtTime(
options.endPosition[1], endAutomationTime);
gainZ.gain.setValueAtTime(options.startPosition[2], 0);
gainZ.gain.linearRampToValueAtTime(
options.endPosition[2], endAutomationTime);
dist.start();
// Splitter and merger to map the panner output and the z-coordinate
// automation to the correct channels in the destination.
let splitter = context.createChannelSplitter(2);
let merger = context.createChannelMerger(5);
source.connect(panner);
// Split the output of the panner to separate channels
panner.connect(splitter);
// Merge the panner outputs and the z-coordinate output to the correct
// destination channels.
splitter.connect(merger, 0, 0);
splitter.connect(merger, 1, 1);
gainX.connect(merger, 0, 2);
gainY.connect(merger, 0, 3);
gainZ.connect(merger, 0, 4);
merger.connect(context.destination);
// Initialize starting point of the panner.
panner.positionX.setValueAtTime(options.startPosition[0], 0);
panner.positionY.setValueAtTime(options.startPosition[1], 0);
panner.positionZ.setValueAtTime(options.startPosition[2], 0);
// Automate z coordinate to move away from the listener
panner.positionX.linearRampToValueAtTime(
options.endPosition[0], 0.75 * renderDuration);
panner.positionY.linearRampToValueAtTime(
options.endPosition[1], 0.75 * renderDuration);
panner.positionZ.linearRampToValueAtTime(
options.endPosition[2], 0.75 * renderDuration);
source.start();
// Go!
return context.startRendering().then(function(renderedBuffer) {
// Get the panner outputs
let data0 = renderedBuffer.getChannelData(0);
let data1 = renderedBuffer.getChannelData(1);
let xcoord = renderedBuffer.getChannelData(2);
let ycoord = renderedBuffer.getChannelData(3);
let zcoord = renderedBuffer.getChannelData(4);
// We're doing a linear ramp on the Z axis with the equalpower panner,
// so the equalpower panning gain remains constant. We only need to
// model the distance effect.
// Compute the distance gain
let distanceGain = new Float32Array(xcoord.length);
;
if (panner.distanceModel === 'inverse') {
for (let k = 0; k < distanceGain.length; ++k) {
distanceGain[k] =
inverseDistance(panner, xcoord[k], ycoord[k], zcoord[k])
}
} else if (panner.distanceModel === 'linear') {
for (let k = 0; k < distanceGain.length; ++k) {
distanceGain[k] =
linearDistance(panner, xcoord[k], ycoord[k], zcoord[k])
}
} else if (panner.distanceModel === 'exponential') {
for (let k = 0; k < distanceGain.length; ++k) {
distanceGain[k] =
exponentialDistance(panner, xcoord[k], ycoord[k], zcoord[k])
}
}
// Compute the expected result. Since we're on the z-axis, the left
// and right channels pass through the equalpower panner unchanged.
// Only need to apply the distance gain.
let buffer0 = source.buffer.getChannelData(0);
let buffer1 =
channelCount == 2 ? source.buffer.getChannelData(1) : buffer0;
let azimuth = new Float32Array(buffer0.length);
for (let k = 0; k < data0.length; ++k) {
azimuth[k] = calculateAzimuth(
[xcoord[k], ycoord[k], zcoord[k]],
[
context.listener.positionX.value,
context.listener.positionY.value,
context.listener.positionZ.value
],
[
context.listener.forwardX.value,
context.listener.forwardY.value,
context.listener.forwardZ.value
],
[
context.listener.upX.value, context.listener.upY.value,
context.listener.upZ.value
]);
}
let expected = applyPanner(azimuth, buffer0, buffer1, channelCount);
let expected0 = expected.left;
let expected1 = expected.right;
for (let k = 0; k < expected0.length; ++k) {
expected0[k] *= distanceGain[k];
expected1[k] *= distanceGain[k];
}
let info = options.distanceModel.model +
', rolloff: ' + options.distanceModel.rolloff;
let prefix = channelCount + '-channel ' +
'[' + options.startPosition[0] + ', ' + options.startPosition[1] +
', ' + options.startPosition[2] + '] -> [' +
options.endPosition[0] + ', ' + options.endPosition[1] + ', ' +
options.endPosition[2] + ']: ';
let errorThreshold = 0;
if (options.errorThreshold)
errorThreshold = options.errorThreshold[channelCount - 1]
should(data0, prefix + 'distanceModel: ' + info + ', left channel')
.beCloseToArray(expected0, {absoluteThreshold: errorThreshold});
should(data1, prefix + 'distanceModel: ' + info + ', right channel')
.beCloseToArray(expected1, {absoluteThreshold: errorThreshold});
});
}
</script>
</body>
</html>
Codebase Browser
chromium