panner-automation-position.html

<!DOCTYPE html>

<html>

  <head>

    <title>

      Test Automation of PannerNode Positions

    </title>

    <script src="/resources/testharness.js"></script>

    <script src="/resources/testharnessreport.js"></script>

    <script src="../../resources/audit-util.js"></script>

    <script src="../../resources/audit.js"></script>

    <script src="../../resources/panner-formulas.js"></script>

  </head>

  <body>

    <script id="layout-test-code">

      let sampleRate = 48000;

      // These tests are quite slow, so don't run for many frames.  256 frames

      // should be enough to demonstrate that automations are working.

      let renderFrames = 256;

      let renderDuration = renderFrames / sampleRate;

      let context;

      let panner;

      let audit = Audit.createTaskRunner();

      // Set of tests for the panner node with automations applied to the

      // position of the source.

      let testConfigs = [

          // Distance model parameters for the panner

          distanceModel: {model: 'inverse', rolloff: 1},

          // Initial location of the source

          startPosition: [0, 0, 1],

          // Final position of the source.  For this test, we only want to move

          // on the z axis which

          // doesn't change the azimuth angle.

          endPosition: [0, 0, 10000],

},

          distanceModel: {model: 'inverse', rolloff: 1},

          startPosition: [0, 0, 1],

          // An essentially random end position, but it should be such that

          // azimuth angle changes as

          // we move from the start to the end.

          endPosition: [20000, 30000, 10000],

          errorThreshold: [

              // Error threshold for 1-channel case

              relativeThreshold: 4.8124e-7

},

              // Error threshold for 2-channel case

              relativeThreshold: 4.3267e-7

],

},

          distanceModel: {model: 'exponential', rolloff: 1.5},

          startPosition: [0, 0, 1],

          endPosition: [20000, 30000, 10000],

          errorThreshold:

              [{relativeThreshold: 5.0783e-7}, {relativeThreshold: 5.2180e-7}]

},

          distanceModel: {model: 'linear', rolloff: 1},

          startPosition: [0, 0, 1],

          endPosition: [20000, 30000, 10000],

          errorThreshold: [

            {relativeThreshold: 6.5324e-6}, {relativeThreshold: 6.5756e-6}

];

      for (let k = 0; k < testConfigs.length; ++k) {

        let config = testConfigs[k];

        let tester = function(c, channelCount) {

          return (task, should) => {

            runTest(should, c, channelCount).then(() => task.done());

};

        let baseTestName = config.distanceModel.model +

            ' rolloff: ' + config.distanceModel.rolloff;

        // Define tasks for both 1-channel and 2-channel

        audit.define(k + ': 1-channel ' + baseTestName, tester(config, 1));

        audit.define(k + ': 2-channel ' + baseTestName, tester(config, 2));

      audit.run();

      function runTest(should, options, channelCount) {

        // Output has 5 channels: channels 0 and 1 are for the stereo output of

        // the panner node. Channels 2-5 are the for automation of the x,y,z

        // coordinate so that we have actual coordinates used for the panner

        // automation.

        context = new OfflineAudioContext(5, renderFrames, sampleRate);

        // Stereo source for the panner.

        let source = context.createBufferSource();

        source.buffer = createConstantBuffer(

            context, renderFrames, channelCount == 1 ? 1 : [1, 2]);

        panner = context.createPanner();

        panner.distanceModel = options.distanceModel.model;

        panner.rolloffFactor = options.distanceModel.rolloff;

        panner.panningModel = 'equalpower';

        // Source and gain node for the z-coordinate calculation.

        let dist = context.createBufferSource();

        dist.buffer = createConstantBuffer(context, 1, 1);

        dist.loop = true;

        let gainX = context.createGain();

        let gainY = context.createGain();

        let gainZ = context.createGain();

        dist.connect(gainX);

        dist.connect(gainY);

        dist.connect(gainZ);

        // Set the gain automation to match the z-coordinate automation of the

        // panner.

        // End the automation some time before the end of the rendering so we

        // can verify that automation has the correct end time and value.

        let endAutomationTime = 0.75 * renderDuration;

        gainX.gain.setValueAtTime(options.startPosition[0], 0);

        gainX.gain.linearRampToValueAtTime(

            options.endPosition[0], endAutomationTime);

        gainY.gain.setValueAtTime(options.startPosition[1], 0);

        gainY.gain.linearRampToValueAtTime(

            options.endPosition[1], endAutomationTime);

        gainZ.gain.setValueAtTime(options.startPosition[2], 0);

        gainZ.gain.linearRampToValueAtTime(

            options.endPosition[2], endAutomationTime);

        dist.start();

        // Splitter and merger to map the panner output and the z-coordinate

        // automation to the correct channels in the destination.

        let splitter = context.createChannelSplitter(2);

        let merger = context.createChannelMerger(5);

        source.connect(panner);

        // Split the output of the panner to separate channels

        panner.connect(splitter);

        // Merge the panner outputs and the z-coordinate output to the correct

        // destination channels.

        splitter.connect(merger, 0, 0);

        splitter.connect(merger, 1, 1);

        gainX.connect(merger, 0, 2);

        gainY.connect(merger, 0, 3);

        gainZ.connect(merger, 0, 4);

        merger.connect(context.destination);

        // Initialize starting point of the panner.

        panner.positionX.setValueAtTime(options.startPosition[0], 0);

        panner.positionY.setValueAtTime(options.startPosition[1], 0);

        panner.positionZ.setValueAtTime(options.startPosition[2], 0);

        // Automate z coordinate to move away from the listener

        panner.positionX.linearRampToValueAtTime(

            options.endPosition[0], 0.75 * renderDuration);

        panner.positionY.linearRampToValueAtTime(

            options.endPosition[1], 0.75 * renderDuration);

        panner.positionZ.linearRampToValueAtTime(

            options.endPosition[2], 0.75 * renderDuration);

        source.start();

        // Go!

        return context.startRendering().then(function(renderedBuffer) {

          // Get the panner outputs

          let data0 = renderedBuffer.getChannelData(0);

          let data1 = renderedBuffer.getChannelData(1);

          let xcoord = renderedBuffer.getChannelData(2);

          let ycoord = renderedBuffer.getChannelData(3);

          let zcoord = renderedBuffer.getChannelData(4);

          // We're doing a linear ramp on the Z axis with the equalpower panner,

          // so the equalpower panning gain remains constant.  We only need to

          // model the distance effect.

          // Compute the distance gain

          let distanceGain = new Float32Array(xcoord.length);

          if (panner.distanceModel === 'inverse') {

            for (let k = 0; k < distanceGain.length; ++k) {

              distanceGain[k] =

                  inverseDistance(panner, xcoord[k], ycoord[k], zcoord[k])

          } else if (panner.distanceModel === 'linear') {

            for (let k = 0; k < distanceGain.length; ++k) {

              distanceGain[k] =

                  linearDistance(panner, xcoord[k], ycoord[k], zcoord[k])

          } else if (panner.distanceModel === 'exponential') {

            for (let k = 0; k < distanceGain.length; ++k) {

              distanceGain[k] =

                  exponentialDistance(panner, xcoord[k], ycoord[k], zcoord[k])

          // Compute the expected result.  Since we're on the z-axis, the left

          // and right channels pass through the equalpower panner unchanged.

          // Only need to apply the distance gain.

          let buffer0 = source.buffer.getChannelData(0);

          let buffer1 =

              channelCount == 2 ? source.buffer.getChannelData(1) : buffer0;

          let azimuth = new Float32Array(buffer0.length);

          for (let k = 0; k < data0.length; ++k) {

            azimuth[k] = calculateAzimuth(

                [xcoord[k], ycoord[k], zcoord[k]],

                  context.listener.positionX.value,

                  context.listener.positionY.value,

                  context.listener.positionZ.value

],

                  context.listener.forwardX.value,

                  context.listener.forwardY.value,

                  context.listener.forwardZ.value

],

                  context.listener.upX.value, context.listener.upY.value,

                  context.listener.upZ.value

]);

          let expected = applyPanner(azimuth, buffer0, buffer1, channelCount);

          let expected0 = expected.left;

          let expected1 = expected.right;

          for (let k = 0; k < expected0.length; ++k) {

            expected0[k] *= distanceGain[k];

            expected1[k] *= distanceGain[k];

          let info = options.distanceModel.model +

              ', rolloff: ' + options.distanceModel.rolloff;

          let prefix = channelCount + '-channel ' +

              '[' + options.startPosition[0] + ', ' + options.startPosition[1] +

              ', ' + options.startPosition[2] + '] -> [' +

              options.endPosition[0] + ', ' + options.endPosition[1] + ', ' +

              options.endPosition[2] + ']: ';

          let errorThreshold = 0;

          if (options.errorThreshold)

            errorThreshold = options.errorThreshold[channelCount - 1]

            should(data0, prefix + 'distanceModel: ' + info + ', left channel')

                .beCloseToArray(expected0, {absoluteThreshold: errorThreshold});

          should(data1, prefix + 'distanceModel: ' + info + ', right channel')

              .beCloseToArray(expected1, {absoluteThreshold: errorThreshold});

});

    </script>

  </body>

</html>

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings