blob: 8c63dbc8485b4e568ed4cf3b7b5ed7909ca95494 [file] [log] [blame]
<!doctype html>
<html>
<head>
<script src="../resources/js-test.js"></script>
<script src="resources/compatibility.js"></script>
<script src="resources/audio-testing.js"></script>
<script src="resources/realtimeanalyser-testing.js"></script>
<script src="resources/fft.js"></script>
<title>Test Analyser getFloatFrequencyData and getByteFrequencyData, No Smoothing</title>
</head>
<body>
<script>
description("Test AnalyserNode getFloatFrequencyData and getByteFrequencyData, no Smoothing");
window.jsTestIsAsync = true;
// Use a power of two to eliminate any round-off in the computation of the times for
// context.suspend().
var sampleRate = 32768;
// The largest FFT size for the analyser node is 32768. We want to render longer than this so
// that we have at least one complete buffer of data of 32768 samples.
var renderFrames = 2 * 32768;
var renderDuration = renderFrames / sampleRate;
var audit = Audit.createTaskRunner();
// Options for basic tests of the AnalyserNode frequency domain data. The thresholds are
// experimentally determined.
var testConfig = [{
order: 5,
// For this order, need to specify a higher minDecibels value for the analyser because the
// FFT doesn't get that small. This allows us to test that (a changed) minDecibels has an
// effect and that we properly clip the byte data.
minDecibels: -50,
floatRelError: 6.8964e-7,
}, {
order: 6,
floatRelError: 6.8366e-6
}, {
order: 7,
floatRelError: 1.4602e-6
}, {
order: 8,
floatRelError: 8.4828e-7
}, {
order: 9,
floatRelError: 1.6568e-5
}, {
order: 10,
floatRelError: 1.2765e-5
}, {
order: 11,
floatRelError: 8.4920e-6,
}, {
order: 12,
floatRelError: 4.3344e-7
}, {
order: 13,
floatRelError: 2.2798e-7
}, {
order: 14,
floatRelError: 1.1756e-7
}, {
order: 15,
floatRelError: 1.1675e-7
}];
// True if all of the basic tests passed.
var basicTestsPassed = true;
// Generate tests for each entry in testConfig.
for (var k = 0; k < testConfig.length; ++k) {
var name = testConfig[k].order + "-order FFT";
(function (config) {
audit.defineTask(name, function (done) {
basicFFTTest(config).then(done);
});
})(testConfig[k]);
}
// Just print a summary of the result of the above tests.
audit.defineTask("summarize basic tests", function (done) {
if (basicTestsPassed)
testPassed("Basic frequency data computed correctly.\n");
else
testFailed("Basic frequency data computed incorrectly.\n");
done();
});
// Test that smoothing isn't done and we have the expected data, calling getFloatFrequencyData
// twice at different times.
audit.defineTask("no smoothing", function (done) {
// Use 128-point FFT for the test. The actual order doesn't matter (but the error threshold
// depends on the order).
var options = {
order: 7,
smoothing: 0,
floatRelError: 1.2548e-6
};
var graph = createGraph(options);
var context = graph.context;
var analyser = graph.analyser;
// Be sure to suspend after the analyser fftSize so we get a full buffer of data. We will
// grab the FFT data to prime the pump for smoothing. We don't need to check the results
// (because this is tested above in the basicFFTTests).
var suspendFrame = Math.max(128, analyser.fftSize);
context.suspend(suspendFrame / sampleRate).then(function () {
// Grab the time and frequency data. But we don't care what values we get now; we just
// want to prime the analyser.
var freqData = new Float32Array(analyser.frequencyBinCount);
// Grab the frequency domain data
analyser.getFloatFrequencyData(freqData);
}).then(context.resume.bind(context));
// Grab another set of data after one rendering quantum. We will test this to make sure
// smoothing was not done.
suspendFrame += 128;
context.suspend(suspendFrame / sampleRate).then(function () {
var timeData = new Float32Array(analyser.fftSize);
var freqData = new Float32Array(analyser.frequencyBinCount);
// Grab the time domain and frequency domain data
analyser.getFloatTimeDomainData(timeData);
analyser.getFloatFrequencyData(freqData);
var expected = computeFFTMagnitude(timeData, options.order).map(linearToDb);
var comparison = compareFloatFreq(Math.pow(2, options.order) + "-point float FFT",
freqData, expected, options);
basicTestsPassed = basicTestsPassed && comparison.success;
if (comparison.success)
testPassed("Smoothing constant of 0 correctly handled.\n");
else
testFailed("Smoothing constant of 0 incorrectly handled.\n");
}).then(context.resume.bind(context));
context.startRendering().then(done);
});
audit.defineTask("finish", function (done) {
finishJSTest();
done();
});
audit.runTasks();
// Run a simple test of the AnalyserNode's frequency domain data. Both the float and byte
// frequency data are tested. The byte tests depend on the float tests being correct.
//
// The parameters of the test are given by |options| which is a property bag consisting of the
// following:
//
// order: Order of the FFT to test.
// smoothing: smoothing time constant for the analyser.
// minDecibels: min decibels value for the analyser.
// floatRelError: max allowed relative error for the float FFT data
function basicFFTTest(options) {
var graph = createGraph(options);
var context = graph.context;
var analyser = graph.analyser;
var suspendTime = Math.max(128, analyser.fftSize) / sampleRate;
context.suspend(suspendTime).then(function () {
var timeData = new Float32Array(analyser.fftSize);
var freqData = new Float32Array(analyser.frequencyBinCount);
// Grab the time domain and frequency domain data
analyser.getFloatTimeDomainData(timeData);
analyser.getFloatFrequencyData(freqData);
var expected = computeFFTMagnitude(timeData, options.order).map(linearToDb);
var comparison = compareFloatFreq(Math.pow(2, options.order) + "-point float FFT",
freqData, expected, options);
basicTestsPassed = basicTestsPassed && comparison.success;
var expected = comparison.expected;
// For the byte test to be better, check that there are some samples that are outside the
// range of minDecibels and maxDecibels. If there aren't the test should update the
// minDecibels and maxDecibels values for the analyser.
var minValue = Math.min(...expected);
var maxValue = Math.max(...expected);
basicTestsPassed = Should("Min FFT value", minValue)
.beLessThanOrEqualTo(analyser.minDecibels) && basicTestsPassed;
basicTestsPassed = Should("Max FFT value", maxValue)
.beGreaterThanOrEqualTo(analyser.maxDecibels) && basicTestsPassed;
// Test the byte frequency data.
var byteFreqData = new Uint8Array(analyser.frequencyBinCount);
var expectedByteData = new Float32Array(analyser.frequencyBinCount);
analyser.getByteFrequencyData(byteFreqData);
// Convert the expected float frequency data to byte data.
var expectedByteData = convertFloatToByte(expected, analyser.minDecibels,
analyser.maxDecibels);
basicTestsPassed = Should(analyser.fftSize + "-point byte FFT", byteFreqData, {
verbose: true
}).beCloseToArray(expectedByteData, 0) && basicTestsPassed;
}).then(context.resume.bind(context));
return context.startRendering();
}
</script>
</body>
</html>