| <!DOCTYPE html> |
| <html> |
| <head> |
| <title> |
| Test IIRFilter getFrequencyResponse() functionality |
| </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/biquad-filters.js"></script> |
| </head> |
| <body> |
| <script id="layout-test-code"> |
| let sampleRate = 48000; |
| // Some short duration; we're not actually looking at the rendered output. |
| let testDurationSec = 0.01; |
| |
| // Number of frequency samples to take. |
| let numberOfFrequencies = 1000; |
| |
| let audit = Audit.createTaskRunner(); |
| |
| |
| // Compute a set of linearly spaced frequencies. |
| function createFrequencies(nFrequencies, sampleRate) { |
| let frequencies = new Float32Array(nFrequencies); |
| let nyquist = sampleRate / 2; |
| let freqDelta = nyquist / nFrequencies; |
| |
| for (let k = 0; k < nFrequencies; ++k) { |
| frequencies[k] = k * freqDelta; |
| } |
| |
| return frequencies; |
| } |
| |
| audit.define('1-pole IIR', (task, should) => { |
| let context = new OfflineAudioContext( |
| 1, testDurationSec * sampleRate, sampleRate); |
| |
| let iir = context.createIIRFilter([1], [1, -0.9]); |
| let frequencies = |
| createFrequencies(numberOfFrequencies, context.sampleRate); |
| |
| let iirMag = new Float32Array(numberOfFrequencies); |
| let iirPhase = new Float32Array(numberOfFrequencies); |
| let trueMag = new Float32Array(numberOfFrequencies); |
| let truePhase = new Float32Array(numberOfFrequencies); |
| |
| // The IIR filter is |
| // H(z) = 1/(1 - 0.9*z^(-1)). |
| // |
| // The frequency response is |
| // H(exp(j*w)) = 1/(1 - 0.9*exp(-j*w)). |
| // |
| // Thus, the magnitude is |
| // |H(exp(j*w))| = 1/sqrt(1.81-1.8*cos(w)). |
| // |
| // The phase is |
| // arg(H(exp(j*w)) = atan(0.9*sin(w)/(.9*cos(w)-1)) |
| |
| let frequencyScale = Math.PI / (sampleRate / 2); |
| |
| for (let k = 0; k < frequencies.length; ++k) { |
| let omega = frequencyScale * frequencies[k]; |
| trueMag[k] = 1 / Math.sqrt(1.81 - 1.8 * Math.cos(omega)); |
| truePhase[k] = |
| Math.atan(0.9 * Math.sin(omega) / (0.9 * Math.cos(omega) - 1)); |
| } |
| |
| iir.getFrequencyResponse(frequencies, iirMag, iirPhase); |
| |
| // Thresholds were experimentally determined. |
| should(iirMag, '1-pole IIR Magnitude Response') |
| .beCloseToArray(trueMag, {absoluteThreshold: 2.8611e-6}); |
| should(iirPhase, '1-pole IIR Phase Response') |
| .beCloseToArray(truePhase, {absoluteThreshold: 1.7882e-7}); |
| |
| task.done(); |
| }); |
| |
| audit.define('compare IIR and biquad', (task, should) => { |
| // Create an IIR filter equivalent to the biquad filter. Compute the |
| // frequency response for both and verify that they are the same. |
| let context = new OfflineAudioContext( |
| 1, testDurationSec * sampleRate, sampleRate); |
| |
| let biquad = context.createBiquadFilter(); |
| let coef = createFilter( |
| biquad.type, biquad.frequency.value / (context.sampleRate / 2), |
| biquad.Q.value, biquad.gain.value); |
| |
| let iir = context.createIIRFilter( |
| [coef.b0, coef.b1, coef.b2], [1, coef.a1, coef.a2]); |
| |
| let frequencies = |
| createFrequencies(numberOfFrequencies, context.sampleRate); |
| let biquadMag = new Float32Array(numberOfFrequencies); |
| let biquadPhase = new Float32Array(numberOfFrequencies); |
| let iirMag = new Float32Array(numberOfFrequencies); |
| let iirPhase = new Float32Array(numberOfFrequencies); |
| |
| biquad.getFrequencyResponse(frequencies, biquadMag, biquadPhase); |
| iir.getFrequencyResponse(frequencies, iirMag, iirPhase); |
| |
| // Thresholds were experimentally determined. |
| should(iirMag, 'IIR Magnitude Response').beCloseToArray(biquadMag, { |
| absoluteThreshold: 2.7419e-5 |
| }); |
| should(iirPhase, 'IIR Phase Response').beCloseToArray(biquadPhase, { |
| absoluteThreshold: 2.7657e-5 |
| }); |
| |
| task.done(); |
| }); |
| |
| audit.define( |
| { |
| label: 'getFrequencyResponse', |
| description: 'Test out-of-bounds frequency values' |
| }, |
| (task, should) => { |
| let context = new OfflineAudioContext(1, 1, sampleRate); |
| let filter = new IIRFilterNode( |
| context, {feedforward: [1], feedback: [1, -.9]}); |
| |
| // Frequencies to test. These are all outside the valid range of |
| // frequencies of 0 to Nyquist. |
| let freq = new Float32Array(2); |
| freq[0] = -1; |
| freq[1] = context.sampleRate / 2 + 1; |
| |
| let mag = new Float32Array(freq.length); |
| let phase = new Float32Array(freq.length); |
| |
| filter.getFrequencyResponse(freq, mag, phase); |
| |
| // Verify that the returned magnitude and phase entries are alL NaN |
| // since the frequencies are outside the valid range |
| for (let k = 0; k < mag.length; ++k) { |
| should(mag[k], |
| 'Magnitude response at frequency ' + freq[k]) |
| .beNaN(); |
| } |
| |
| for (let k = 0; k < phase.length; ++k) { |
| should(phase[k], |
| 'Phase response at frequency ' + freq[k]) |
| .beNaN(); |
| } |
| |
| task.done(); |
| }); |
| |
| audit.run(); |
| </script> |
| </body> |
| </html> |
