LayoutTests/webaudio/AudioNode/tail-processing.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
   <head>
     <title>
       Test Handling of Tail Processing
     </title>
     <script src="../../imported/w3c/web-platform-tests/resources/testharness.js"></script>
     <script src="../../resources/testharnessreport.js"></script>
     <script src="../resources/audit.js"></script>
     <script src="../resources/audit-util.js"></script>
   </head>
   <body>
     <script id="layout-test-code">
       let audit = Audit.createTaskRunner();

       // Fairly arbitrary but must be a power of two to eliminate roundoff when
       // we compute times from sample frames
       const sampleRate = 32768;

       // Fairly arbitrary duration
       const renderDuration = 0.25;
       const renderFrames = renderDuration * sampleRate;

       audit.define(
           {label: 'grain', description: 'ABSN grain has the correct duration'},
           (task, should) => {
             // Test that the grain duration is the requested duration.
             let context = new OfflineAudioContext(2, sampleRate, sampleRate);
             let merger = new ChannelMergerNode(
                 context, {numberOfInputs: context.destination.channelCount});
             merger.connect(context.destination);

             // Number of frames for the grain we want to play. (Pretty much
             // arbitrary.)
             let grainFrames = 128;

             // Test signal.  Just fill the buffer with all ones.
             let bTest = new AudioBuffer(
                 {length: context.length, sampleRate: context.sampleRate});
             bTest.getChannelData(0).fill(1);
             let sTest = new AudioBufferSourceNode(context, {buffer: bTest});

             // Reference signal.
             let bRef = new AudioBuffer(
                 {length: context.length, sampleRate: context.sampleRate});
             bRef.getChannelData(0).fill(1, 0, grainFrames);
             let sRef = new AudioBufferSourceNode(context, {buffer: bRef});

             sTest.connect(merger, 0, 0);
             sRef.connect(merger, 0, 1);

             sTest.start(0, 0, grainFrames / context.sampleRate);
             sRef.start();

             context.startRendering()
                 .then(renderedBuffer => {
                   let actual = renderedBuffer.getChannelData(0);
                   let expected = renderedBuffer.getChannelData(1);

                   // The actual and expected should be the same because we got
                   // rid of the grain hack that caused a grain to play for an
                   // extra 512 frames.
                   should(actual, 'Rendered ABSN grain')
                       .beEqualToArray(expected);
                 })
                 .then(() => task.done());
           });

       audit.define('hrtf-panner-tail', (task, should) => {
         runTest('PannerNode', {panningModel: 'HRTF', distanceMode: 'linear'})
             .then(renderedBuffer => {
               let prefix = 'HRTF PannerNode';
               let output = renderedBuffer.getChannelData(0);
               let response = renderedBuffer.getChannelData(1);
               let latencyFrame = findLatencyFrame(response);
               let tailFrame = findTailFrame(response);

               // The HRTF panner has both a latency component and a tail
               // component.  Make sure both are non-zero.
               should(latencyFrame, `${prefix} latency frame (${latencyFrame})`)
                   .beGreaterThan(0);

               should(tailFrame, `${prefix} tail frame (${tailFrame})`)
                   .beGreaterThan(0);

               // Because of the latency, the output is zero at the beginning.
               // Make sure this is true.
               should(
                   output.slice(0, latencyFrame),
                   `${prefix} Latency output[0:` + (latencyFrame - 1) + ']')
                   .beConstantValueOf(0);

               // Verify the rest of the output matches the expected values.  The
               // output should be non-zero from latencyFrame to tailFrame and
               // zero after tailFrame.
               verifyOutput(should, output, {
                 prefix: prefix,
                 startFrame: latencyFrame,
                 nonZeroEndFrame: Math.min(tailFrame, output.length),
                 zeroStartFrame: roundUp(tailFrame),
                 tailFrame: tailFrame,
                 reference: response
               });
             })
             .then(() => task.done());
       });

       audit.define('biquad-tail', (task, should) => {
         runTest('BiquadFilterNode', {Q: 20, frequency: 100})
             .then(renderedBuffer => {
               let prefix = 'BiquadFilter'
               let output = renderedBuffer.getChannelData(0);
               let response = renderedBuffer.getChannelData(1);
               let tailFrame = findTailFrame(response);

               should(tailFrame, `${prefix} tail frame (${tailFrame})`)
                   .beGreaterThan(0);

               // Verify biquad output which should be non-zero up to tailFrame
               // and zero afterwards.  However, the actual output isn't after
               // tailFrame because the internal biquad tail time uses an
               // approximation.  That's why zeroStartFrame is one render quantum
               // after tailFrame.
               verifyOutput(should, output, {
                 prefix: prefix,
                 startFrame: 0,
                 nonZeroEndFrame:
                     Math.min(tailFrame + RENDER_QUANTUM_FRAMES, output.length),
                 zeroStartFrame: RENDER_QUANTUM_FRAMES + roundUp(tailFrame),
                 tailFrame: tailFrame,
                 reference: response
               });
             })
             .then(() => task.done());
       });

       audit.define('iir-tail', (task, should) => {
         runTest('IIRFilterNode', {feedforward: [1], feedback: [1, -.99]})
             .then(renderedBuffer => {
               let prefix = 'IIRFilter';
               let output = renderedBuffer.getChannelData(0);
               let response = renderedBuffer.getChannelData(1);
               let tailFrame = findTailFrame(response);

               should(tailFrame, `${prefix} tail frame (${tailFrame})`)
                   .beGreaterThan(0);

               verifyOutput(should, output, {
                 prefix: prefix,
                 startFrame: 0,
                 nonZeroEndFrame:
                     Math.min(tailFrame + RENDER_QUANTUM_FRAMES, output.length),
                 zeroStartFrame: 2 * RENDER_QUANTUM_FRAMES + roundUp(tailFrame),
                 tailFrame: tailFrame,
                 reference: response
               });
             })
             .then(() => task.done());
       });

       audit.define('delay-tail', (task, should) => {
         // For the test, make sure the delay is greater than one render
         // quantum.  If it's less we won't be able to tell if tail processing
         // worked because the input signal is an impulse.
         let delayFrames = RENDER_QUANTUM_FRAMES + 64;
         runTest('DelayNode', {delayTime: delayFrames / sampleRate})
             .then(renderedBuffer => {
               let prefix = 'Delay';
               let output = renderedBuffer.getChannelData(0);
               let response = renderedBuffer.getChannelData(1);
               let tailFrame = findTailFrame(response);

               should(tailFrame, `${prefix} tail frame (${tailFrame})`)
                   .beGreaterThan(0);

               // As a delay node with delay time greater than one render
               // quantum, the first render quantum must be 0.
               should(
                   output.slice(0, RENDER_QUANTUM_FRAMES),
                   `${prefix} output[0:` + (RENDER_QUANTUM_FRAMES - 1) + ']')
                   .beConstantValueOf(0);

               // The output of the delay node should be nonzero in the second
               // render quantum and zero forever after.
               verifyOutput(should, output, {
                 prefix: prefix,
                 startFrame: RENDER_QUANTUM_FRAMES,
                 nonZeroEndFrame: Math.min(tailFrame, output.length),
                 zeroStartFrame: roundUp(tailFrame),
                 tailFrame: tailFrame,
                 reference: response
               });

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

       audit.define('convolver-tail', (task, should) => {
         // The convolver response.  It needs to be longer than one render
         // quantum to show the tail processing.
         let response = new AudioBuffer(
             {length: RENDER_QUANTUM_FRAMES + 64, sampleRate: sampleRate});
         // For simplicity, just make the response all ones.
         response.getChannelData(0).fill(1);

         runTest('ConvolverNode', {disableNormalization: true, buffer: response})
             .then(renderedBuffer => {
               let prefix = 'Convolver';
               let output = renderedBuffer.getChannelData(0);
               let response = renderedBuffer.getChannelData(1);
               let tailFrame = findTailFrame(response);

               should(tailFrame, `${prefix} tail frame (${tailFrame})`)
                   .beGreaterThan(0);

               verifyOutput(should, output, {
                 prefix: prefix,
                 startFrame: 0,
                 nonZeroEndFrame:
                     Math.min(tailFrame + RENDER_QUANTUM_FRAMES, output.length),
                 zeroStartFrame: RENDER_QUANTUM_FRAMES + roundUp(tailFrame),
                 tailFrame: tailFrame,
                 reference: response
               });
             })
             .then(() => task.done());
       });

       audit.define('dynamics-compressor-tail', (task, should) => {
         runTest('DynamicsCompressorNode', {})
             .then(renderedBuffer => {
               let prefix = 'DyamicsCompressor';
               let output = renderedBuffer.getChannelData(0);
               let response = renderedBuffer.getChannelData(1);
               let tailFrame = findTailFrame(response);

               should(tailFrame, `${prefix} tail frame (${tailFrame})`)
                   .beGreaterThan(0);

               let latencyFrame = roundDown(tailFrame - 1);
               should(
                   output.slice(0, latencyFrame),
                   `${prefix} output[0:` + (latencyFrame - 1) + ']')
                   .beConstantValueOf(0);

               verifyOutput(should, output, {
                 prefix: prefix,
                 startFrame: latencyFrame,
                 nonZeroEndFrame: Math.min(tailFrame, output.length),
                 zeroStartFrame: roundUp(tailFrame),
                 tailFrame: tailFrame,
                 reference: response
               });

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

       audit.define('waveshaper-tail', (task, should) => {
         // Fairly arbitrary curve for the WaveShaper
         let curve = Float32Array.from([-1, -.5, 0, 0.5, 1]);

         runTest('WaveShaperNode', {curve: curve, oversample: '2x'})
             .then(renderedBuffer => {
               let prefix = 'WaveShaper';
               let output = renderedBuffer.getChannelData(0);
               let response = renderedBuffer.getChannelData(1);
               // FFT resampler introduces some very small round-off.  Use a
               // threshold of zero to find the tail frame.
               let tailFrame = findTailFrame(response, 0);

               should(tailFrame, `${prefix} tail frame (${tailFrame})`)
                   .beGreaterThan(0);

               verifyOutput(should, output, {
                 prefix: prefix,
                 startFrame: 0,
                 nonZeroEndFrame: Math.min(tailFrame, output.length),
                 zeroStartFrame: roundUp(tailFrame),
                 tailFrame: tailFrame,
                 reference: response
               });
             })
             .then(() => task.done());
       });

       audit.run('waveshaper-tail');

       function runTest(nodeName, nodeOptions) {
         // Two-channel output.  Channel 0 is the test result; channel 1 is the
         // impulse response that is used to figure out when the tail should
         // start.
         let context = new OfflineAudioContext(2, sampleRate, sampleRate);

         // Merge channels for the destination.
         let merger = new ChannelMergerNode(context, {numberOfInputs: 2});
         merger.connect(context.destination);

         let src = new ConstantSourceNode(context, {offset: 1});

         // Impulse for testing.  We want a full buffer so as not to worry about
         // the source disconnecting prematurely from the filter.
         let b = new AudioBuffer(
             {length: context.length, sampleRate: context.sampleRate});
         b.getChannelData(0)[0] = 1;
         let impulse = new AudioBufferSourceNode(context, {buffer: b});

         let testNode = new window[nodeName](context, nodeOptions);
         let refNode = new window[nodeName](context, nodeOptions);

         src.connect(testNode).connect(merger, 0, 0);
         impulse.connect(refNode).connect(merger, 0, 1);

         src.start();
         src.stop(1 / context.sampleRate);
         impulse.start();

         return context.startRendering();
       }

       // Starting from the end find the first frame that exceeds our threshold.
       // This assumes that everything less than the threshold is equivalent to 0
       // for our purposes.
       function findTailFrame(response, zeroThreshold) {
         // Any value below this is considered to be zero for our purpose of
         // finding the first non-zero value.  Somewhat arbitrary, but the value
         // here is the size of the LSB of a 16-bit PCM sample.
         let threshold = zeroThreshold === undefined ? 1 / 32768 : zeroThreshold;
         let tailFrame = response.length;

         for (let k = response.length - 1; k >= 0; --k) {
           if (Math.abs(response[k]) > threshold) {
             tailFrame = k + 1;
             break;
           }
         }

         return tailFrame;
       }

       function findLatencyFrame(response) {
         for (let k = 0; k < response.length; ++k) {
           if (response[k] != 0)
             return k;
         }

         return response.length;
       }

       function verifyOutput(should, output, options) {
         let prefix = options.prefix || '';
         if (options.tailFrame && options.reference) {
           should(
               output.slice(0, options.tailFrame),
               `${prefix} Tail output[0:` + (options.tailFrame - 1) + ']')
               .beEqualToArray(options.reference.slice(0, options.tailFrame));
         }

         // Verify that |output| is non-zero between |startFrame| and
         // |nonZeroEndFrame|.
         for (let k = options.startFrame; k < options.nonZeroEndFrame;
              k += RENDER_QUANTUM_FRAMES) {
           should(
               output.slice(k, k + RENDER_QUANTUM_FRAMES),
               `${prefix} output[` + k + ':' + (k + 127) + ']')
               .notBeConstantValueOf(0);
         }

         // Verify |output| is zero starting at frame |zeroStartFrame|, inclusive
         if (options.zeroStartFrame < output.length) {
           should(
               output.slice(options.zeroStartFrame),
               `${prefix} output[` + options.zeroStartFrame + ':]')
               .beConstantValueOf(0);
         }
       }

       function roundDown(frame) {
         return RENDER_QUANTUM_FRAMES *
             Math.floor(frame / RENDER_QUANTUM_FRAMES);
       }

       function roundUp(frame) {
         return RENDER_QUANTUM_FRAMES * Math.ceil(frame / RENDER_QUANTUM_FRAMES);
       }
     </script>
   </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<title>
	Test Handling of Tail Processing
	</title>
	<script src="../../imported/w3c/web-platform-tests/resources/testharness.js"></script>
	<script src="../../resources/testharnessreport.js"></script>
	<script src="../resources/audit.js"></script>
	<script src="../resources/audit-util.js"></script>
	</head>
	<body>
	<script id="layout-test-code">
	let audit = Audit.createTaskRunner();

	// Fairly arbitrary but must be a power of two to eliminate roundoff when
	// we compute times from sample frames
	const sampleRate = 32768;

	// Fairly arbitrary duration
	const renderDuration = 0.25;
	const renderFrames = renderDuration * sampleRate;

	audit.define(
	{label: 'grain', description: 'ABSN grain has the correct duration'},
	(task, should) => {
	// Test that the grain duration is the requested duration.
	let context = new OfflineAudioContext(2, sampleRate, sampleRate);
	let merger = new ChannelMergerNode(
	context, {numberOfInputs: context.destination.channelCount});
	merger.connect(context.destination);

	// Number of frames for the grain we want to play. (Pretty much
	// arbitrary.)
	let grainFrames = 128;

	// Test signal. Just fill the buffer with all ones.
	let bTest = new AudioBuffer(
	{length: context.length, sampleRate: context.sampleRate});
	bTest.getChannelData(0).fill(1);
	let sTest = new AudioBufferSourceNode(context, {buffer: bTest});

	// Reference signal.
	let bRef = new AudioBuffer(
	{length: context.length, sampleRate: context.sampleRate});
	bRef.getChannelData(0).fill(1, 0, grainFrames);
	let sRef = new AudioBufferSourceNode(context, {buffer: bRef});

	sTest.connect(merger, 0, 0);
	sRef.connect(merger, 0, 1);

	sTest.start(0, 0, grainFrames / context.sampleRate);
	sRef.start();

	context.startRendering()
	.then(renderedBuffer => {
	let actual = renderedBuffer.getChannelData(0);
	let expected = renderedBuffer.getChannelData(1);

	// The actual and expected should be the same because we got
	// rid of the grain hack that caused a grain to play for an
	// extra 512 frames.
	should(actual, 'Rendered ABSN grain')
	.beEqualToArray(expected);
	})
	.then(() => task.done());
	});

	audit.define('hrtf-panner-tail', (task, should) => {
	runTest('PannerNode', {panningModel: 'HRTF', distanceMode: 'linear'})
	.then(renderedBuffer => {
	let prefix = 'HRTF PannerNode';
	let output = renderedBuffer.getChannelData(0);
	let response = renderedBuffer.getChannelData(1);
	let latencyFrame = findLatencyFrame(response);
	let tailFrame = findTailFrame(response);

	// The HRTF panner has both a latency component and a tail
	// component. Make sure both are non-zero.
	should(latencyFrame, `${prefix} latency frame (${latencyFrame})`)
	.beGreaterThan(0);

	should(tailFrame, `${prefix} tail frame (${tailFrame})`)
	.beGreaterThan(0);

	// Because of the latency, the output is zero at the beginning.
	// Make sure this is true.
	should(
	output.slice(0, latencyFrame),
	`${prefix} Latency output[0:` + (latencyFrame - 1) + ']')
	.beConstantValueOf(0);

	// Verify the rest of the output matches the expected values. The
	// output should be non-zero from latencyFrame to tailFrame and
	// zero after tailFrame.
	verifyOutput(should, output, {
	prefix: prefix,
	startFrame: latencyFrame,
	nonZeroEndFrame: Math.min(tailFrame, output.length),
	zeroStartFrame: roundUp(tailFrame),
	tailFrame: tailFrame,
	reference: response
	});
	})
	.then(() => task.done());
	});

	audit.define('biquad-tail', (task, should) => {
	runTest('BiquadFilterNode', {Q: 20, frequency: 100})
	.then(renderedBuffer => {
	let prefix = 'BiquadFilter'
	let output = renderedBuffer.getChannelData(0);
	let response = renderedBuffer.getChannelData(1);
	let tailFrame = findTailFrame(response);

	should(tailFrame, `${prefix} tail frame (${tailFrame})`)
	.beGreaterThan(0);

	// Verify biquad output which should be non-zero up to tailFrame
	// and zero afterwards. However, the actual output isn't after
	// tailFrame because the internal biquad tail time uses an
	// approximation. That's why zeroStartFrame is one render quantum
	// after tailFrame.
	verifyOutput(should, output, {
	prefix: prefix,
	startFrame: 0,
	nonZeroEndFrame:
	Math.min(tailFrame + RENDER_QUANTUM_FRAMES, output.length),
	zeroStartFrame: RENDER_QUANTUM_FRAMES + roundUp(tailFrame),
	tailFrame: tailFrame,
	reference: response
	});
	})
	.then(() => task.done());
	});

	audit.define('iir-tail', (task, should) => {
	runTest('IIRFilterNode', {feedforward: [1], feedback: [1, -.99]})
	.then(renderedBuffer => {
	let prefix = 'IIRFilter';
	let output = renderedBuffer.getChannelData(0);
	let response = renderedBuffer.getChannelData(1);
	let tailFrame = findTailFrame(response);

	should(tailFrame, `${prefix} tail frame (${tailFrame})`)
	.beGreaterThan(0);

	verifyOutput(should, output, {
	prefix: prefix,
	startFrame: 0,
	nonZeroEndFrame:
	Math.min(tailFrame + RENDER_QUANTUM_FRAMES, output.length),
	zeroStartFrame: 2 * RENDER_QUANTUM_FRAMES + roundUp(tailFrame),
	tailFrame: tailFrame,
	reference: response
	});
	})
	.then(() => task.done());
	});

	audit.define('delay-tail', (task, should) => {
	// For the test, make sure the delay is greater than one render
	// quantum. If it's less we won't be able to tell if tail processing
	// worked because the input signal is an impulse.
	let delayFrames = RENDER_QUANTUM_FRAMES + 64;
	runTest('DelayNode', {delayTime: delayFrames / sampleRate})
	.then(renderedBuffer => {
	let prefix = 'Delay';
	let output = renderedBuffer.getChannelData(0);
	let response = renderedBuffer.getChannelData(1);
	let tailFrame = findTailFrame(response);

	should(tailFrame, `${prefix} tail frame (${tailFrame})`)
	.beGreaterThan(0);

	// As a delay node with delay time greater than one render
	// quantum, the first render quantum must be 0.
	should(
	output.slice(0, RENDER_QUANTUM_FRAMES),
	`${prefix} output[0:` + (RENDER_QUANTUM_FRAMES - 1) + ']')
	.beConstantValueOf(0);

	// The output of the delay node should be nonzero in the second
	// render quantum and zero forever after.
	verifyOutput(should, output, {
	prefix: prefix,
	startFrame: RENDER_QUANTUM_FRAMES,
	nonZeroEndFrame: Math.min(tailFrame, output.length),
	zeroStartFrame: roundUp(tailFrame),
	tailFrame: tailFrame,
	reference: response
	});

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

	audit.define('convolver-tail', (task, should) => {
	// The convolver response. It needs to be longer than one render
	// quantum to show the tail processing.
	let response = new AudioBuffer(
	{length: RENDER_QUANTUM_FRAMES + 64, sampleRate: sampleRate});
	// For simplicity, just make the response all ones.
	response.getChannelData(0).fill(1);

	runTest('ConvolverNode', {disableNormalization: true, buffer: response})
	.then(renderedBuffer => {
	let prefix = 'Convolver';
	let output = renderedBuffer.getChannelData(0);
	let response = renderedBuffer.getChannelData(1);
	let tailFrame = findTailFrame(response);

	should(tailFrame, `${prefix} tail frame (${tailFrame})`)
	.beGreaterThan(0);

	verifyOutput(should, output, {
	prefix: prefix,
	startFrame: 0,
	nonZeroEndFrame:
	Math.min(tailFrame + RENDER_QUANTUM_FRAMES, output.length),
	zeroStartFrame: RENDER_QUANTUM_FRAMES + roundUp(tailFrame),
	tailFrame: tailFrame,
	reference: response
	});
	})
	.then(() => task.done());
	});

	audit.define('dynamics-compressor-tail', (task, should) => {
	runTest('DynamicsCompressorNode', {})
	.then(renderedBuffer => {
	let prefix = 'DyamicsCompressor';
	let output = renderedBuffer.getChannelData(0);
	let response = renderedBuffer.getChannelData(1);
	let tailFrame = findTailFrame(response);

	should(tailFrame, `${prefix} tail frame (${tailFrame})`)
	.beGreaterThan(0);

	let latencyFrame = roundDown(tailFrame - 1);
	should(
	output.slice(0, latencyFrame),
	`${prefix} output[0:` + (latencyFrame - 1) + ']')
	.beConstantValueOf(0);

	verifyOutput(should, output, {
	prefix: prefix,
	startFrame: latencyFrame,
	nonZeroEndFrame: Math.min(tailFrame, output.length),
	zeroStartFrame: roundUp(tailFrame),
	tailFrame: tailFrame,
	reference: response
	});

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

	audit.define('waveshaper-tail', (task, should) => {
	// Fairly arbitrary curve for the WaveShaper
	let curve = Float32Array.from([-1, -.5, 0, 0.5, 1]);

	runTest('WaveShaperNode', {curve: curve, oversample: '2x'})
	.then(renderedBuffer => {
	let prefix = 'WaveShaper';
	let output = renderedBuffer.getChannelData(0);
	let response = renderedBuffer.getChannelData(1);
	// FFT resampler introduces some very small round-off. Use a
	// threshold of zero to find the tail frame.
	let tailFrame = findTailFrame(response, 0);

	should(tailFrame, `${prefix} tail frame (${tailFrame})`)
	.beGreaterThan(0);

	verifyOutput(should, output, {
	prefix: prefix,
	startFrame: 0,
	nonZeroEndFrame: Math.min(tailFrame, output.length),
	zeroStartFrame: roundUp(tailFrame),
	tailFrame: tailFrame,
	reference: response
	});
	})
	.then(() => task.done());
	});

	audit.run('waveshaper-tail');

	function runTest(nodeName, nodeOptions) {
	// Two-channel output. Channel 0 is the test result; channel 1 is the
	// impulse response that is used to figure out when the tail should
	// start.
	let context = new OfflineAudioContext(2, sampleRate, sampleRate);

	// Merge channels for the destination.
	let merger = new ChannelMergerNode(context, {numberOfInputs: 2});
	merger.connect(context.destination);

	let src = new ConstantSourceNode(context, {offset: 1});

	// Impulse for testing. We want a full buffer so as not to worry about
	// the source disconnecting prematurely from the filter.
	let b = new AudioBuffer(
	{length: context.length, sampleRate: context.sampleRate});
	b.getChannelData(0)[0] = 1;
	let impulse = new AudioBufferSourceNode(context, {buffer: b});

	let testNode = new window[nodeName](context, nodeOptions);
	let refNode = new window[nodeName](context, nodeOptions);

	src.connect(testNode).connect(merger, 0, 0);
	impulse.connect(refNode).connect(merger, 0, 1);

	src.start();
	src.stop(1 / context.sampleRate);
	impulse.start();

	return context.startRendering();
	}

	// Starting from the end find the first frame that exceeds our threshold.
	// This assumes that everything less than the threshold is equivalent to 0
	// for our purposes.
	function findTailFrame(response, zeroThreshold) {
	// Any value below this is considered to be zero for our purpose of
	// finding the first non-zero value. Somewhat arbitrary, but the value
	// here is the size of the LSB of a 16-bit PCM sample.
	let threshold = zeroThreshold === undefined ? 1 / 32768 : zeroThreshold;
	let tailFrame = response.length;

	for (let k = response.length - 1; k >= 0; --k) {
	if (Math.abs(response[k]) > threshold) {
	tailFrame = k + 1;
	break;
	}
	}

	return tailFrame;
	}

	function findLatencyFrame(response) {
	for (let k = 0; k < response.length; ++k) {
	if (response[k] != 0)
	return k;
	}

	return response.length;
	}

	function verifyOutput(should, output, options) {
	let prefix = options.prefix \|\| '';
	if (options.tailFrame && options.reference) {
	should(
	output.slice(0, options.tailFrame),
	`${prefix} Tail output[0:` + (options.tailFrame - 1) + ']')
	.beEqualToArray(options.reference.slice(0, options.tailFrame));
	}

	// Verify that \|output\| is non-zero between \|startFrame\| and
	// \|nonZeroEndFrame\|.
	for (let k = options.startFrame; k < options.nonZeroEndFrame;
	k += RENDER_QUANTUM_FRAMES) {
	should(
	output.slice(k, k + RENDER_QUANTUM_FRAMES),
	`${prefix} output[` + k + ':' + (k + 127) + ']')
	.notBeConstantValueOf(0);
	}

	// Verify \|output\| is zero starting at frame \|zeroStartFrame\|, inclusive
	if (options.zeroStartFrame < output.length) {
	should(
	output.slice(options.zeroStartFrame),
	`${prefix} output[` + options.zeroStartFrame + ':]')
	.beConstantValueOf(0);
	}
	}

	function roundDown(frame) {
	return RENDER_QUANTUM_FRAMES *
	Math.floor(frame / RENDER_QUANTUM_FRAMES);
	}

	function roundUp(frame) {
	return RENDER_QUANTUM_FRAMES * Math.ceil(frame / RENDER_QUANTUM_FRAMES);
	}
	</script>
	</body>
	</html>