<!DOCTYPE html>
<html>
<head>
<title>
Test OscillatorNode with Negative Frequency
</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>
</head>
<body>
<script id="layout-test-code">
// Some arbitrary sample rate for the offline context. But it MUST be
// at least twice the oscillator frequency that we're using for the
// test. (Currently 440 Hz.)
let sampleRate = 16000;
// A fairly arbitrary duration that should have at least 1-2 sample
// periods of the oscillator (at a nominal 440 Hz).
let renderDuration = 0.1;
let renderFrames = renderDuration * sampleRate;
let audit = Audit.createTaskRunner();
audit.define('sine', (task, should) => {
runTest(should, {
message: 'Sum of positive and negative frequency sine oscillators',
type: 'sine',
threshold: 1.5349e-6
}).then(() => task.done());
});
audit.define('square', (task, should) => {
runTest(should, {
message: 'Sum of positive and negative frequency square oscillators',
type: 'square',
threshold: 1.1496e-5
}).then(() => task.done());
});
audit.define('sawtooth', (task, should) => {
runTest(should, {
message:
'Sum of positive and negative frequency sawtooth oscillators',
type: 'sawtooth',
threshold: 1.1506e-5
}).then(() => task.done());
});
audit.define('triangle', (task, should) => {
runTest(should, {
message:
'Sum of positive and negative frequency triangle oscillators',
type: 'triangle',
threshold: 1.0133e-5
}).then(() => task.done());
});
audit.define('auto-sawtooth', (task, should) => {
runTest(should, {
message:
'Sum of positive and negative frequency-ramped sawtooth oscillators',
type: 'sawtooth',
automation: {
type: 'linearRampToValueAtTime',
startTime: 0,
endTime: renderDuration / 2,
startFrequency: 440,
endFrequency: sampleRate / 4
},
threshold: 1.2368e-6
}).then(() => task.done());
});
audit.define('periodic-wave', (task, should) => {
// Test negative frequencies for a custom oscillator. Two channels are
// needed for the context; one for the expected result, and one for the
// actual, as explained below.
let context = new OfflineAudioContext(2, renderFrames, sampleRate);
let oscPositive = context.createOscillator();
let oscNegative = context.createOscillator();
// The Fourier coefficients for our custom oscillator. The actual
// values not important. The waveform for our custom oscillator is
//
// x(t) = sum(real[k]*cos(2*%pi*f*k/Fs), k, 1)
// + sum(imag[k]*sin(2*%pi*f*k/Fs), k, 0)
//
// With a negative frequency we have
//
// x(t) = sum(real[k]*cos(2*%pi*(-f)*k/Fs), k, 1)
// + sum(imag[k]*sin(2*%pi*(-f)*k/Fs), k, 0)
//
// = sum(real[k]*cos(2*%pi*f*k/Fs), k, 1)
// + sum((-imag[k])*sin(2*%pi*f*k/Fs), k, 0)
//
// That is, when the frequency is inverted, it behaves as if the
// coefficients of the imaginary part are inverted.
//
// Thus, the test is to create two custom oscillators. The second
// osillator uses the same PeriodicWave as the first except the
// imaginary coefficients are inverted. This second oscillator also
// gets a negative frequency. The combination of the two results in an
// oscillator that is the same as the first with gain of 2.
let real = [0, 1, 1];
let imag = [0, 1, 1];
let wavePositive = context.createPeriodicWave(
Float32Array.from(real), Float32Array.from(imag));
let waveNegative = context.createPeriodicWave(
Float32Array.from(real), Float32Array.from(imag.map(x => -x)));
oscPositive.setPeriodicWave(wavePositive);
oscNegative.setPeriodicWave(waveNegative);
oscPositive.frequency.value = 440;
oscNegative.frequency.value = -oscPositive.frequency.value;
let merger = context.createChannelMerger(2);
let gain = context.createGain();
// As explained above, the expected result should be positive frequency
// oscillator but with a gain of 2.
gain.gain.value = 2;
oscPositive.connect(gain);
gain.connect(merger, 0, 0);
// Sum the positive and negative frequency oscillators by using the same
// input to the merger.
oscPositive.connect(merger, 0, 1);
oscNegative.connect(merger, 0, 1);
merger.connect(context.destination);
oscPositive.start();
oscNegative.start();
context.startRendering()
.then(function(buffer) {
let expected = buffer.getChannelData(0);
let actual = buffer.getChannelData(1);
should(
actual,
'Sum of positive and negative frequency custom oscillators')
.beCloseToArray(expected, {absoluteThreshold: 2.2352e-6});
})
.then(() => task.done());
});
audit.run();
function runTest(should, options) {
// To test if negative frequencies work, create two oscillators. One
// has a positive frequency and the other has a negative frequency.
// Sum the oscillator outputs; the output should be zero because all of
// the builtin oscillator types are odd functions of frequency.
let context = new OfflineAudioContext(1, renderFrames, sampleRate);
let oscPositive = context.createOscillator();
let oscNegative = context.createOscillator();
oscPositive.type = options.type;
oscNegative.type = oscPositive.type;
if (options.automation) {
let {type, startTime, endTime, startFrequency, endFrequency} =
options.automation;
oscPositive.frequency.setValueAtTime(startFrequency, startTime);
oscPositive.frequency[type](endFrequency, endTime)
oscNegative.frequency.setValueAtTime(-startFrequency, startTime);
oscNegative.frequency[type](-endFrequency, endTime)
} else {
oscPositive.frequency.value = 440;
oscNegative.frequency.value = -oscPositive.frequency.value;
}
oscPositive.connect(context.destination);
oscNegative.connect(context.destination);
oscPositive.start();
oscNegative.start();
return context.startRendering().then(function(buffer) {
let result = buffer.getChannelData(0);
should(result, options.message)
.beCloseToArray(
new Float32Array(result.length),
{absoluteThreshold: options.threshold || 0});
});
}
</script>
</body>
</html>
Codebase Browser
chromium