third_party/WebKit/LayoutTests/webaudio/IIRFilter/iirfilter.html - chromium/src - Git at Google

 <!DOCTYPE html>
 <html>
   <head>
     <title>
       Test Basic IIRFilterNode Operation
     </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 = 24000;
       let testDurationSec = 0.25;
       let testFrames = testDurationSec * sampleRate;

       let audit = Audit.createTaskRunner();

       audit.define('coefficient-normalization', (task, should) => {
         // Test that the feedback coefficients are normalized.  Do this be
         // creating two IIRFilterNodes.  One has normalized coefficients, and
         // one doesn't.  Compute the difference and make sure they're the same.
         let context = new OfflineAudioContext(2, testFrames, sampleRate);

         // Use a simple impulse as the source.
         let buffer = context.createBuffer(1, 1, sampleRate);
         buffer.getChannelData(0)[0] = 1;
         let source = context.createBufferSource();
         source.buffer = buffer;

         // Gain node for computing the difference between the filters.
         let gain = context.createGain();
         gain.gain.value = -1;

         // The IIR filters.  Use a common feedforward array.
         let ff = [1];

         let fb1 = [1, .9];

         let fb2 = new Float64Array(2);
         // Scale the feedback coefficients by an arbitrary factor.
         let coefScaleFactor = 2;
         for (let k = 0; k < fb2.length; ++k) {
           fb2[k] = coefScaleFactor * fb1[k];
         }

         let iir1;
         let iir2;

         should(function() {
           iir1 = context.createIIRFilter(ff, fb1);
         }, 'createIIRFilter with normalized coefficients').notThrow();

         should(function() {
           iir2 = context.createIIRFilter(ff, fb2);
         }, 'createIIRFilter with unnormalized coefficients').notThrow();

         // Create the graph.  The output of iir1 (normalized coefficients) is
         // channel 0, and the output of iir2 (unnormalized coefficients), with
         // appropriate scaling, is channel 1.
         let merger = context.createChannelMerger(2);
         source.connect(iir1);
         source.connect(iir2);
         iir1.connect(merger, 0, 0);
         iir2.connect(gain);

         // The gain for the gain node should be set to compensate for the
         // scaling of the coefficients.  Since iir2 has scaled the coefficients
         // by coefScaleFactor, the output is reduced by the same factor, so
         // adjust the gain to scale the output of iir2 back up.
         gain.gain.value = coefScaleFactor;
         gain.connect(merger, 0, 1);

         merger.connect(context.destination);

         source.start();

         // Rock and roll!

         context.startRendering()
             .then(function(result) {
               // Find the max amplitude of the result, which should be near
               // zero.
               let iir1Data = result.getChannelData(0);
               let iir2Data = result.getChannelData(1);

               // Threshold isn't exactly zero because the arithmetic is done
               // differently between the IIRFilterNode and the BiquadFilterNode.
               should(
                   iir2Data,
                   'Output of IIR filter with unnormalized coefficients')
                   .beCloseToArray(iir1Data, {absoluteThreshold: 2.1958e-38});
             })
             .then(() => task.done());
       });

       audit.define('one-zero', (task, should) => {
         // Create a simple 1-zero filter and compare with the expected output.
         let context = new OfflineAudioContext(1, testFrames, sampleRate);

         // Use a simple impulse as the source
         let buffer = context.createBuffer(1, 1, sampleRate);
         buffer.getChannelData(0)[0] = 1;
         let source = context.createBufferSource();
         source.buffer = buffer;

         // The filter is y(n) = 0.5*(x(n) + x(n-1)), a simple 2-point moving
         // average.  This is rather arbitrary; keep it simple.

         let iir = context.createIIRFilter([0.5, 0.5], [1]);

         // Create the graph
         source.connect(iir);
         iir.connect(context.destination);

         // Rock and roll!
         source.start();

         context.startRendering()
             .then(function(result) {
               let actual = result.getChannelData(0);
               let expected = new Float64Array(testFrames);
               // The filter is a simple 2-point moving average of an impulse, so
               // the first two values are non-zero and the rest are zero.
               expected[0] = 0.5;
               expected[1] = 0.5;
               should(actual, 'IIR 1-zero output').beCloseToArray(expected, {
                 absoluteThreshold: 0
               });
             })
             .then(() => task.done());
       });

       audit.define('one-pole', (task, should) => {
         // Create a simple 1-pole filter and compare with the expected output.

         // The filter is y(n) + c*y(n-1)= x(n).  The analytical response is
         // (-c)^n, so choose a suitable number of frames to run the test for
         // where the output isn't flushed to zero.
         let c = 0.9;
         let eps = 1e-20;
         let duration = Math.floor(Math.log(eps) / Math.log(Math.abs(c)));
         let context = new OfflineAudioContext(1, duration, sampleRate);

         // Use a simple impulse as the source
         let buffer = context.createBuffer(1, 1, sampleRate);
         buffer.getChannelData(0)[0] = 1;
         let source = context.createBufferSource();
         source.buffer = buffer;

         let iir = context.createIIRFilter([1], [1, c]);

         // Create the graph
         source.connect(iir);
         iir.connect(context.destination);

         // Rock and roll!
         source.start();

         context.startRendering()
             .then(function(result) {
               let actual = result.getChannelData(0);
               let expected = new Float64Array(actual.length);

               // The filter is a simple 1-pole filter: y(n) = -c*y(n-k)+x(n),
               // with an impulse as the input.
               expected[0] = 1;
               for (k = 1; k < testFrames; ++k) {
                 expected[k] = -c * expected[k - 1];
               }

               // Threshold isn't exactly zero due to round-off in the
               // single-precision IIRFilterNode computations versus the
               // double-precision Javascript computations.
               should(actual, 'IIR 1-pole output').beCloseToArray(expected, {
                 absoluteThreshold: 2.7657e-8
               });
             })
             .then(() => task.done());
       });

       // Return a function suitable for use as a defineTask function.  This
       // function creates an IIRFilterNode equivalent to the specified
       // BiquadFilterNode and compares the outputs.  The outputs from the two
       // filters should be virtually identical.
       function testWithBiquadFilter(filterType, errorThreshold, snrThreshold) {
         return (task, should) => {
           let context = new OfflineAudioContext(2, testFrames, sampleRate);

           // Use a constant (step function) as the source
           let buffer = createConstantBuffer(context, testFrames, 1);
           let source = context.createBufferSource();
           source.buffer = buffer;


           // Create the biquad.  Choose some rather arbitrary values for Q and
           // gain for the biquad so that the shelf filters aren't identical.
           let biquad = context.createBiquadFilter();
           biquad.type = filterType;
           biquad.Q.value = 10;
           biquad.gain.value = 10;

           // Create the equivalent IIR Filter node by computing the coefficients
           // of the given biquad filter type.
           let nyquist = sampleRate / 2;
           let coef = createFilter(
               filterType, biquad.frequency.value / nyquist, biquad.Q.value,
               biquad.gain.value);

           let iir = context.createIIRFilter(
               [coef.b0, coef.b1, coef.b2], [1, coef.a1, coef.a2]);

           let merger = context.createChannelMerger(2);
           // Create the graph
           source.connect(biquad);
           source.connect(iir);

           biquad.connect(merger, 0, 0);
           iir.connect(merger, 0, 1);

           merger.connect(context.destination);

           // Rock and roll!
           source.start();

           context.startRendering()
               .then(function(result) {
                 // Find the max amplitude of the result, which should be near
                 // zero.
                 let expected = result.getChannelData(0);
                 let actual = result.getChannelData(1);

                 // On MacOSX, WebAudio uses an optimized Biquad implementation
                 // that is different from the implementation used for Linux and
                 // Windows.  This will cause the output to differ, even if the
                 // threshold passes.  Thus, only print out a very small number
                 // of elements of the array where we have tested that they are
                 // consistent.
                 should(actual, 'IIRFilter for Biquad ' + filterType)
                     .beCloseToArray(expected, errorThreshold);

                 let snr = 10 * Math.log10(computeSNR(actual, expected));
                 should(snr, 'SNR for IIRFIlter for Biquad ' + filterType)
                     .beGreaterThanOrEqualTo(snrThreshold);
               })
               .then(() => task.done());
         };
       }

       // Thresholds here are experimentally determined.
       let biquadTestConfigs = [
         {
           filterType: 'lowpass',
           snrThreshold: 91.221,
           errorThreshold: {relativeThreshold: 4.9834e-5}
         },
         {
           filterType: 'highpass',
           snrThreshold: 105.4590,
           errorThreshold: {absoluteThreshold: 2.9e-6, relativeThreshold: 3e-5}
         },
         {
           filterType: 'bandpass',
           snrThreshold: 104.060,
           errorThreshold: {absoluteThreshold: 2e-7, relativeThreshold: 8.7e-4}
         },
         {
           filterType: 'notch',
           snrThreshold: 91.312,
           errorThreshold: {absoluteThreshold: 0, relativeThreshold: 4.22e-5}
         },
         {
           filterType: 'allpass',
           snrThreshold: 91.319,
           errorThreshold: {absoluteThreshold: 0, relativeThreshold: 4.31e-5}
         },
         {
           filterType: 'lowshelf',
           snrThreshold: 90.609,
           errorThreshold: {absoluteThreshold: 0, relativeThreshold: 2.98e-5}
         },
         {
           filterType: 'highshelf',
           snrThreshold: 103.159,
           errorThreshold: {absoluteThreshold: 0, relativeThreshold: 1.24e-5}
         },
         {
           filterType: 'peaking',
           snrThreshold: 91.504,
           errorThreshold: {absoluteThreshold: 0, relativeThreshold: 5.05e-5}
         }
       ];

       // Create a set of tasks based on biquadTestConfigs.
       for (k = 0; k < biquadTestConfigs.length; ++k) {
         let config = biquadTestConfigs[k];
         let name = k + ': ' + config.filterType;
         audit.define(
             name,
             testWithBiquadFilter(
                 config.filterType, config.errorThreshold, config.snrThreshold));
       }

       audit.define('multi-channel', (task, should) => {
         // Multi-channel test.  Create a biquad filter and the equivalent IIR
         // filter.  Filter the same multichannel signal and compare the results.
         let nChannels = 3;
         let context =
             new OfflineAudioContext(nChannels, testFrames, sampleRate);

         // Create a set of oscillators as the multi-channel source.
         let source = [];

         for (k = 0; k < nChannels; ++k) {
           source[k] = context.createOscillator();
           source[k].type = 'sawtooth';
           // The frequency of the oscillator is pretty arbitrary, but each
           // oscillator should have a different frequency.
           source[k].frequency.value = 100 + k * 100;
         }

         let merger = context.createChannelMerger(3);

         let biquad = context.createBiquadFilter();

         // Create the equivalent IIR Filter node.
         let nyquist = sampleRate / 2;
         let coef = createFilter(
             biquad.type, biquad.frequency.value / nyquist, biquad.Q.value,
             biquad.gain.value);
         let fb = [1, coef.a1, coef.a2];
         let ff = [coef.b0, coef.b1, coef.b2];

         let iir = context.createIIRFilter(ff, fb);
         // Gain node to compute the difference between the IIR and biquad
         // filter.
         let gain = context.createGain();
         gain.gain.value = -1;

         // Create the graph.
         for (k = 0; k < nChannels; ++k)
           source[k].connect(merger, 0, k);

         merger.connect(biquad);
         merger.connect(iir);
         iir.connect(gain);
         biquad.connect(context.destination);
         gain.connect(context.destination);

         for (k = 0; k < nChannels; ++k)
           source[k].start();

         context.startRendering()
             .then(function(result) {
               let errorThresholds = [3.7671e-5, 3.0071e-5, 2.6241e-5];

               // Check the difference signal on each channel
               for (channel = 0; channel < result.numberOfChannels; ++channel) {
                 // Find the max amplitude of the result, which should be near
                 // zero.
                 let data = result.getChannelData(channel);
                 let maxError =
                     data.reduce(function(reducedValue, currentValue) {
                       return Math.max(reducedValue, Math.abs(currentValue));
                     });

                 should(
                     maxError,
                     'Max difference between IIR and Biquad on channel ' +
                         channel)
                     .beLessThanOrEqualTo(errorThresholds[channel]);
               }

             })
             .then(() => task.done());
       });

       // Apply an IIRFilter to the given input signal.
       //
       // IIR filter in the time domain is
       //
       //   y[n] = sum(ff[k]*x[n-k], k, 0, M) - sum(fb[k]*y[n-k], k, 1, N)
       //
       function iirFilter(input, feedforward, feedback) {
         // For simplicity, create an x buffer that contains the input, and a y
         // buffer that contains the output.  Both of these buffers have an
         // initial work space to implement the initial memory of the filter.
         let workSize = Math.max(feedforward.length, feedback.length);
         let x = new Float32Array(input.length + workSize);

         // Float64 because we want to match the implementation that uses doubles
         // to minimize roundoff.
         let y = new Float64Array(input.length + workSize);

         // Copy the input over.
         for (let k = 0; k < input.length; ++k)
           x[k + feedforward.length] = input[k];

         // Run the filter
         for (let n = 0; n < input.length; ++n) {
           let index = n + workSize;
           let yn = 0;
           for (let k = 0; k < feedforward.length; ++k)
             yn += feedforward[k] * x[index - k];
           for (let k = 0; k < feedback.length; ++k)
             yn -= feedback[k] * y[index - k];

           y[index] = yn;
         }

         return y.slice(workSize).map(Math.fround);
       }

       // Cascade the two given biquad filters to create one IIR filter.
       function cascadeBiquads(f1Coef, f2Coef) {
         // The biquad filters are:
         //
         // f1 = (b10 + b11/z + b12/z^2)/(1 + a11/z + a12/z^2);
         // f2 = (b20 + b21/z + b22/z^2)/(1 + a21/z + a22/z^2);
         //
         // To cascade them, multiply the two transforms together to get a fourth
         // order IIR filter.

         let numProduct = [
           f1Coef.b0 * f2Coef.b0, f1Coef.b0 * f2Coef.b1 + f1Coef.b1 * f2Coef.b0,
           f1Coef.b0 * f2Coef.b2 + f1Coef.b1 * f2Coef.b1 + f1Coef.b2 * f2Coef.b0,
           f1Coef.b1 * f2Coef.b2 + f1Coef.b2 * f2Coef.b1, f1Coef.b2 * f2Coef.b2
         ];

         let denProduct = [
           1, f2Coef.a1 + f1Coef.a1,
           f2Coef.a2 + f1Coef.a1 * f2Coef.a1 + f1Coef.a2,
           f1Coef.a1 * f2Coef.a2 + f1Coef.a2 * f2Coef.a1, f1Coef.a2 * f2Coef.a2
         ];

         return {
           ff: numProduct, fb: denProduct
         }
       }

       // Find the magnitude of the root of the quadratic that has the maximum
       // magnitude.
       //
       // The quadratic is z^2 + a1 * z + a2 and we want the root z that has the
       // largest magnitude.
       function largestRootMagnitude(a1, a2) {
         let discriminant = a1 * a1 - 4 * a2;
         if (discriminant < 0) {
           // Complex roots:  -a1/2 +/- i*sqrt(-d)/2.  Thus the magnitude of each
           // root is the same and is sqrt(a1^2/4 + |d|/4)
           let d = Math.sqrt(-discriminant);
           return Math.hypot(a1 / 2, d / 2);
         } else {
           // Real roots
           let d = Math.sqrt(discriminant);
           return Math.max(Math.abs((-a1 + d) / 2), Math.abs((-a1 - d) / 2));
         }
       }

       audit.define('4th-order-iir', (task, should) => {
         // Cascade 2 lowpass biquad filters and compare that with the equivalent
         // 4th order IIR filter.

         let nyquist = sampleRate / 2;
         // Compute the coefficients of a lowpass filter.

         // First some preliminary stuff.  Compute the coefficients of the
         // biquad.  This is used to figure out how frames to use in the test.
         let biquadType = 'lowpass';
         let biquadCutoff = 350;
         let biquadQ = 5;
         let biquadGain = 1;

         let coef = createFilter(
             biquadType, biquadCutoff / nyquist, biquadQ, biquadGain);

         // Cascade the biquads together to create an equivalent IIR filter.
         let cascade = cascadeBiquads(coef, coef);

         // Since we're cascading two identical biquads, the root of denominator
         // of the IIR filter is repeated, so the root of the denominator with
         // the largest magnitude occurs twice.  The impulse response of the IIR
         // filter will be roughly c*(r*r)^n at time n, where r is the root of
         // largest magnitude.  This approximation gets better as n increases.
         // We can use this to get a rough idea of when the response has died
         // down to a small value.

         // This is the value we will use to determine how many frames to render.
         // Rendering too many is a waste of time and also makes it hard to
         // compare the actual result to the expected because the magnitudes are
         // so small that they could be mostly round-off noise.
         //
         // Find magnitude of the root with largest magnitude
         let rootMagnitude = largestRootMagnitude(coef.a1, coef.a2);

         // Find n such that |r|^(2*n) <= eps.  That is, n = log(eps)/(2*log(r)).
         // Somewhat arbitrarily choose eps = 1e-20;
         let eps = 1e-20;
         let framesForTest =
             Math.floor(Math.log(eps) / (2 * Math.log(rootMagnitude)));

         // We're ready to create the graph for the test.  The offline context
         // has two channels: channel 0 is the expected (cascaded biquad) result
         // and channel 1 is the actual IIR filter result.
         let context = new OfflineAudioContext(2, framesForTest, sampleRate);

         // Use a simple impulse with a large (arbitrary) amplitude as the source
         let amplitude = 1;
         let buffer = context.createBuffer(1, testFrames, sampleRate);
         buffer.getChannelData(0)[0] = amplitude;
         let source = context.createBufferSource();
         source.buffer = buffer;

         // Create the two biquad filters.  Doesn't really matter what, but for
         // simplicity we choose identical lowpass filters with the same
         // parameters.
         let biquad1 = context.createBiquadFilter();
         biquad1.type = biquadType;
         biquad1.frequency.value = biquadCutoff;
         biquad1.Q.value = biquadQ;

         let biquad2 = context.createBiquadFilter();
         biquad2.type = biquadType;
         biquad2.frequency.value = biquadCutoff;
         biquad2.Q.value = biquadQ;

         let iir = context.createIIRFilter(cascade.ff, cascade.fb);

         // Create the merger to get the signals into multiple channels
         let merger = context.createChannelMerger(2);

         // Create the graph, filtering the source through two biquads.
         source.connect(biquad1);
         biquad1.connect(biquad2);
         biquad2.connect(merger, 0, 0);

         source.connect(iir);
         iir.connect(merger, 0, 1);

         merger.connect(context.destination);

         // Now filter the source through the IIR filter.
         let y = iirFilter(buffer.getChannelData(0), cascade.ff, cascade.fb);

         // Rock and roll!
         source.start();

         context.startRendering()
             .then(function(result) {
               let expected = result.getChannelData(0);
               let actual = result.getChannelData(1);

               should(actual, '4-th order IIRFilter (biquad ref)')
                   .beCloseToArray(expected, {
                     // Thresholds experimentally determined.
                     absoluteThreshold: 1.59e-7,
                     relativeThreshold: 2.11e-5,
                   });

               let snr = 10 * Math.log10(computeSNR(actual, expected));
               should(snr, 'SNR of 4-th order IIRFilter (biquad ref)')
                   .beGreaterThanOrEqualTo(108.947);
             })
             .then(() => task.done());
       });

       audit.run();
     </script>
   </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<title>
	Test Basic IIRFilterNode Operation
	</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 = 24000;
	let testDurationSec = 0.25;
	let testFrames = testDurationSec * sampleRate;

	let audit = Audit.createTaskRunner();

	audit.define('coefficient-normalization', (task, should) => {
	// Test that the feedback coefficients are normalized. Do this be
	// creating two IIRFilterNodes. One has normalized coefficients, and
	// one doesn't. Compute the difference and make sure they're the same.
	let context = new OfflineAudioContext(2, testFrames, sampleRate);

	// Use a simple impulse as the source.
	let buffer = context.createBuffer(1, 1, sampleRate);
	buffer.getChannelData(0)[0] = 1;
	let source = context.createBufferSource();
	source.buffer = buffer;

	// Gain node for computing the difference between the filters.
	let gain = context.createGain();
	gain.gain.value = -1;

	// The IIR filters. Use a common feedforward array.
	let ff = [1];

	let fb1 = [1, .9];

	let fb2 = new Float64Array(2);
	// Scale the feedback coefficients by an arbitrary factor.
	let coefScaleFactor = 2;
	for (let k = 0; k < fb2.length; ++k) {
	fb2[k] = coefScaleFactor * fb1[k];
	}

	let iir1;
	let iir2;

	should(function() {
	iir1 = context.createIIRFilter(ff, fb1);
	}, 'createIIRFilter with normalized coefficients').notThrow();

	should(function() {
	iir2 = context.createIIRFilter(ff, fb2);
	}, 'createIIRFilter with unnormalized coefficients').notThrow();

	// Create the graph. The output of iir1 (normalized coefficients) is
	// channel 0, and the output of iir2 (unnormalized coefficients), with
	// appropriate scaling, is channel 1.
	let merger = context.createChannelMerger(2);
	source.connect(iir1);
	source.connect(iir2);
	iir1.connect(merger, 0, 0);
	iir2.connect(gain);

	// The gain for the gain node should be set to compensate for the
	// scaling of the coefficients. Since iir2 has scaled the coefficients
	// by coefScaleFactor, the output is reduced by the same factor, so
	// adjust the gain to scale the output of iir2 back up.
	gain.gain.value = coefScaleFactor;
	gain.connect(merger, 0, 1);

	merger.connect(context.destination);

	source.start();

	// Rock and roll!

	context.startRendering()
	.then(function(result) {
	// Find the max amplitude of the result, which should be near
	// zero.
	let iir1Data = result.getChannelData(0);
	let iir2Data = result.getChannelData(1);

	// Threshold isn't exactly zero because the arithmetic is done
	// differently between the IIRFilterNode and the BiquadFilterNode.
	should(
	iir2Data,
	'Output of IIR filter with unnormalized coefficients')
	.beCloseToArray(iir1Data, {absoluteThreshold: 2.1958e-38});
	})
	.then(() => task.done());
	});

	audit.define('one-zero', (task, should) => {
	// Create a simple 1-zero filter and compare with the expected output.
	let context = new OfflineAudioContext(1, testFrames, sampleRate);

	// Use a simple impulse as the source
	let buffer = context.createBuffer(1, 1, sampleRate);
	buffer.getChannelData(0)[0] = 1;
	let source = context.createBufferSource();
	source.buffer = buffer;

	// The filter is y(n) = 0.5*(x(n) + x(n-1)), a simple 2-point moving
	// average. This is rather arbitrary; keep it simple.

	let iir = context.createIIRFilter([0.5, 0.5], [1]);

	// Create the graph
	source.connect(iir);
	iir.connect(context.destination);

	// Rock and roll!
	source.start();

	context.startRendering()
	.then(function(result) {
	let actual = result.getChannelData(0);
	let expected = new Float64Array(testFrames);
	// The filter is a simple 2-point moving average of an impulse, so
	// the first two values are non-zero and the rest are zero.
	expected[0] = 0.5;
	expected[1] = 0.5;
	should(actual, 'IIR 1-zero output').beCloseToArray(expected, {
	absoluteThreshold: 0
	});
	})
	.then(() => task.done());
	});

	audit.define('one-pole', (task, should) => {
	// Create a simple 1-pole filter and compare with the expected output.

	// The filter is y(n) + c*y(n-1)= x(n). The analytical response is
	// (-c)^n, so choose a suitable number of frames to run the test for
	// where the output isn't flushed to zero.
	let c = 0.9;
	let eps = 1e-20;
	let duration = Math.floor(Math.log(eps) / Math.log(Math.abs(c)));
	let context = new OfflineAudioContext(1, duration, sampleRate);

	// Use a simple impulse as the source
	let buffer = context.createBuffer(1, 1, sampleRate);
	buffer.getChannelData(0)[0] = 1;
	let source = context.createBufferSource();
	source.buffer = buffer;

	let iir = context.createIIRFilter([1], [1, c]);

	// Create the graph
	source.connect(iir);
	iir.connect(context.destination);

	// Rock and roll!
	source.start();

	context.startRendering()
	.then(function(result) {
	let actual = result.getChannelData(0);
	let expected = new Float64Array(actual.length);

	// The filter is a simple 1-pole filter: y(n) = -c*y(n-k)+x(n),
	// with an impulse as the input.
	expected[0] = 1;
	for (k = 1; k < testFrames; ++k) {
	expected[k] = -c * expected[k - 1];
	}

	// Threshold isn't exactly zero due to round-off in the
	// single-precision IIRFilterNode computations versus the
	// double-precision Javascript computations.
	should(actual, 'IIR 1-pole output').beCloseToArray(expected, {
	absoluteThreshold: 2.7657e-8
	});
	})
	.then(() => task.done());
	});

	// Return a function suitable for use as a defineTask function. This
	// function creates an IIRFilterNode equivalent to the specified
	// BiquadFilterNode and compares the outputs. The outputs from the two
	// filters should be virtually identical.
	function testWithBiquadFilter(filterType, errorThreshold, snrThreshold) {
	return (task, should) => {
	let context = new OfflineAudioContext(2, testFrames, sampleRate);

	// Use a constant (step function) as the source
	let buffer = createConstantBuffer(context, testFrames, 1);
	let source = context.createBufferSource();
	source.buffer = buffer;


	// Create the biquad. Choose some rather arbitrary values for Q and
	// gain for the biquad so that the shelf filters aren't identical.
	let biquad = context.createBiquadFilter();
	biquad.type = filterType;
	biquad.Q.value = 10;
	biquad.gain.value = 10;

	// Create the equivalent IIR Filter node by computing the coefficients
	// of the given biquad filter type.
	let nyquist = sampleRate / 2;
	let coef = createFilter(
	filterType, biquad.frequency.value / nyquist, biquad.Q.value,
	biquad.gain.value);

	let iir = context.createIIRFilter(
	[coef.b0, coef.b1, coef.b2], [1, coef.a1, coef.a2]);

	let merger = context.createChannelMerger(2);
	// Create the graph
	source.connect(biquad);
	source.connect(iir);

	biquad.connect(merger, 0, 0);
	iir.connect(merger, 0, 1);

	merger.connect(context.destination);

	// Rock and roll!
	source.start();

	context.startRendering()
	.then(function(result) {
	// Find the max amplitude of the result, which should be near
	// zero.
	let expected = result.getChannelData(0);
	let actual = result.getChannelData(1);

	// On MacOSX, WebAudio uses an optimized Biquad implementation
	// that is different from the implementation used for Linux and
	// Windows. This will cause the output to differ, even if the
	// threshold passes. Thus, only print out a very small number
	// of elements of the array where we have tested that they are
	// consistent.
	should(actual, 'IIRFilter for Biquad ' + filterType)
	.beCloseToArray(expected, errorThreshold);

	let snr = 10 * Math.log10(computeSNR(actual, expected));
	should(snr, 'SNR for IIRFIlter for Biquad ' + filterType)
	.beGreaterThanOrEqualTo(snrThreshold);
	})
	.then(() => task.done());
	};
	}

	// Thresholds here are experimentally determined.
	let biquadTestConfigs = [
	{
	filterType: 'lowpass',
	snrThreshold: 91.221,
	errorThreshold: {relativeThreshold: 4.9834e-5}
	},
	{
	filterType: 'highpass',
	snrThreshold: 105.4590,
	errorThreshold: {absoluteThreshold: 2.9e-6, relativeThreshold: 3e-5}
	},
	{
	filterType: 'bandpass',
	snrThreshold: 104.060,
	errorThreshold: {absoluteThreshold: 2e-7, relativeThreshold: 8.7e-4}
	},
	{
	filterType: 'notch',
	snrThreshold: 91.312,
	errorThreshold: {absoluteThreshold: 0, relativeThreshold: 4.22e-5}
	},
	{
	filterType: 'allpass',
	snrThreshold: 91.319,
	errorThreshold: {absoluteThreshold: 0, relativeThreshold: 4.31e-5}
	},
	{
	filterType: 'lowshelf',
	snrThreshold: 90.609,
	errorThreshold: {absoluteThreshold: 0, relativeThreshold: 2.98e-5}
	},
	{
	filterType: 'highshelf',
	snrThreshold: 103.159,
	errorThreshold: {absoluteThreshold: 0, relativeThreshold: 1.24e-5}
	},
	{
	filterType: 'peaking',
	snrThreshold: 91.504,
	errorThreshold: {absoluteThreshold: 0, relativeThreshold: 5.05e-5}
	}
	];

	// Create a set of tasks based on biquadTestConfigs.
	for (k = 0; k < biquadTestConfigs.length; ++k) {
	let config = biquadTestConfigs[k];
	let name = k + ': ' + config.filterType;
	audit.define(
	name,
	testWithBiquadFilter(
	config.filterType, config.errorThreshold, config.snrThreshold));
	}

	audit.define('multi-channel', (task, should) => {
	// Multi-channel test. Create a biquad filter and the equivalent IIR
	// filter. Filter the same multichannel signal and compare the results.
	let nChannels = 3;
	let context =
	new OfflineAudioContext(nChannels, testFrames, sampleRate);

	// Create a set of oscillators as the multi-channel source.
	let source = [];

	for (k = 0; k < nChannels; ++k) {
	source[k] = context.createOscillator();
	source[k].type = 'sawtooth';
	// The frequency of the oscillator is pretty arbitrary, but each
	// oscillator should have a different frequency.
	source[k].frequency.value = 100 + k * 100;
	}

	let merger = context.createChannelMerger(3);

	let biquad = context.createBiquadFilter();

	// Create the equivalent IIR Filter node.
	let nyquist = sampleRate / 2;
	let coef = createFilter(
	biquad.type, biquad.frequency.value / nyquist, biquad.Q.value,
	biquad.gain.value);
	let fb = [1, coef.a1, coef.a2];
	let ff = [coef.b0, coef.b1, coef.b2];

	let iir = context.createIIRFilter(ff, fb);
	// Gain node to compute the difference between the IIR and biquad
	// filter.
	let gain = context.createGain();
	gain.gain.value = -1;

	// Create the graph.
	for (k = 0; k < nChannels; ++k)
	source[k].connect(merger, 0, k);

	merger.connect(biquad);
	merger.connect(iir);
	iir.connect(gain);
	biquad.connect(context.destination);
	gain.connect(context.destination);

	for (k = 0; k < nChannels; ++k)
	source[k].start();

	context.startRendering()
	.then(function(result) {
	let errorThresholds = [3.7671e-5, 3.0071e-5, 2.6241e-5];

	// Check the difference signal on each channel
	for (channel = 0; channel < result.numberOfChannels; ++channel) {
	// Find the max amplitude of the result, which should be near
	// zero.
	let data = result.getChannelData(channel);
	let maxError =
	data.reduce(function(reducedValue, currentValue) {
	return Math.max(reducedValue, Math.abs(currentValue));
	});

	should(
	maxError,
	'Max difference between IIR and Biquad on channel ' +
	channel)
	.beLessThanOrEqualTo(errorThresholds[channel]);
	}

	})
	.then(() => task.done());
	});

	// Apply an IIRFilter to the given input signal.
	//
	// IIR filter in the time domain is
	//
	// y[n] = sum(ff[k]x[n-k], k, 0, M) - sum(fb[k]y[n-k], k, 1, N)
	//
	function iirFilter(input, feedforward, feedback) {
	// For simplicity, create an x buffer that contains the input, and a y
	// buffer that contains the output. Both of these buffers have an
	// initial work space to implement the initial memory of the filter.
	let workSize = Math.max(feedforward.length, feedback.length);
	let x = new Float32Array(input.length + workSize);

	// Float64 because we want to match the implementation that uses doubles
	// to minimize roundoff.
	let y = new Float64Array(input.length + workSize);

	// Copy the input over.
	for (let k = 0; k < input.length; ++k)
	x[k + feedforward.length] = input[k];

	// Run the filter
	for (let n = 0; n < input.length; ++n) {
	let index = n + workSize;
	let yn = 0;
	for (let k = 0; k < feedforward.length; ++k)
	yn += feedforward[k] * x[index - k];
	for (let k = 0; k < feedback.length; ++k)
	yn -= feedback[k] * y[index - k];

	y[index] = yn;
	}

	return y.slice(workSize).map(Math.fround);
	}

	// Cascade the two given biquad filters to create one IIR filter.
	function cascadeBiquads(f1Coef, f2Coef) {
	// The biquad filters are:
	//
	// f1 = (b10 + b11/z + b12/z^2)/(1 + a11/z + a12/z^2);
	// f2 = (b20 + b21/z + b22/z^2)/(1 + a21/z + a22/z^2);
	//
	// To cascade them, multiply the two transforms together to get a fourth
	// order IIR filter.

	let numProduct = [
	f1Coef.b0 * f2Coef.b0, f1Coef.b0 * f2Coef.b1 + f1Coef.b1 * f2Coef.b0,
	f1Coef.b0 * f2Coef.b2 + f1Coef.b1 * f2Coef.b1 + f1Coef.b2 * f2Coef.b0,
	f1Coef.b1 * f2Coef.b2 + f1Coef.b2 * f2Coef.b1, f1Coef.b2 * f2Coef.b2
	];

	let denProduct = [
	1, f2Coef.a1 + f1Coef.a1,
	f2Coef.a2 + f1Coef.a1 * f2Coef.a1 + f1Coef.a2,
	f1Coef.a1 * f2Coef.a2 + f1Coef.a2 * f2Coef.a1, f1Coef.a2 * f2Coef.a2
	];

	return {
	ff: numProduct, fb: denProduct
	}
	}

	// Find the magnitude of the root of the quadratic that has the maximum
	// magnitude.
	//
	// The quadratic is z^2 + a1 * z + a2 and we want the root z that has the
	// largest magnitude.
	function largestRootMagnitude(a1, a2) {
	let discriminant = a1 * a1 - 4 * a2;
	if (discriminant < 0) {
	// Complex roots: -a1/2 +/- i*sqrt(-d)/2. Thus the magnitude of each
	// root is the same and is sqrt(a1^2/4 + \|d\|/4)
	let d = Math.sqrt(-discriminant);
	return Math.hypot(a1 / 2, d / 2);
	} else {
	// Real roots
	let d = Math.sqrt(discriminant);
	return Math.max(Math.abs((-a1 + d) / 2), Math.abs((-a1 - d) / 2));
	}
	}

	audit.define('4th-order-iir', (task, should) => {
	// Cascade 2 lowpass biquad filters and compare that with the equivalent
	// 4th order IIR filter.

	let nyquist = sampleRate / 2;
	// Compute the coefficients of a lowpass filter.

	// First some preliminary stuff. Compute the coefficients of the
	// biquad. This is used to figure out how frames to use in the test.
	let biquadType = 'lowpass';
	let biquadCutoff = 350;
	let biquadQ = 5;
	let biquadGain = 1;

	let coef = createFilter(
	biquadType, biquadCutoff / nyquist, biquadQ, biquadGain);

	// Cascade the biquads together to create an equivalent IIR filter.
	let cascade = cascadeBiquads(coef, coef);

	// Since we're cascading two identical biquads, the root of denominator
	// of the IIR filter is repeated, so the root of the denominator with
	// the largest magnitude occurs twice. The impulse response of the IIR
	// filter will be roughly c(rr)^n at time n, where r is the root of
	// largest magnitude. This approximation gets better as n increases.
	// We can use this to get a rough idea of when the response has died
	// down to a small value.

	// This is the value we will use to determine how many frames to render.
	// Rendering too many is a waste of time and also makes it hard to
	// compare the actual result to the expected because the magnitudes are
	// so small that they could be mostly round-off noise.
	//
	// Find magnitude of the root with largest magnitude
	let rootMagnitude = largestRootMagnitude(coef.a1, coef.a2);

	// Find n such that \|r\|^(2n) <= eps. That is, n = log(eps)/(2log(r)).
	// Somewhat arbitrarily choose eps = 1e-20;
	let eps = 1e-20;
	let framesForTest =
	Math.floor(Math.log(eps) / (2 * Math.log(rootMagnitude)));

	// We're ready to create the graph for the test. The offline context
	// has two channels: channel 0 is the expected (cascaded biquad) result
	// and channel 1 is the actual IIR filter result.
	let context = new OfflineAudioContext(2, framesForTest, sampleRate);

	// Use a simple impulse with a large (arbitrary) amplitude as the source
	let amplitude = 1;
	let buffer = context.createBuffer(1, testFrames, sampleRate);
	buffer.getChannelData(0)[0] = amplitude;
	let source = context.createBufferSource();
	source.buffer = buffer;

	// Create the two biquad filters. Doesn't really matter what, but for
	// simplicity we choose identical lowpass filters with the same
	// parameters.
	let biquad1 = context.createBiquadFilter();
	biquad1.type = biquadType;
	biquad1.frequency.value = biquadCutoff;
	biquad1.Q.value = biquadQ;

	let biquad2 = context.createBiquadFilter();
	biquad2.type = biquadType;
	biquad2.frequency.value = biquadCutoff;
	biquad2.Q.value = biquadQ;

	let iir = context.createIIRFilter(cascade.ff, cascade.fb);

	// Create the merger to get the signals into multiple channels
	let merger = context.createChannelMerger(2);

	// Create the graph, filtering the source through two biquads.
	source.connect(biquad1);
	biquad1.connect(biquad2);
	biquad2.connect(merger, 0, 0);

	source.connect(iir);
	iir.connect(merger, 0, 1);

	merger.connect(context.destination);

	// Now filter the source through the IIR filter.
	let y = iirFilter(buffer.getChannelData(0), cascade.ff, cascade.fb);

	// Rock and roll!
	source.start();

	context.startRendering()
	.then(function(result) {
	let expected = result.getChannelData(0);
	let actual = result.getChannelData(1);

	should(actual, '4-th order IIRFilter (biquad ref)')
	.beCloseToArray(expected, {
	// Thresholds experimentally determined.
	absoluteThreshold: 1.59e-7,
	relativeThreshold: 2.11e-5,
	});

	let snr = 10 * Math.log10(computeSNR(actual, expected));
	should(snr, 'SNR of 4-th order IIRFilter (biquad ref)')
	.beGreaterThanOrEqualTo(108.947);
	})
	.then(() => task.done());
	});

	audit.run();
	</script>
	</body>
	</html>