k-rate-delay-connections.html

Enable keyboard shortcuts

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

<!doctype html>

<html>

  <head>

    <title>k-rate AudioParams with inputs for DelayNode</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();

      // Power-of-two to eliminate round-off in computing time and frames, but

      // is otherwise arbitrary.

      const sampleRate = 8192;

      // Arbitrary duration except it must be greater than or equal to 1.

      const testDuration = 1.5;

      audit.define(

          {label: 'delayTime', description: `DelayNode delayTime k-rate input`},

          async (task, should) => {

            // Two channels:  0 = test result, 1 = expected result.

            let context = new OfflineAudioContext({

              numberOfChannels: 2,

              sampleRate: sampleRate,

              length: testDuration * sampleRate

});

            let merger = new ChannelMergerNode(

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

            merger.connect(context.destination);

            // Test the DelayNode by having a reference node (refNode) that uses

            // k-rate automations of delayTime. The test node (testNode) sets

            // delayTime to k-rate with a connected input that has the same

            // automation vlaues as the reference node.  The test passes if the

            // output from each node is identical to each other.

            // Just some non-constant source.

            let src = new OscillatorNode(context);

            // The end value and time for the linear ramp.  These values are

            // chosen so that the delay advances faster than real time.

            let endValue = 1.125;

            let endTime = 1;

            let refNode;

            should(

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

                `refNode = new DelayNode(context)`)

                .notThrow();

            should(

                () => refNode.delayTime.automationRate = 'k-rate',

                `refNode.delayTime.automationRate = 'k-rate'`)

                .notThrow();

            should(

                () => refNode.delayTime.setValueAtTime(0, 0),

                `refNode.delayTime.setValueAtTime(0, 0)`)

                .notThrow();

            should(

                () => refNode.delayTime.linearRampToValueAtTime(

                    endValue, endTime),

                `refNode.delayTime.linearRampToValueAtTime(${endValue}, ${

                    endTime})`)

                .notThrow();

            let testNode;

            should(

                () => testNode = new DelayNode(context),

                `testNode = new DelayNode(context)`)

                .notThrow();

            should(

                () => testNode.delayTime.automationRate = 'k-rate',

                `testNode.delayTime.automationRate = 'k-rate'`)

                .notThrow();

            let testMod;

            should(

                () => testMod = new ConstantSourceNode(context),

                `testMod = new ConstantSourceNode(context)`)

                .notThrow();

            should(

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

                `testMod.offset.setValueAtTime(0, 0)`)

                .notThrow();

            should(

                () => testMod.offset.linearRampToValueAtTime(endValue, endTime),

                `testMod.offset.linearRampToValueAtTime(${endValue}, ${

                    endTime})`)

                .notThrow();

            should(

                () => testMod.connect(testNode.delayTime),

                `testMod.connect(testNode.delayTime)`)

                .notThrow();

            // Connect up everything and go!

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

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

            src.start();

            testMod.start();

            const buffer = await context.startRendering();

            let expected = buffer.getChannelData(0);

            let actual = buffer.getChannelData(1);

            // Quick sanity check that output isn't zero.  This means we messed

            // up the connections or automations or the buffer source.

            should(expected, `Expected k-rate delayTime AudioParam with input`)

                .notBeConstantValueOf(0);

            should(actual, `Actual k-rate delayTime AudioParam with input`)

                .notBeConstantValueOf(0);

            // Quick sanity check.  The amount of delay after one render is

            // endValue * 128 / sampleRate.  But after 1 render, time has

            // advanced 128/sampleRate.  Hence, the delay exceeds the time by

            // (endValue - 1)*128/sampleRate sec or (endValue - 1)*128 frames.

            // This means the output must be EXACTLY zero for this many frames

            // in the second render.

            let zeroFrames = (endValue - 1) * RENDER_QUANTUM_FRAMES;

            should(

                actual.slice(

                    RENDER_QUANTUM_FRAMES, RENDER_QUANTUM_FRAMES + zeroFrames),

                `output[${RENDER_QUANTUM_FRAMES}, ${

                    RENDER_QUANTUM_FRAMES + zeroFrames - 1}]`)

                .beConstantValueOf(0);

            should(

                actual.slice(

                    RENDER_QUANTUM_FRAMES + zeroFrames,

                    2 * RENDER_QUANTUM_FRAMES),

                `output[${RENDER_QUANTUM_FRAMES + zeroFrames}, ${

                    2 * RENDER_QUANTUM_FRAMES - 1}]`)

                .notBeConstantValueOf(0);

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

            should(actual, `k-rate delayTime AudioParam with input`)

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

});

      audit.run();

    </script>

  </body>

  </html>