<!DOCTYPE html>
<html>
<head>
<title>
Test Interpolation for AudioParam.setValueCurveAtTime
</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>
<title>
Test Interpolation for AudioParam.setValueCurveAtTime
</title>
</head>
<body>
<script id="layout-test-code">
// Play a constant signal through a gain node that is automated using
// setValueCurveAtTime with a 2-element curve. The output should be a
// linear change.
// Choose a sample rate that is a multiple of 128, the rendering quantum
// size. This makes the math work out to be nice numbers.
let sampleRate = 25600;
let testDurationSec = 1;
let testDurationFrames = testDurationSec * sampleRate;
// Where the curve starts and its duration. This MUST be less than the
// total rendering time.
let curveStartTime = 256 / sampleRate;
let curveDuration = 300 / sampleRate;
;
let curveValue = 0.75;
// At this time, the gain node goes to gain 1. This is used to make sure
// the value curve is propagated correctly until the next event.
let fullGainTime = 0.75;
// Thresholds use to determine if the test passes; these are
// experimentally determined. The SNR between the actual and expected
// result should be at least |snrThreshold|. The maximum difference
// betwen them should not exceed |maxErrorThreshold|.
let snrThreshold = 10000;
let maxErrorThreshold = 0;
let context;
let actualResult;
let expectedResult;
let audit = Audit.createTaskRunner();
// Array of test configs. Each config must specify curveStartTime,
// curveDuration, curveLength, fullGainTime, maxErrorThreshold, and
// snrThreshold.
let testConfigs = [
{
// The main test
curveStartTime: 256 / sampleRate,
curveDuration: 300 / sampleRate,
curveLength: 2,
fullGainTime: 0.75,
maxErrorThreshold: 5.9605e-8,
snrThreshold: 171.206
},
{
// Increase the curve length
curveStartTime: 256 / sampleRate,
curveDuration: 300 / sampleRate,
curveLength: 3,
fullGainTime: 0.75,
maxErrorThreshold: 5.9605e-8,
snrThreshold: 171.206
},
{
// Increase the curve length
curveStartTime: 256 / sampleRate,
curveDuration: 300 / sampleRate,
curveLength: 16,
fullGainTime: 0.75,
maxErrorThreshold: 5.9605e-8,
snrThreshold: 170.892
},
{
// Increase the curve length
curveStartTime: 256 / sampleRate,
curveDuration: 300 / sampleRate,
curveLength: 100,
fullGainTime: 0.75,
maxErrorThreshold: 1.1921e-7,
snrThreshold: 168.712
},
{
// Corner case with duration less than a frame!
curveStartTime: 256 / sampleRate,
curveDuration: 0.25 / sampleRate,
curveLength: 2,
fullGainTime: 0.75,
maxErrorThreshold: 0,
snrThreshold: 10000
},
{
// Short duration test
curveStartTime: 256 / sampleRate,
curveDuration: 2 / sampleRate,
curveLength: 2,
fullGainTime: 0.75,
maxErrorThreshold: 0,
snrThreshold: 10000
},
{
// Short duration test with many points.
curveStartTime: 256 / sampleRate,
curveDuration: 2 / sampleRate,
curveLength: 8,
fullGainTime: 0.75,
maxErrorThreshold: 0,
snrThreshold: 10000
},
{
// Long duration, big curve
curveStartTime: 256 / sampleRate,
curveDuration: .5,
curveLength: 1000,
fullGainTime: 0.75,
maxErrorThreshold: 5.9605e-8,
snrThreshold: 152.784
}
];
// Creates a function based on the test config that is suitable for use by
// defineTask().
function createTaskFunction(config) {
return function(task, should) {
runTest(should, config).then(() => task.done());
};
}
// Define a task for each config, in the order listed in testConfigs.
for (let k = 0; k < testConfigs.length; ++k) {
let config = testConfigs[k];
let name = k + ':curve=' + config.curveLength +
',duration=' + (config.curveDuration * sampleRate);
audit.define(name, createTaskFunction(config));
}
// Simple test from crbug.com/441471. Makes sure the end points and the
// middle point are interpolated correctly.
audit.define('crbug-441471', (task, should) => {
// Any sample rate should work; we pick something small such that the
// time end points are on a sampling point.
let context = new OfflineAudioContext(1, 5000, 5000)
// A constant source
let source = context.createBufferSource();
source.buffer = createConstantBuffer(context, 1, 1);
source.loop = true;
let gain = context.createGain();
let startTime = 0.7;
let duration = 0.2;
// Create the curve. The interpolated result should be just a straight
// line from -1 to 1 from time startTime to startTime + duration.
let c = new Float32Array(3);
c[0] = -1;
c[1] = 0;
c[2] = 1;
gain.gain.setValueCurveAtTime(c, startTime, duration);
source.connect(gain);
gain.connect(context.destination);
source.start();
context.startRendering()
.then(function(renderedBuffer) {
let data = renderedBuffer.getChannelData(0);
let endTime = startTime + duration;
let midPoint = (startTime + endTime) / 2;
should(
data[timeToSampleFrame(startTime, context.sampleRate)],
'Curve value at time ' + startTime)
.beEqualTo(c[0]);
// Due to round-off, the value at the midpoint is not exactly zero
// on arm64. See crbug.com/558563. The current value is
// experimentally determined.
should(
data[timeToSampleFrame(midPoint, context.sampleRate)],
'Curve value at time ' + midPoint)
.beCloseTo(0, {threshold: Math.pow(2, -51)});
should(
data[timeToSampleFrame(endTime, context.sampleRate)],
'Curve value at time ' + endTime)
.beEqualTo(c[2]);
})
.then(() => task.done());
});
function runTest(should, config) {
context = new OfflineAudioContext(1, testDurationFrames, sampleRate);
// A constant audio source of value 1.
let source = context.createBufferSource();
source.buffer = createConstantBuffer(context, 1, 1);
source.loop = true;
// The value curve for testing. Just to make things easy for testing,
// make the curve a simple ramp up to curveValue.
// TODO(rtoy): Maybe allow more complicated curves?
let curve = new Float32Array(config.curveLength);
for (let k = 0; k < config.curveLength; ++k) {
curve[k] = curveValue / (config.curveLength - 1) * k;
}
// A gain node that is to be automated using setValueCurveAtTime.
let gain = context.createGain();
gain.gain.value = 0;
gain.gain.setValueCurveAtTime(
curve, config.curveStartTime, config.curveDuration);
// This is to verify that setValueCurveAtTime ends appropriately.
gain.gain.setValueAtTime(1, config.fullGainTime);
source.connect(gain);
gain.connect(context.destination);
source.start();
// Some consistency checks on the test parameters
let prefix = 'Length ' + config.curveLength + ', duration ' +
config.curveDuration;
should(
config.curveStartTime + config.curveDuration,
prefix + ': Check: Curve end time')
.beLessThanOrEqualTo(testDurationSec);
should(config.fullGainTime, prefix + ': Check: Full gain start time')
.beLessThanOrEqualTo(testDurationSec);
should(config.fullGainTime, prefix + ': Check: Full gain start time')
.beGreaterThanOrEqualTo(
config.curveStartTime + config.curveDuration);
// Rock and roll!
return context.startRendering().then(checkResult(should, config));
}
// Return a function to check that the rendered result matches the
// expected result.
function checkResult(should, config) {
return function(renderedBuffer) {
let success = true;
actualResult = renderedBuffer.getChannelData(0);
expectedResult = computeExpectedResult(config);
// Compute the SNR and max absolute difference between the actual and
// expected result.
let SNR = 10 * Math.log10(computeSNR(actualResult, expectedResult));
let maxDiff = -1;
let posn = -1;
for (let k = 0; k < actualResult.length; ++k) {
let diff = Math.abs(actualResult[k] - expectedResult[k]);
if (maxDiff < diff) {
maxDiff = diff;
posn = k;
}
}
let prefix = 'Curve length ' + config.curveLength + ', duration ' +
config.curveDuration;
should(SNR, prefix + ': SNR')
.beGreaterThanOrEqualTo(config.snrThreshold);
should(maxDiff, prefix + ': Max difference')
.beLessThanOrEqualTo(config.maxErrorThreshold);
}
}
// Compute the expected result based on the config settings.
function computeExpectedResult(config) {
// The automation curve starts at |curveStartTime| and has duration
// |curveDuration|. So, the output should be zero until curveStartTime,
// linearly ramp up from there to |curveValue|, and then be constant 1
// from then to the end of the buffer.
let expected = new Float32Array(testDurationFrames);
let curveStartFrame = config.curveStartTime * sampleRate;
let curveEndFrame =
(config.curveStartTime + config.curveDuration) * sampleRate;
let fullGainFrame = config.fullGainTime * sampleRate;
let k;
// Zero out the start.
for (k = 0; k < curveStartFrame; ++k)
expected[k] = 0;
// Linearly ramp now. This assumes that the actual curve used is a
// linear ramp, even if there are many curve points.
let stepSize = curveValue / (config.curveDuration * sampleRate);
for (; k < curveEndFrame; ++k)
expected[k] = stepSize * (k - curveStartFrame);
// Hold it constant until the next event
for (; k < fullGainFrame; ++k)
expected[k] = curveValue;
// Amplitude is one for the rest of the test.
for (; k < testDurationFrames; ++k)
expected[k] = 1;
return expected;
}
audit.run();
</script>
</body>
</html>
Codebase Browser
chromium