Implement Biquad lowpass and highpass filters according to spec

third_party/WebKit/LayoutTests/webaudio/resources/biquad-testing.js

 // Globals, to make testing and debugging easier.
 var context;
 var filter;
 var signal;
 var renderedBuffer;
 var renderedData;
 
 var sampleRate = 44100.0;
 var pulseLengthFrames = .1 * sampleRate;
 
@@ skipping 22 matching lines @@
     var data = impulse.getChannelData(0);
     for (var k = 1; k < data.length; ++k) {
         data[k] = 0;
     }
     data[0] = 1;
 
     return impulse;
 }
 
 
-function createTestAndRun(context, filterType, filterParameters) {
+function createTestAndRun(context, filterType, testParameters) {
     // To test the filters, we apply a signal (an impulse) to each of
     // the specified filters, with each signal starting at a different
     // time.  The output of the filters is summed together at the
     // output.  Thus for filter k, the signal input to the filter
     // starts at time k * timeStep.  For this to work well, timeStep
     // must be large enough for the output of each filter to have
     // decayed to zero with timeStep seconds.  That way the filter
     // outputs don't interfere with each other.
-    
+
+    var filterParameters = testParameters.filterParameters;
     nFilters = Math.min(filterParameters.length, maxFilters);
 
     signal = new Array(nFilters);
     filter = new Array(nFilters);
 
     impulse = createImpulseBuffer(context, pulseLengthFrames);
 
     // Create all of the signal sources and filters that we need.
     for (var k = 0; k < nFilters; ++k) {
         signal[k] = context.createBufferSource();
         signal[k].buffer = impulse;
 
         filter[k] = context.createBiquadFilter();
         filter[k].type = filterType;
         filter[k].frequency.value = context.sampleRate / 2 * filterParameters[k].cutoff;
         filter[k].detune.value = (filterParameters[k].detune === undefined) ? 0 : filterParameters[k].detune;
         filter[k].Q.value = filterParameters[k].q;
         filter[k].gain.value = filterParameters[k].gain;
 
         signal[k].connect(filter[k]);
         filter[k].connect(context.destination);
 
         signal[k].start(timeStep * k);
     }
 
-    context.oncomplete = checkFilterResponse(filterType, filterParameters);
+    context.oncomplete = checkFilterResponse(filterType, testParameters);
     context.startRendering();
 }
 
 function addSignal(dest, src, destOffset) {
     // Add src to dest at the given dest offset.
     for (var k = destOffset, j = 0; k < dest.length, j < src.length; ++k, ++j) {
         dest[k] += src[j];
     }
 }
 
@@ skipping 19 matching lines @@
                                       filterParameters[k].gain);
         var y = filterData(filterCoef, data, renderLengthSamples);
 
         // Accumulate this filtered data into the final output at the desired offset.
         addSignal(result, y, timeToSampleFrame(timeStep * k, sampleRate));
     }
 
     return result;
 }
 
-function checkFilterResponse(filterType, filterParameters) {
+function checkFilterResponse(filterType, testParameters) {
     return function(event) {
+        var filterParameters = testParameters.filterParameters;
+        var maxAllowedError = testParameters.threshold;
         renderedBuffer = event.renderedBuffer;
         renderedData = renderedBuffer.getChannelData(0);
 
         reference = generateReference(filterType, filterParameters);
         
         var len = Math.min(renderedData.length, reference.length);
 
         var success = true;
 
         // Maximum error between rendered data and expected data
@@ skipping 40 matching lines @@
         }
         
         if (success) {
             testPassed("Test signal was correctly filtered.");
         } else {
             testFailed("Test signal was not correctly filtered.");
         }
         finishJSTest();
     }
 }