waveshaper-limits.html

Enable keyboard shortcuts

This WPT test may be referenced by the following Test IDs:
- /webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-limits.html - WPT Dashboard Interop Dashboard

<!DOCTYPE html>

<html>

  <head>

    <title>

      waveshaper-limits.html

    </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>

  </head>

  <body>

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

      let audit = Audit.createTaskRunner();

      let context;

      let bufferData;

      let outputData;

      let reference;

      let sampleRate = 48000;

      // Must be odd so we have an exact middle point.

      let testFrames = 23;

      let scale = 1 / ((testFrames - 1) / 2 - 1);

      // Number of decimal digits to print

      let decimals = 6;

      // Required accuracy

      let diffThreshold = Math.pow(10, -decimals);

      // Generate reference data

      function generateReference() {

        // The curve data is 0, 1, 0, and the input data is a ramp from -1+eps

        // to 1+eps.  Then the output is a ramp from 0 to 1 back to 0.

        let ref = new Float32Array(testFrames);

        let midPoint = (testFrames - 1) / 2;

        // First sample is below -1 at -1-scale.

        ref[0] = 0;

        // Generate ramp up to the mid-point

        for (let k = 0; k < midPoint; ++k) {

          ref[k + 1] = k * scale;

        // The value at the mid-point must be 1, from the curve

        ref[midPoint] = 1;

        // Generate a ramp from 1 down to 0

        for (let k = midPoint; k < testFrames - 1; ++k) {

          ref[k + 1] = 2 - k * scale;

        // The last sample is out of range at 1+scale

        ref[testFrames - 1] = 0;

        return ref;

      function checkResult(renderedBuffer, should) {

        outputData = renderedBuffer.getChannelData(0);

        reference = generateReference();

        let success = true;

        // Verify that every output value matches our expected reference value.

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

          let diff = outputData[k] - reference[k];

          should(

              Math.abs(diff),

              'Max error mapping ' + bufferData[k].toFixed(decimals) + ' to ' +

                  outputData[k].toFixed(decimals))

              .beLessThanOrEqualTo(diffThreshold);

      audit.define(

            label: 'test',

            description:

                'WaveShaperNode including values outside the range of [-1,1]'

},

          function(task, should) {

            context = new OfflineAudioContext(1, testFrames, sampleRate);

            // Create input values between -1.1 and 1.1

            let buffer =

                context.createBuffer(1, testFrames, context.sampleRate);

            bufferData = new Float32Array(testFrames);

            let start = -1 - scale;

            for (let k = 0; k < testFrames; ++k) {

              bufferData[k] = k * scale + start;

            buffer.copyToChannel(bufferData, 0);

            let source = context.createBufferSource();

            source.buffer = buffer;

            // Create simple waveshaper. It should map -1 to 0, 0 to 1, and +1

            // to 0 and interpolate all points in between using a simple linear

            // interpolator.

            let shaper = context.createWaveShaper();

            let curve = new Float32Array(3);

            curve[0] = 0;

            curve[1] = 1;

            curve[2] = 0;

            shaper.curve = curve;

            source.connect(shaper);

            shaper.connect(context.destination);

            source.start();

            context.startRendering()

                .then(buffer => checkResult(buffer, should))

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

});

      audit.run();

    </script>

  </body>

</html>