The Tor Browser: content/media/webaudio/test/test_pannerNodeTail.html@6474c204b198 (annotated)

content/media/webaudio/test/test_pannerNodeTail.html@6474c204b198 (annotated)

content/media/webaudio/test/test_pannerNodeTail.html

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 <!DOCTYPE HTML>
 <html>
 <head>
   <title>Test tail time lifetime of PannerNode</title>
   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <script type="text/javascript" src="webaudio.js"></script>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
 </head>
 <body>
 <pre id="test">
 <script class="testbody" type="text/javascript">
 // This tests that a PannerNode does not release its reference before
 // it finishes emitting sound.
 //
 // The PannerNode tail time is short, so, when a PannerNode is destroyed on
 // the main thread, it is unlikely to notify the graph thread before the tail
 // time expires.  However, by adding DelayNodes downstream from the
 // PannerNodes, the graph thread can have enough time to notice that a
 // DelayNode has been destroyed.
 //
 // In the current implementation, DelayNodes will take a tail-time reference
 // immediately when they receive the first block of sound from an upstream
 // node, so this test connects the downstream DelayNodes while the upstream
 // nodes are finishing, and then runs GC (on the main thread) before the
 // DelayNodes receive any input (on the graph thread).
 //
 // Web Audio doesn't provide a means to precisely time connect()s but we can
 // test that the output of delay nodes matches the output from a reference
 // PannerNode that we know will not be GCed.
 //
 // Another set of delay nodes is added upstream to ensure that the source node
 // has removed its self-reference after dispatching its "ended" event.
 SimpleTest.waitForExplicitFinish();
 const blockSize = 128;
 // bufferSize should be long enough that to allow an audioprocess event to be
 // sent to the main thread and a connect message to return to the graph
 // thread.
 const bufferSize = 4096;
 const pannerCount = bufferSize / blockSize;
 // sourceDelayBufferCount should be long enough to allow the source node
 // onended to finish and remove the source self-reference.
 const sourceDelayBufferCount = 3;
 var gotEnded = false;
 // ccDelayLength should be long enough to allow CC to run
 var ccDelayBufferCount = 20;
 const ccDelayLength = ccDelayBufferCount * bufferSize;
 var ctx;
 var testPanners = [];
 var referencePanner;
 var referenceProcessCount = 0;
 var referenceOutput = [new Float32Array(bufferSize),
                        new Float32Array(bufferSize)];
 var testProcessor;
 var testProcessCount = 0;
 function isChannelSilent(channel) {
   for (var i = 0; i < channel.length; ++i) {
     if (channel[i] != 0.0) {
       return false;
     }
   }
   return true;
 }
 function onReferenceOutput(e) {
   switch(referenceProcessCount) {
   case sourceDelayBufferCount - 1:
     // The panners are about to finish.
     if (!gotEnded) {
       todo(false, "Source hasn't ended.  Increase sourceDelayBufferCount?");
     }
     // Connect each PannerNode output to a downstream DelayNode,
     // and connect ScriptProcessors to compare test and reference panners.
     var delayDuration = ccDelayLength / ctx.sampleRate;
     for (var i = 0; i < pannerCount; ++i) {
       var delay = ctx.createDelay(delayDuration);
       delay.delayTime.value = delayDuration;
       delay.connect(testProcessor);
       testPanners[i].connect(delay);
     }
     testProcessor = null;
     testPanners = null;
     // The panning effect is linear so only one reference panner is required.
     // This also checks that the individual panners don't chop their output
     // too soon.
     referencePanner.connect(e.target);
     // Assuming the above operations have already scheduled an event to run in
     // stable state and ask the graph thread to make connections, schedule a
     // subsequent event to run cycle collection, which should not collect
     // panners that are still producing sound.
     SimpleTest.executeSoon(function() {
       SpecialPowers.forceGC();
       SpecialPowers.forceCC();
     });
     break;
   case sourceDelayBufferCount:
     // Record this buffer during which PannerNode outputs were connected.
     for (var i = 0; i < 2; ++i) {
       e.inputBuffer.copyFromChannel(referenceOutput[i], i);
     }
     e.target.onaudioprocess = null;
     e.target.disconnect();
     // If the buffer is silent, there is probably not much point just
     // increasing the buffer size, because, with the buffer size already
     // significantly larger than panner tail time, it demonstrates that the
     // lag between threads is much greater than the tail time.
     if (isChannelSilent(referenceOutput[0])) {
       todo(false, "Connections not detected.");
     }
   }
   referenceProcessCount++;
 }
 function onTestOutput(e) {
   if (testProcessCount < sourceDelayBufferCount + ccDelayBufferCount) {
     testProcessCount++;
     return;
   }
   for (var i = 0; i < 2; ++i) {
     compareChannels(e.inputBuffer.getChannelData(i), referenceOutput[i]);
   }
   e.target.onaudioprocess = null;
   e.target.disconnect();
   SimpleTest.finish();
 }
 function startTest() {
   // 0.002 is MaxDelayTimeSeconds in HRTFpanner.cpp
   // and 512 is fftSize() at 48 kHz.
   const expectedPannerTailTime = 0.002 * ctx.sampleRate + 512;
   // Create some PannerNodes downstream from DelayNodes with delays long
   // enough for their source to finish, dispatch its "ended" event
   // and release its playing reference.  The DelayNodes should expire their
   // tail-time references before the PannerNodes and so only the PannerNode
   // lifetimes depends on their tail-time references.  Many DelayNodes are
   // created and timed to finish at different times so that one PannerNode
   // will be finishing the block processed immediately after the connect is
   // received.
   var source = ctx.createBufferSource();
   // Just short of blockSize here to avoid rounding into the next block
   var buffer = ctx.createBuffer(1, blockSize - 1, ctx.sampleRate);
   for (var i = 0; i < buffer.length; ++i) {
     buffer.getChannelData(0)[i] = Math.cos(Math.PI * i / buffer.length);
   }
   source.buffer = buffer;
   source.start(0);
   source.onended = function(e) {
     gotEnded = true;
   };
   // Time the first test panner to finish just before downstream DelayNodes
   // are about the be connected.  Note that DelayNode lifetime depends on
   // maxDelayTime so set that equal to the delay.
   var delayDuration =
     (sourceDelayBufferCount * bufferSize
      - expectedPannerTailTime - 2 * blockSize) / ctx.sampleRate;
   for (var i = 0; i < pannerCount; ++i) {
     var delay = ctx.createDelay(delayDuration);
     delay.delayTime.value = delayDuration;
     source.connect(delay);
     delay.connect(referencePanner)
     var panner = ctx.createPanner();
     delay.connect(panner);
     testPanners[i] = panner;
     delayDuration += blockSize / ctx.sampleRate;
   }
   // Create a ScriptProcessor now to use as a timer to trigger connection of
   // downstream nodes.  It will also be used to record reference output.
   var referenceProcessor = ctx.createScriptProcessor(bufferSize, 2, 0);
   referenceProcessor.onaudioprocess = onReferenceOutput;
   // Start audioprocess events before source delays are connected.
   referenceProcessor.connect(ctx.destination);
   // The test ScriptProcessor will record output of testPanners.
   // Create it now so that it is synchronized with the referenceProcessor.
   testProcessor = ctx.createScriptProcessor(bufferSize, 2, 0);
   testProcessor.onaudioprocess = onTestOutput;
   // Start audioprocess events before source delays are connected.
   testProcessor.connect(ctx.destination);
 }
 function prepareTest() {
   ctx = new AudioContext();
   // Place the listener to the side of the origin, where the panners are
   // positioned, to maximize delay in one ear.
   ctx.listener.setPosition(1,0,0);
   // A PannerNode will produce no output until it has loaded its HRIR
   // database.  Wait for this to load before starting the test.
   var processor = ctx.createScriptProcessor(bufferSize, 2, 0);
   referencePanner = ctx.createPanner();
   referencePanner.connect(processor);
   var oscillator = ctx.createOscillator();
   oscillator.connect(referencePanner);
   oscillator.start(0);
   processor.onaudioprocess = function(e) {
     if (isChannelSilent(e.inputBuffer.getChannelData(0)))
       return;
     oscillator.stop(0);
     oscillator.disconnect();
     referencePanner.disconnect();
     e.target.onaudioprocess = null;
     SimpleTest.executeSoon(startTest);
   };
 }
 prepareTest();
 </script>
 </pre>
 </body>
 </html>

The Tor Browser / annotate

content/media/webaudio/test/test_pannerNodeTail.html@6474c204b198 (annotated)

content/media/webaudio/test/test_pannerNodeTail.html