active-processing.https.html

Enable keyboard shortcuts

This WPT test may be referenced by the following Test IDs:
- /webaudio/the-audio-api/the-channelmergernode-interface/active-processing.https.html - WPT Dashboard Interop Dashboard

<!DOCTYPE html>

<html>

  <head>

    <title>

      Test Active Processing for ChannelMergerNode

    </title>

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

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

  </head>

  <body>

    <script>

      // AudioProcessor that sends a message to its AudioWorkletNode whenver the

      // number of channels on its input changes.

      const filePath =

          '../the-audioworklet-interface/processors/active-processing.js';

      let context;

      // Keep one promise_test to load module

      // and set up context (so ordering is explicit).

      promise_test(() => {

        // Create context and load the module

        context = new AudioContext();

        return context.audioWorklet.addModule(filePath);

      }, 'initialize: AudioWorklet module loading');

      promise_test(() => {

        return new Promise(resolve => {

          const src = new OscillatorNode(context);

          // Number of inputs for the ChannelMergerNode.  Pretty arbitrary, but

          // should not be 1.

          const numberOfInputs = 7;

          const merger =

              new ChannelMergerNode(context, {numberOfInputs: numberOfInputs});

          const testerNode =

              new AudioWorkletNode(context, 'active-processing-tester', {

                // Use as short a duration as possible to keep the test from

                // taking too much time.

                processorOptions: {testDuration: .5},

});

          // Expected number of output channels from the merger node.  We should

          // start with the number of inputs, because the source (oscillator) is

          // actively processing.  When the source stops, the number of channels

          // should change to 0.

          const expectedValues = [numberOfInputs, 0];

          let index = 0;

          testerNode.port.onmessage = event => {

            const count = event.data.channelCount;

            const finished = event.data.finished;

            // If we're finished, end testing.

            if (finished) {

              // Verify that we got the expected number of changes.

              assert_equals(

                  index, expectedValues.length, 'Number of distinct values');

              resolve();

              return;

            if (index < expectedValues.length) {

              // Verify that the number of channels matches the expected number

              // of channels.

              assert_equals(

                  count, expectedValues[index],

                  `Test ${index}: Number of convolver output channels`);

            ++index;

};

          // Create the graph and go

          src.connect(merger).connect(testerNode).connect(context.destination);

          src.start();

          // Stop the source after a short time so we can test that the channel

          // merger changes to not actively processing and thus produces a

          // single channel of silence.

          src.stop(context.currentTime + .1);

});

      }, 'test: Active processing emits expected channel-count changes');

    </script>

  </body>

</html>