tor-browser

webaudio.js (10884B)

---

// Helpers for Web Audio tests

// It is expected that the test defines this.
/* global gTest */

function expectException(func, exceptionCode) {
 var threw = false;
 try {
   func();
 } catch (ex) {
   threw = true;
   is(ex.constructor.name, "DOMException", "Expect a DOM exception");
   is(ex.code, exceptionCode, "Expect the correct exception code");
 }
 ok(threw, "The exception was thrown");
}

function expectNoException(func) {
 var threw = false;
 try {
   func();
 } catch (ex) {
   threw = true;
 }
 ok(!threw, "An exception was not thrown");
}

function expectTypeError(func) {
 var threw = false;
 try {
   func();
 } catch (ex) {
   threw = true;
   ok(ex instanceof TypeError, "Expect a TypeError");
 }
 ok(threw, "The exception was thrown");
}

function expectRejectedPromise(that, func, exceptionName) {
 var promise = that[func]();

 ok(promise instanceof Promise, "Expect a Promise");

 promise
   .then(function () {
     ok(false, "Promise resolved when it should have been rejected.");
   })
   .catch(function (err) {
     is(
       err.name,
       exceptionName,
       "Promise correctly reject with " + exceptionName
     );
   });
}

function fuzzyCompare(a, b) {
 return Math.abs(a - b) < 9e-3;
}

function compareChannels(
 buf1,
 buf2,
 /*optional*/ length,
 /*optional*/ sourceOffset,
 /*optional*/ destOffset,
 /*optional*/ skipLengthCheck
) {
 if (!skipLengthCheck) {
   is(buf1.length, buf2.length, "Channels must have the same length");
 }
 sourceOffset = sourceOffset || 0;
 destOffset = destOffset || 0;
 if (length == undefined) {
   length = buf1.length - sourceOffset;
 }
 var difference = 0;
 var maxDifference = 0;
 var firstBadIndex = -1;
 for (var i = 0; i < length; ++i) {
   if (!fuzzyCompare(buf1[i + sourceOffset], buf2[i + destOffset])) {
     difference++;
     maxDifference = Math.max(
       maxDifference,
       Math.abs(buf1[i + sourceOffset] - buf2[i + destOffset])
     );
     if (firstBadIndex == -1) {
       firstBadIndex = i;
     }
   }
 }

 is(
   difference,
   0,
   "maxDifference: " +
     maxDifference +
     ", first bad index: " +
     firstBadIndex +
     " with test-data offset " +
     sourceOffset +
     " and expected-data offset " +
     destOffset +
     "; corresponding values " +
     buf1[firstBadIndex + sourceOffset] +
     " and " +
     buf2[firstBadIndex + destOffset] +
     " --- differences"
 );
}

function compareBuffers(got, expected) {
 if (got.numberOfChannels != expected.numberOfChannels) {
   is(
     got.numberOfChannels,
     expected.numberOfChannels,
     "Correct number of buffer channels"
   );
   return;
 }
 if (got.length != expected.length) {
   is(got.length, expected.length, "Correct buffer length");
   return;
 }
 if (got.sampleRate != expected.sampleRate) {
   is(got.sampleRate, expected.sampleRate, "Correct sample rate");
   return;
 }

 for (var i = 0; i < got.numberOfChannels; ++i) {
   compareChannels(
     got.getChannelData(i),
     expected.getChannelData(i),
     got.length,
     0,
     0,
     true
   );
 }
}

/**
* Compute the root mean square (RMS,
* <http://en.wikipedia.org/wiki/Root_mean_square>) of a channel of a slice
* (defined by `start` and `end`) of an AudioBuffer.
*
* This is useful to detect that a buffer is noisy or silent.
*/
function rms(audiobuffer, channel = 0, start = 0, end = audiobuffer.length) {
 var buffer = audiobuffer.getChannelData(channel);
 var rms = 0;
 for (var i = start; i < end; i++) {
   rms += buffer[i] * buffer[i];
 }

 rms /= buffer.length;
 rms = Math.sqrt(rms);
 return rms;
}

function getEmptyBuffer(context, length) {
 return context.createBuffer(
   gTest.numberOfChannels,
   length,
   context.sampleRate
 );
}

function isChannelSilent(channel) {
 for (var i = 0; i < channel.length; ++i) {
   if (channel[i] != 0.0) {
     return false;
   }
 }
 return true;
}

const HRTFPannersByRate = new Map();
/**
* Return a promise that resolves when PannerNodes with HRTF panningModel in
* an AudioContext of the specified sample rate will be ready to produce
* non-zero output.  Before the HRIR database is loaded, such PannerNodes
* produce zero output.
*/
async function promiseHRTFReady(sampleRate) {
 if (HRTFPannersByRate.has(sampleRate)) {
   return;
 }

 const ctx = new AudioContext({ sampleRate });
 const processor = ctx.createScriptProcessor(4096, 2, 0);
 const panner = new PannerNode(ctx, { panningModel: "HRTF" });
 panner.connect(processor);
 const oscillator = ctx.createOscillator();
 oscillator.connect(panner);
 oscillator.start(0);

 await new Promise(r => {
   processor.onaudioprocess = e => {
     if (!isChannelSilent(e.inputBuffer.getChannelData(0))) {
       r();
     }
   };
 });

 ctx.suspend();
 oscillator.disconnect();
 panner.disconnect();
 processor.onaudioprocess = null;
 // Keep a reference to the panner so that the database is not unloaded.
 HRTFPannersByRate.set(sampleRate, panner);
}

