<!doctype html>
<html>
<head>
<title>k-rate AudioParams with inputs for AudioBufferSourceNode</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/webaudio/resources/audit.js"></script>
<script src="/webaudio/resources/audit-util.js"></script>
</head>
<body>
<script>
let audit = Audit.createTaskRunner();
// Fairly abitrary sampleRate and somewhat duration
const sampleRate = 8000;
const testDuration = 0.25;
[['playbackRate', [1, 0], [2, testDuration]],
['detune', [-1200, 0], [1200, testDuration]]]
.forEach(param => {
audit.define(
{label: param[0], description: `AudioBufferSource ${param[0]}`},
async (task, should) => {
await doTest(should, {
prefix: task.label,
paramName: param[0],
startValue: param[1],
endValue: param[2]
});
task.done();
});
});
audit.run();
async function doTest(should, options) {
// Test k-rate automation of AudioBufferSourceNode with connected
// input.
//
// A reference source node is created with an automation on the
// selected AudioParam. For simplicity, we just use a linear ramp from
// the minValue to the maxValue of the AudioParam.
//
// The test node has an input signal connected to the AudioParam. This
// input signal is created to match the automation on the reference
// node.
//
// Finally, the output from the two nodes must be identical if k-rate
// inputs are working correctly.
//
// Options parameter is a dictionary with the following required
// members:
// prefix - prefix to use for the messages.
// paramName - Name of the AudioParam to be tested
let {prefix, paramName, startValue, endValue} = options;
let context = new OfflineAudioContext({
numberOfChannels: 2,
sampleRate: sampleRate,
length: testDuration * sampleRate
});
let merger = new ChannelMergerNode(
context, {numberOfInputs: context.destination.channelCount});
merger.connect(context.destination);
// Linear ramp to use for the buffer sources
let ramp = createLinearRampBuffer(context, context.length);
// Create the reference and test nodes.
let refNode;
let tstNode;
const nodeOptions = {buffer: ramp};
should(
() => refNode = new AudioBufferSourceNode(context, nodeOptions),
`${prefix}: refNode = new AudioBufferSourceNode(context, ${
JSON.stringify(nodeOptions)})`)
.notThrow();
should(
() => tstNode = new AudioBufferSourceNode(context, nodeOptions),
`${prefix}: tstNode = new AudioBufferSourceNode(context, ${
JSON.stringify(nodeOptions)})`)
.notThrow();
// Automate the AudioParam of the reference node with a linear ramp
should(
() => refNode[paramName].setValueAtTime(...startValue),
`${prefix}: refNode[${paramName}].setValueAtTime(${
startValue[0]}, ${startValue[1]})`)
.notThrow();
should(
() => refNode[paramName].linearRampToValueAtTime(...endValue),
`${prefix}: refNode[${paramName}].linearRampToValueAtTime(${
endValue[0]}, ${endValue[1]})`)
.notThrow();
// Create the input node and automate it so that it's output when added
// to the intrinsic value of the AudioParam we get the same values as
// the automations on the reference node.
// Compute the start and end values based on the defaultValue of the
// param and the desired startValue and endValue. The input is added to
// the intrinsic value of the AudioParam, so we need to account for
// that.
let mod;
should(
() => mod = new ConstantSourceNode(context, {offset: 0}),
`${prefix}: mod = new ConstantSourceNode(context, {offset: 0})`)
.notThrow();
let modStart = startValue[0] - refNode[paramName].defaultValue;
let modEnd = endValue[0] - refNode[paramName].defaultValue;
should(
() => mod.offset.setValueAtTime(modStart, startValue[1]),
`${prefix}: mod.offset.setValueAtTime(${modStart}, ${
startValue[1]})`)
.notThrow();
should(
() => mod.offset.linearRampToValueAtTime(modEnd, endValue[1]),
`${prefix}: mod.offset.linearRampToValueAtTime(${modEnd}, ${
endValue[1]})`)
.notThrow();
// Connect up everything.
should(
() => mod.connect(tstNode[paramName]),
`${prefix}: mod.connect(tstNode[${paramName}])`)
.notThrow();
refNode.connect(merger, 0, 0);
tstNode.connect(merger, 0, 1);
// Go!
refNode.start();
tstNode.start();
mod.start();
const buffer = await context.startRendering();
let expected = buffer.getChannelData(0);
let actual = buffer.getChannelData(1);
// Quick sanity check that output isn't zero. This means we messed up
// the connections or automations or the buffer source.
should(expected, `Expected k-rate ${paramName} AudioParam with input`)
.notBeConstantValueOf(0);
should(actual, `Actual k-rate ${paramName} AudioParam with input`)
.notBeConstantValueOf(0);
// The expected and actual results must be EXACTLY the same.
should(actual, `k-rate ${paramName} AudioParam with input`)
.beCloseToArray(expected, {absoluteThreshold: 0});
}
</script>
</body>
</html>
Codebase Browser
chromium