k-rate-dynamics-compressor-connections.html

Enable keyboard shortcuts

This test has a WPT meta file that expects 4 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /webaudio/the-audio-api/the-audioparam-interface/k-rate-dynamics-compressor-connections.html - WPT Dashboard Interop Dashboard

<!doctype html>

<html>

  <head>

    <title>k-rate AudioParams with inputs for DynamicsCompressorNode</title>

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

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

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

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

  </head>

  <body>

    <script>

      let audit = Audit.createTaskRunner();

      // Fairly abitrary sampleRate and somewhat duration

      const sampleRate = 48000;

      const testDuration = 0.25;

      ['attack', 'knee', 'ratio', 'release', 'threshold'].forEach(param => {

        audit.define(

            {label: param, description: `Dynamics compressor ${param}`},

            async (task, should) => {

              await doTest(should, {prefix: task.label, paramName: param});

              task.done();

});

});

      audit.run();

      async function doTest(should, options) {

        // Test k-rate automation of DynamicsCompressorNode with connected

        // input.

//

        // A reference compressor node is created with an automation on the

        // selected AudioParam. For simplicity, we just use a linear ramp from

        // the minValue to the maxValue of the AudioParam.

//

        // The test node has an input signal connected to the AudioParam.  This

        // input signal is created to match the automation on the reference

        // node.

//

        // Finally, the output from the two nodes must be identical if k-rate

        // inputs are working correctly.

//

        // Options parameter is a dictionary with the following required

        // members:

        //   prefix    - prefix to use for the messages.

        //   paramName - Name of the AudioParam to be tested

        let {prefix, paramName} = options;

        let context = new OfflineAudioContext({

          numberOfChannels: 2,

          sampleRate: sampleRate,

          length: testDuration * sampleRate

});

        let merger = new ChannelMergerNode(

            context, {numberOfInputs: context.destination.channelCount});

        merger.connect(context.destination);

        // Use an oscillator for the source.  Pretty arbitrary parameters.

        let src =

            new OscillatorNode(context, {type: 'sawtooth', frequency: 440});

        // Create the reference and test nodes.

        let refNode;

        let tstNode;

        should(

            () => refNode = new DynamicsCompressorNode(context),

            `${prefix}: refNode = new DynamicsCompressorNode(context)`)

            .notThrow();

        let tstOptions = {};

        tstOptions[paramName] = refNode[paramName].minValue;

        should(

            () => tstNode = new DynamicsCompressorNode(context, tstOptions),

            `${prefix}: tstNode = new DynamicsCompressorNode(context, ${

                JSON.stringify(tstOptions)})`)

            .notThrow();

        // Automate the AudioParam of the reference node with a linear ramp

        should(

            () => refNode[paramName].setValueAtTime(

                refNode[paramName].minValue, 0),

            `${prefix}: refNode[${paramName}].setValueAtTime(refNode[${

                paramName}].minValue, 0)`)

            .notThrow();

        should(

            () => refNode[paramName].linearRampToValueAtTime(

                refNode[paramName].maxValue, testDuration),

            `${prefix}: refNode[${paramName}].linearRampToValueAtTime(refNode[${

                paramName}].minValue, ${testDuration})`)

            .notThrow();

        // Create the input node and automate it so that it's output when added

        // to the intrinsic value of the AudioParam we get the same values as

        // the automations on the ference node.  We need to do it this way

        // because the ratio AudioParam has a nominal range of [1, 20] so we

        // can't just set the value to 0, which is what we'd normally do.

        let mod;

        should(

            () => mod = new ConstantSourceNode(context, {offset: 0}),

            `${prefix}: mod = new ConstantSourceNode(context, {offset: 0})`)

            .notThrow();

        let endValue =

            refNode[paramName].maxValue - refNode[paramName].minValue;

        should(

            () => mod.offset.setValueAtTime(0, 0),

            `${prefix}: mod.offset.setValueAtTime(0, 0)`)

            .notThrow();

        should(

            () => mod.offset.linearRampToValueAtTime(endValue, testDuration),

            `${prefix}: mod.offset.linearRampToValueAtTime(${endValue}, ${

                testDuration})`)

            .notThrow();

        // Connect up everything.

        should(

            () => mod.connect(tstNode[paramName]),

            `${prefix}: mod.connect(tstNode[${paramName}])`)

            .notThrow();

        src.connect(refNode).connect(merger, 0, 0);

        src.connect(tstNode).connect(merger, 0, 1);

        // Go!

        src.start();

        mod.start();

        const buffer = await context.startRendering();

        let expected = buffer.getChannelData(0);

        let actual = buffer.getChannelData(1);

        // The expected and actual results must be EXACTLY the same.

        should(actual, `k-rate ${paramName} AudioParam with input`)

            .beCloseToArray(expected, {absoluteThreshold: 0});

    </script>

  </body>

</html>