/**
* This function assumes that the test file defines a single gTest variable with
* the following properties and methods:
*
* + numberOfChannels: optional property which specifies the number of channels
*                     in the output.  The default value is 2.
* + createGraph: mandatory method which takes a context object and does
*                everything needed in order to set up the Web Audio graph.
*                This function returns the node to be inspected.
* + createGraphAsync: async version of createGraph.  This function takes
*                     a callback which should be called with an argument
*                     set to the node to be inspected when the callee is
*                     ready to proceed with the test.  Either this function
*                     or createGraph must be provided.
* + createExpectedBuffers: optional method which takes a context object and
*                          returns either one expected buffer or an array of
*                          them, designating what is expected to be observed
*                          in the output.  If omitted, the output is expected
*                          to be silence.  All buffers must have the same
*                          length, which must be a bufferSize supported by
*                          ScriptProcessorNode.  This function is guaranteed
*                          to be called before createGraph.
* + length: property equal to the total number of frames which we are waiting
*           to see in the output, mandatory if createExpectedBuffers is not
*           provided, in which case it must be a bufferSize supported by
*           ScriptProcessorNode (256, 512, 1024, 2048, 4096, 8192, or 16384).
*           If createExpectedBuffers is provided then this must be equal to
*           the number of expected buffers * the expected buffer length.
*
* + skipOfflineContextTests: optional. when true, skips running tests on an offline
*                            context by circumventing testOnOfflineContext.
*/
function runTest() {
 function done() {
   SimpleTest.finish();
 }

 SimpleTest.waitForExplicitFinish();
 function runTestFunction() {
   if (!gTest.numberOfChannels) {
     gTest.numberOfChannels = 2; // default
   }

   var testLength;

   function runTestOnContext(context, callback, testOutput) {
     if (!gTest.createExpectedBuffers) {
       // Assume that the output is silence
       var expectedBuffers = getEmptyBuffer(context, gTest.length);
     } else {
       var expectedBuffers = gTest.createExpectedBuffers(context);
     }
     if (!(expectedBuffers instanceof Array)) {
       expectedBuffers = [expectedBuffers];
     }
     var expectedFrames = 0;
     for (var i = 0; i < expectedBuffers.length; ++i) {
       is(
         expectedBuffers[i].numberOfChannels,
         gTest.numberOfChannels,
         "Correct number of channels for expected buffer " + i
       );
       expectedFrames += expectedBuffers[i].length;
     }
     if (gTest.length && gTest.createExpectedBuffers) {
       is(expectedFrames, gTest.length, "Correct number of expected frames");
     }

     if (gTest.createGraphAsync) {
       gTest.createGraphAsync(context, function (nodeToInspect) {
         testOutput(nodeToInspect, expectedBuffers, callback);
       });
     } else {
       testOutput(gTest.createGraph(context), expectedBuffers, callback);
     }
   }

   function testOnNormalContext(callback) {
     function testOutput(nodeToInspect, expectedBuffers, callback) {
       testLength = 0;
       var sp = context.createScriptProcessor(
         expectedBuffers[0].length,
         gTest.numberOfChannels,
         0
       );
       nodeToInspect.connect(sp);
       sp.onaudioprocess = function (e) {
         var expectedBuffer = expectedBuffers.shift();
         testLength += expectedBuffer.length;
         compareBuffers(e.inputBuffer, expectedBuffer);
         if (!expectedBuffers.length) {
           sp.onaudioprocess = null;
           callback();
         }
       };
     }
     var context = new AudioContext();
     runTestOnContext(context, callback, testOutput);
   }

   function testOnOfflineContext(callback, sampleRate) {
     function testOutput(nodeToInspect, expectedBuffers, callback) {
       nodeToInspect.connect(context.destination);
       context.oncomplete = function (e) {
         var samplesSeen = 0;
         while (expectedBuffers.length) {
           var expectedBuffer = expectedBuffers.shift();
           is(
             e.renderedBuffer.numberOfChannels,
             expectedBuffer.numberOfChannels,
             "Correct number of input buffer channels"
           );
           for (var i = 0; i < e.renderedBuffer.numberOfChannels; ++i) {
             compareChannels(
               e.renderedBuffer.getChannelData(i),
               expectedBuffer.getChannelData(i),
               expectedBuffer.length,
               samplesSeen,
               undefined,
               true
             );
           }
           samplesSeen += expectedBuffer.length;
         }
         callback();
       };
       context.startRendering();
     }

     var context = new OfflineAudioContext(
       gTest.numberOfChannels,
       testLength,
       sampleRate
     );
     runTestOnContext(context, callback, testOutput);
   }

   testOnNormalContext(function () {
     if (!gTest.skipOfflineContextTests) {
       testOnOfflineContext(function () {
         testOnOfflineContext(done, 44100);
       }, 48000);
     } else {
       done();
     }
   });
 }

 if (document.readyState !== "complete") {
   addLoadEvent(runTestFunction);
 } else {
   runTestFunction();
 }
}