The Tor Browser / file revision

 var sampleRate = 44100.0;

 var renderLengthSeconds = 8;

 var pulseLengthSeconds = 1;

 var pulseLengthFrames = pulseLengthSeconds * sampleRate;

 function createSquarePulseBuffer(context, sampleFrameLength) {

     var audioBuffer = context.createBuffer(1, sampleFrameLength, context.sampleRate);

     var n = audioBuffer.length;

     var data = audioBuffer.getChannelData(0);

     for (var i = 0; i < n; ++i)

         data[i] = 1;

     return audioBuffer;

 }

 // The triangle buffer holds the expected result of the convolution.

 // It linearly ramps up from 0 to its maximum value (at the center)

 // then linearly ramps down to 0.  The center value corresponds to the

 // point where the two square pulses overlap the most.

 function createTrianglePulseBuffer(context, sampleFrameLength) {

     var audioBuffer = context.createBuffer(1, sampleFrameLength, context.sampleRate);

     var n = audioBuffer.length;

     var halfLength = n / 2;

     var data = audioBuffer.getChannelData(0);

     for (var i = 0; i < halfLength; ++i)

         data[i] = i + 1;

     for (var i = halfLength; i < n; ++i)

         data[i] = n - i - 1;

     return audioBuffer;

 }

 function log10(x) {

   return Math.log(x)/Math.LN10;

 }

 function linearToDecibel(x) {

   return 20*log10(x);

 }

 // Verify that the rendered result is very close to the reference

 // triangular pulse.

 function checkTriangularPulse(rendered, reference) {

     var match = true;

     var maxDelta = 0;

     var valueAtMaxDelta = 0;

     var maxDeltaIndex = 0;

     for (var i = 0; i < reference.length; ++i) {

         var diff = rendered[i] - reference[i];

         var x = Math.abs(diff);

         if (x > maxDelta) {

             maxDelta = x;

             valueAtMaxDelta = reference[i];

             maxDeltaIndex = i;

         }

     }

     // allowedDeviationFraction was determined experimentally.  It

     // is the threshold of the relative error at the maximum

     // difference between the true triangular pulse and the

     // rendered pulse.

     var allowedDeviationDecibels = -129.4;

     var maxDeviationDecibels = linearToDecibel(maxDelta / valueAtMaxDelta);

     if (maxDeviationDecibels <= allowedDeviationDecibels) {

         testPassed("Triangular portion of convolution is correct.");

     } else {

         testFailed("Triangular portion of convolution is not correct.  Max deviation = " + maxDeviationDecibels + " dB at " + maxDeltaIndex);

         match = false;

     }

     return match;

 }        

 // Verify that the rendered data is close to zero for the first part

 // of the tail.

 function checkTail1(data, reference, breakpoint) {

     var isZero = true;

     var tail1Max = 0;

     for (var i = reference.length; i < reference.length + breakpoint; ++i) {

         var mag = Math.abs(data[i]);

         if (mag > tail1Max) {

             tail1Max = mag;

         }

     }

     // Let's find the peak of the reference (even though we know a

     // priori what it is).

     var refMax = 0;

     for (var i = 0; i < reference.length; ++i) {

       refMax = Math.max(refMax, Math.abs(reference[i]));

     }

     // This threshold is experimentally determined by examining the

     // value of tail1MaxDecibels.

     var threshold1 = -129.7;

     var tail1MaxDecibels = linearToDecibel(tail1Max/refMax);

     if (tail1MaxDecibels <= threshold1) {

         testPassed("First part of tail of convolution is sufficiently small.");

     } else {

         testFailed("First part of tail of convolution is not sufficiently small: " + tail1MaxDecibels + " dB");

         isZero = false;

     }

     return isZero;

 }

 // Verify that the second part of the tail of the convolution is

 // exactly zero.

 function checkTail2(data, reference, breakpoint) {

     var isZero = true;

     var tail2Max = 0;

     // For the second part of the tail, the maximum value should be

     // exactly zero.

     var threshold2 = 0;

     for (var i = reference.length + breakpoint; i < data.length; ++i) {

         if (Math.abs(data[i]) > 0) {

             isZero = false; 

             break;

         }

     }

     if (isZero) {

         testPassed("Rendered signal after tail of convolution is silent.");

     } else {

         testFailed("Rendered signal after tail of convolution should be silent.");

     }

     return isZero;

 }

 function checkConvolvedResult(trianglePulse) {

     return function(event) {

         var renderedBuffer = event.renderedBuffer;

         var referenceData = trianglePulse.getChannelData(0);

         var renderedData = renderedBuffer.getChannelData(0);

         var success = true;

         // Verify the triangular pulse is actually triangular.

         success = success && checkTriangularPulse(renderedData, referenceData);

         // Make sure that portion after convolved portion is totally

         // silent.  But round-off prevents this from being completely

         // true.  At the end of the triangle, it should be close to

         // zero.  If we go farther out, it should be even closer and

         // eventually zero.

         // For the tail of the convolution (where the result would be

         // theoretically zero), we partition the tail into two

         // parts.  The first is the at the beginning of the tail,

         // where we tolerate a small but non-zero value.  The second part is

         // farther along the tail where the result should be zero.

         // breakpoint is the point dividing the first two tail parts

         // we're looking at.  Experimentally determined.

         var breakpoint = 12800;

         success = success && checkTail1(renderedData, referenceData, breakpoint);

         success = success && checkTail2(renderedData, referenceData, breakpoint);

         if (success) {

             testPassed("Test signal was correctly convolved.");

         } else {

             testFailed("Test signal was not correctly convolved.");

         }

         finishJSTest();

     }

 }