| <!doctype html> |
| <html> |
| <head> |
| <title>Test Biquad Tail-Time</title> |
| <script src="../../imported/w3c/web-platform-tests/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> |
| <script src="test-tail-time.js"></script> |
| </head> |
| |
| <body> |
| <script> |
| let audit = Audit.createTaskRunner(); |
| |
| let sampleRate = 16384; |
| let renderSeconds = 1; |
| |
| // For a lowpass filter: |
| // b0 = (1-cos(w0))/2 |
| // b1 = 1-cos(w0) |
| // b2 = (1-cos(w0))/2 |
| // a0 = 1 + alpha |
| // a1 = -2*cos(w0) |
| // a2 = 1 - alpha |
| // |
| // where alpha = sin(w0)/(2*10^(Q/20)) and w0 = 2*%pi*f0/Fs. |
| // |
| // Equivalently a1 = -2*cos(w0)/(1+alpha), a2 = (1-alpha)/(1+alpha). The |
| // poles of this filter are at |
| // |
| // cos(w0)/(1+alpha) +/- sqrt(alpha^2-sin(w0)^2)/(1+alpha) |
| // |
| // But alpha^2-sin(w0)^2 = sin(w0)^2*(1/4/10^(Q/10) - 1). Thus the poles |
| // are complex if 1/4/10^(Q/10) < 1; real distinct if 1/4/10^(Q/10) > 1; |
| // and repeated if 1/4/10^(Q/10) = 1. |
| |
| // Array of tests to run. |descripton| is the task description for |
| // audit.define. |parameters| is option for |testTailTime|. |
| let tests = [ |
| { |
| descripton: |
| {label: 'lpf-complex-roots', description: 'complex roots'}, |
| sampleRate: sampleRate, |
| renderDuration: renderSeconds, |
| parameters: { |
| prefix: 'LPF complex roots', |
| filterOptions: {type: 'lowpass', Q: 40, frequency: sampleRate / 4} |
| }, |
| // Node computed tail frame is 2079.4 which matches the real tail, so |
| // tail output should be exactly 0. |
| threshold: 0, |
| }, |
| { |
| descripton: { |
| label: 'lpf-real-distinct-roots', |
| description: 'real distinct roots' |
| }, |
| sampleRate: sampleRate, |
| renderDuration: renderSeconds, |
| parameters: { |
| prefix: 'LPF real distinct roots', |
| filterOptions: |
| {type: 'lowpass', Q: -50, frequency: sampleRate / 8} |
| }, |
| // Node computed tail frame is 1699 which matches the real tail, so |
| // tail output should be exactly 0. |
| threshold: 0, |
| }, |
| { |
| descripton: |
| {label: 'lpf-repeated-root', description: 'repeated real root'}, |
| sampleRate: sampleRate, |
| renderDuration: renderSeconds, |
| parameters: { |
| prefix: 'LPF repeated roots (approximately)', |
| // For a repeated root, we need 1/4/10^(Q/10) = 1, or Q = |
| // -10*log(4)/log(10). This isn't exactly representable as a float, |
| // we the roots might not actually be repeated. In fact the roots |
| // are actually complex at 6.402396e-5*exp(i*1.570796). |
| filterOptions: { |
| type: 'lowpass', |
| Q: -10 * Math.log10(4), |
| frequency: sampleRate / 4 |
| } |
| }, |
| // Node computed tail frame is 2.9 which matches the real tail, so |
| // tail output should be exactly 0. |
| threshold: 0, |
| }, |
| { |
| descripton: {label: 'lpf-real-roots-2', description: 'complex roots'}, |
| sampleRate: sampleRate, |
| renderDuration: renderSeconds, |
| parameters: { |
| prefix: 'LPF repeated roots 2', |
| // This tests an extreme case where approximate impulse response is |
| // h(n) = C*r^(n-1) and C < 1/32768. Thus, the impulse response is |
| // always less than the response threshold of 1/32768. |
| filterOptions: |
| {type: 'lowpass', Q: -100, frequency: sampleRate / 4} |
| }, |
| // Node computed tail frame is 0 which matches the real tail, so |
| // tail output should be exactly 0. |
| threshold: 0, |
| }, |
| { |
| descripton: 'huge tail', |
| // The BiquadFilter has an internal maximum tail of 30 sec so we want |
| // to render for at least 30 sec to test this. Use the smallest |
| // sample rate we can to limit memory and CPU usage! |
| sampleRate: 3000, |
| renderDuration: 31, |
| parameters: { |
| prefix: 'LPF repeated roots (approximately)', |
| hugeTaileTime: true, |
| // For the record, for this lowpass filter, the computed tail time |
| // is approximately 2830.23 sec, with poles at |
| // 0.999998960442086*exp(i*0.209439510236777). This is very close to |
| // being marginally stable. |
| filterOptions: { |
| type: 'lowpass', |
| Q: 100, |
| frequency: 100, |
| }, |
| // Node computed tail frame is 8.49069e6 which is clamped to 30 sec |
| // so tail output should be exactly 0 after 30 sec. |
| threshold: 0, |
| }, |
| }, |
| { |
| descripton: 'ginormous tail', |
| // Or this lowpass filter, the complex poles are actually computed to |
| // be on the unit circle so the tail infinite. This just tests that |
| // nothing bad happens in computing the tail time. Thus, any small |
| // sample rate and short duration for the test; the results aren't |
| // really interesting. (But they must pass, of course!) |
| sampleRate: 3000, |
| renderDuration: 0.25, |
| parameters: { |
| prefix: 'LPF repeated roots (approximately)', |
| filterOptions: { |
| type: 'lowpass', |
| Q: 500, |
| frequency: 100, |
| }, |
| }, |
| // Node computed tail frame is 90000 which matches the real tail, so |
| // tail output should be exactly 0. |
| threshold: 0, |
| } |
| ] |
| |
| // Define an appropriate task for each test. |
| tests.forEach(entry => { |
| audit.define(entry.descripton, (task, should) => { |
| let context = new OfflineAudioContext( |
| 1, entry.renderDuration * entry.sampleRate, entry.sampleRate); |
| testTailTime(should, context, entry.parameters) |
| .then(() => task.done()); |
| }); |
| }); |
| |
| audit.run(); |
| </script> |
| </body> |
| </html> |
