audioparam-cancel-and-hold.html

<!DOCTYPE html>

<html>

  <head>

    <title>

      Test CancelValuesAndHoldAtTime

    </title>

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

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

    <script src="/webaudio/resources/audio-param.js"></script>

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

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

  </head>

  <body>

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

      let sampleRate = 48000;

      let renderDuration = 0.5;

      let audit = Audit.createTaskRunner();

      audit.define(

          {label: 'cancelTime', description: 'Test Invalid Values'},

          (task, should) => {

            let context = new OfflineAudioContext({

              numberOfChannels: 1,

              length: 1,

              sampleRate: 8000

});

            let src = new ConstantSourceNode(context);

            src.connect(context.destination);

            should(

                () => src.offset.cancelAndHoldAtTime(-1),

                'cancelAndHoldAtTime(-1)')

                .throw(RangeError);

            // These are TypeErrors because |cancelTime| is a

            // double, not unrestricted double.

            should(

                () => src.offset.cancelAndHoldAtTime(NaN),

                'cancelAndHoldAtTime(NaN)')

                .throw(TypeError);

            should(

                () => src.offset.cancelAndHoldAtTime(Infinity),

                'cancelAndHoldAtTime(Infinity)')

                .throw(TypeError);

            task.done();

});

      // The first few tasks test the cancellation of each relevant automation

      // function.  For the test, a simple linear ramp from 0 to 1 is used to

      // start things off.  Then the automation to be tested is scheduled and

      // cancelled.

      audit.define(

          {label: 'linear', description: 'Cancel linearRampToValueAtTime'},

          function(task, should) {

            cancelTest(should, linearRampTest('linearRampToValueAtTime'), {

              valueThreshold: 8.3998e-5,

              curveThreshold: 5.9605e-5

            }).then(task.done.bind(task));

});

      audit.define(

          {label: 'exponential', description: 'Cancel exponentialRampAtTime'},

          function(task, should) {

            // Cancel an exponential ramp.  The thresholds are experimentally

            // determined.

            cancelTest(should, function(g, v0, t0, cancelTime) {

              // Initialize values to 0.

              g[0].gain.setValueAtTime(0, 0);

              g[1].gain.setValueAtTime(0, 0);

              // Schedule a short linear ramp to start things off.

              g[0].gain.linearRampToValueAtTime(v0, t0);

              g[1].gain.linearRampToValueAtTime(v0, t0);

              // After the linear ramp, schedule an exponential ramp to the end.

              // (This is the event that will be be cancelled.)

              let v1 = 0.001;

              let t1 = renderDuration;

              g[0].gain.exponentialRampToValueAtTime(v1, t1);

              g[1].gain.exponentialRampToValueAtTime(v1, t1);

              expectedConstant = Math.fround(

                  v0 * Math.pow(v1 / v0, (cancelTime - t0) / (t1 - t0)));

              return {

                expectedConstant: expectedConstant,

                autoMessage: 'exponentialRampToValue(' + v1 + ', ' + t1 + ')',

                summary: 'exponentialRampToValueAtTime',

};

            }, {

              valueThreshold: 1.8664e-6,

              curveThreshold: 5.9605e-8

            }).then(task.done.bind(task));

});

      audit.define(

          {label: 'setTarget', description: 'Cancel setTargetAtTime'},

          function(task, should) {

            // Cancel a setTarget event.

            cancelTest(should, function(g, v0, t0, cancelTime) {

              // Initialize values to 0.

              g[0].gain.setValueAtTime(0, 0);

              g[1].gain.setValueAtTime(0, 0);

              // Schedule a short linear ramp to start things off.

              g[0].gain.linearRampToValueAtTime(v0, t0);

              g[1].gain.linearRampToValueAtTime(v0, t0);

              // At the end of the linear ramp, schedule a setTarget.  (This is

              // the event that will be cancelled.)

              let v1 = 0;

              let t1 = t0;

              let timeConstant = 0.05;

              g[0].gain.setTargetAtTime(v1, t1, timeConstant);

              g[1].gain.setTargetAtTime(v1, t1, timeConstant);

              expectedConstant = Math.fround(

                  v1 + (v0 - v1) * Math.exp(-(cancelTime - t0) / timeConstant));

              return {

                expectedConstant: expectedConstant,

                autoMessage: 'setTargetAtTime(' + v1 + ', ' + t1 + ', ' +

                    timeConstant + ')',

                summary: 'setTargetAtTime',

};

            }, {

              valueThreshold: 4.5267e-7,  // 1.1317e-7,

              curveThreshold: 0

            }).then(task.done.bind(task));

});

      audit.define(

          {label: 'setValueCurve', description: 'Cancel setValueCurveAtTime'},

          function(task, should) {

            // Cancel a setValueCurve event.

            cancelTest(should, function(g, v0, t0, cancelTime) {

              // Initialize values to 0.

              g[0].gain.setValueAtTime(0, 0);

              g[1].gain.setValueAtTime(0, 0);

              // Schedule a short linear ramp to start things off.

              g[0].gain.linearRampToValueAtTime(v0, t0);

              g[1].gain.linearRampToValueAtTime(v0, t0);

              // After the linear ramp, schedule a setValuesCurve. (This is the

              // event that will be cancelled.)

              let v1 = 0;

              let duration = renderDuration - t0;

              // For simplicity, a 2-point curve so we get a linear interpolated

              // result.

              let curve = Float32Array.from([v0, 0]);

              g[0].gain.setValueCurveAtTime(curve, t0, duration);

              g[1].gain.setValueCurveAtTime(curve, t0, duration);

              let index =

                  Math.floor((curve.length - 1) / duration * (cancelTime - t0));

              let curvePointsPerFrame =

                  (curve.length - 1) / duration / sampleRate;

              let virtualIndex =

                  (cancelTime - t0) * sampleRate * curvePointsPerFrame;

              let delta = virtualIndex - index;

              expectedConstant = curve[0] + (curve[1] - curve[0]) * delta;

              return {

                expectedConstant: expectedConstant,

                autoMessage: 'setValueCurveAtTime([' + curve + '], ' + t0 +

                    ', ' + duration + ')',

                summary: 'setValueCurveAtTime',

};

            }, {

              valueThreshold: 9.5368e-9,

              curveThreshold: 0

            }).then(task.done.bind(task));

});

      audit.define(

            label: 'setValueCurve after end',

            description: 'Cancel setValueCurveAtTime after the end'

},

          function(task, should) {

            cancelTest(should, function(g, v0, t0, cancelTime) {

              // Initialize values to 0.

              g[0].gain.setValueAtTime(0, 0);

              g[1].gain.setValueAtTime(0, 0);

              // Schedule a short linear ramp to start things off.

              g[0].gain.linearRampToValueAtTime(v0, t0);

              g[1].gain.linearRampToValueAtTime(v0, t0);

              // After the linear ramp, schedule a setValuesCurve. (This is the

              // event that will be cancelled.)  Make sure the curve ends before

              // the cancellation time.

              let v1 = 0;

              let duration = cancelTime - t0 - 0.125;

              // For simplicity, a 2-point curve so we get a linear interpolated

              // result.

              let curve = Float32Array.from([v0, 0]);

              g[0].gain.setValueCurveAtTime(curve, t0, duration);

              g[1].gain.setValueCurveAtTime(curve, t0, duration);

              expectedConstant = curve[1];

              return {

                expectedConstant: expectedConstant,

                autoMessage: 'setValueCurveAtTime([' + curve + '], ' + t0 +

                    ', ' + duration + ')',

                summary: 'setValueCurveAtTime',

};

            }, {

              valueThreshold: 0,

              curveThreshold: 0

            }).then(task.done.bind(task));

});

      // Special case where we schedule a setTarget and there is no earlier

      // automation event.  This tests that we pick up the starting point

      // correctly from the last setting of the AudioParam value attribute.

      audit.define(

            label: 'initial setTarget',

            description: 'Cancel with initial setTargetAtTime'

},

          function(task, should) {

            cancelTest(should, function(g, v0, t0, cancelTime) {

              let v1 = 0;

              let timeConstant = 0.1;

              g[0].gain.value = 1;

              g[0].gain.setTargetAtTime(v1, t0, timeConstant);

              g[1].gain.value = 1;

              g[1].gain.setTargetAtTime(v1, t0, timeConstant);

              let expectedConstant = Math.fround(

                  v1 + (v0 - v1) * Math.exp(-(cancelTime - t0) / timeConstant));

              return {

                expectedConstant: expectedConstant,

                autoMessage: 'setTargetAtTime(' + v1 + ', ' + t0 + ', ' +

                    timeConstant + ')',

                summary: 'Initial setTargetAtTime',

};

            }, {

              valueThreshold: 3.1210e-6,

              curveThreshold: 0

            }).then(task.done.bind(task));

});

      // Test automations scheduled after the call to cancelAndHoldAtTime.

      // Very similar to the above tests, but we also schedule an event after

      // cancelAndHoldAtTime and verify that curve after cancellation has

      // the correct values.

      audit.define(

            label: 'post cancel: Linear',

            description: 'LinearRamp after cancelling'

},

          function(task, should) {

            // Run the cancel test using a linearRamp as the event to be

            // cancelled. Then schedule another linear ramp after the

            // cancellation.

            cancelTest(

                should,

                linearRampTest('Post cancellation linearRampToValueAtTime'),

                {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},

                function(g, cancelTime, expectedConstant) {

                  // Schedule the linear ramp on g[0], and do the same for g[2],

                  // using the starting point given by expectedConstant.

                  let v2 = 2;

                  let t2 = cancelTime + 0.125;

                  g[0].gain.linearRampToValueAtTime(v2, t2);

                  g[2].gain.setValueAtTime(expectedConstant, cancelTime);

                  g[2].gain.linearRampToValueAtTime(v2, t2);

                  return {

                    constantEndTime: cancelTime,

                    message: 'Post linearRamp(' + v2 + ', ' + t2 + ')'

};

})

                .then(task.done.bind(task));

});

      audit.define(

            label: 'post cancel: Exponential',

            description: 'ExponentialRamp after cancelling'

},

          function(task, should) {

            // Run the cancel test using a linearRamp as the event to be

            // cancelled. Then schedule an exponential ramp after the

            // cancellation.

            cancelTest(

                should,

                linearRampTest('Post cancel exponentialRampToValueAtTime'),

                {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},

                function(g, cancelTime, expectedConstant) {

                  // Schedule the exponential ramp on g[0], and do the same for

                  // g[2], using the starting point given by expectedConstant.

                  let v2 = 2;

                  let t2 = cancelTime + 0.125;

                  g[0].gain.exponentialRampToValueAtTime(v2, t2);

                  g[2].gain.setValueAtTime(expectedConstant, cancelTime);

                  g[2].gain.exponentialRampToValueAtTime(v2, t2);

                  return {

                    constantEndTime: cancelTime,

                    message: 'Post exponentialRamp(' + v2 + ', ' + t2 + ')'

};

})

                .then(task.done.bind(task));

});

      audit.define('post cancel: ValueCurve', function(task, should) {

        // Run the cancel test using a linearRamp as the event to be cancelled.

        // Then schedule a setValueCurve after the cancellation.

        cancelTest(

            should, linearRampTest('Post cancel setValueCurveAtTime'),

            {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},

            function(g, cancelTime, expectedConstant) {

              // Schedule the exponential ramp on g[0], and do the same for

              // g[2], using the starting point given by expectedConstant.

              let t2 = cancelTime + 0.125;

              let duration = 0.125;

              let curve = Float32Array.from([.125, 2]);

              g[0].gain.setValueCurveAtTime(curve, t2, duration);

              g[2].gain.setValueAtTime(expectedConstant, cancelTime);

              g[2].gain.setValueCurveAtTime(curve, t2, duration);

              return {

                constantEndTime: cancelTime,

                message: 'Post setValueCurve([' + curve + '], ' + t2 + ', ' +

                    duration + ')',

                errorThreshold: 8.3998e-5

};

})

            .then(task.done.bind(task));

});

      audit.define('post cancel: setTarget', function(task, should) {

        // Run the cancel test using a linearRamp as the event to be cancelled.

        // Then schedule a setTarget after the cancellation.

        cancelTest(

            should, linearRampTest('Post cancel setTargetAtTime'),

            {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},

            function(g, cancelTime, expectedConstant) {

              // Schedule the exponential ramp on g[0], and do the same for

              // g[2], using the starting point given by expectedConstant.

              let v2 = 0.125;

              let t2 = cancelTime + 0.125;

              let timeConstant = 0.1;

              g[0].gain.setTargetAtTime(v2, t2, timeConstant);

              g[2].gain.setValueAtTime(expectedConstant, cancelTime);

              g[2].gain.setTargetAtTime(v2, t2, timeConstant);

              return {

                constantEndTime: cancelTime + 0.125,

                message: 'Post setTargetAtTime(' + v2 + ', ' + t2 + ', ' +

                    timeConstant + ')',

                errorThreshold: 8.4037e-5

};

})

            .then(task.done.bind(task));

});

      audit.define('post cancel: setValue', function(task, should) {

        // Run the cancel test using a linearRamp as the event to be cancelled.

        // Then schedule a setTarget after the cancellation.

        cancelTest(

            should, linearRampTest('Post cancel setValueAtTime'),

            {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},

            function(g, cancelTime, expectedConstant) {

              // Schedule the exponential ramp on g[0], and do the same for

              // g[2], using the starting point given by expectedConstant.

              let v2 = 0.125;

              let t2 = cancelTime + 0.125;

              g[0].gain.setValueAtTime(v2, t2);

              g[2].gain.setValueAtTime(expectedConstant, cancelTime);

              g[2].gain.setValueAtTime(v2, t2);

              return {

                constantEndTime: cancelTime + 0.125,

                message: 'Post setValueAtTime(' + v2 + ', ' + t2 + ')'

};

})

            .then(task.done.bind(task));

});

      audit.define('cancel future setTarget', (task, should) => {

        const context =

            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);

        const src = new ConstantSourceNode(context);

        src.connect(context.destination);

        src.offset.setValueAtTime(0.5, 0);

        src.offset.setTargetAtTime(0, 0.75 * renderDuration, 0.1);

        // Now cancel the effect of the setTarget.

        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);

        src.start();

        context.startRendering()

            .then(buffer => {

              let actual = buffer.getChannelData(0);

              // Because the setTarget was cancelled, the output should be a

              // constant.

              should(actual, 'After cancelling future setTarget event, output')

                  .beConstantValueOf(0.5);

})

            .then(task.done.bind(task));

});

      audit.define('cancel setTarget now', (task, should) => {

        const context =

            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);

        const src = new ConstantSourceNode(context);

        src.connect(context.destination);

        src.offset.setValueAtTime(0.5, 0);

        src.offset.setTargetAtTime(0, 0.5 * renderDuration, 0.1);

        // Now cancel the effect of the setTarget.

        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);

        src.start();

        context.startRendering()

            .then(buffer => {

              let actual = buffer.getChannelData(0);

              // Because the setTarget was cancelled, the output should be a

              // constant.

              should(

                  actual,

                  'After cancelling setTarget event starting now, output')

                  .beConstantValueOf(0.5);

})

            .then(task.done.bind(task));

});

      audit.define('cancel future setValueCurve', (task, should) => {

        const context =

            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);

        const src = new ConstantSourceNode(context);

        src.connect(context.destination);

        src.offset.setValueAtTime(0.5, 0);

        src.offset.setValueCurveAtTime([-1, 1], 0.75 * renderDuration, 0.1);

        // Now cancel the effect of the setTarget.

        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);

        src.start();

        context.startRendering()

            .then(buffer => {

              let actual = buffer.getChannelData(0);

              // Because the setTarget was cancelled, the output should be a

              // constant.

              should(

                  actual, 'After cancelling future setValueCurve event, output')

                  .beConstantValueOf(0.5);

})

            .then(task.done.bind(task));

});

      audit.define('cancel setValueCurve now', (task, should) => {

        const context =

            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);

        const src = new ConstantSourceNode(context);

        src.connect(context.destination);

        src.offset.setValueAtTime(0.5, 0);

        src.offset.setValueCurveAtTime([-1, 1], 0.5 * renderDuration, 0.1);

        // Now cancel the effect of the setTarget.

        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);

        src.start();

        context.startRendering()

            .then(buffer => {

              let actual = buffer.getChannelData(0);

              // Because the setTarget was cancelled, the output should be a

              // constant.

              should(

                  actual,

                  'After cancelling current setValueCurve event starting now, output')

                  .beConstantValueOf(0.5);

})

            .then(task.done.bind(task));

});

      audit.define(

          label: 'linear, cancel, linear, cancel, linear',

          description: 'Schedules 3 linear ramps, cancelling 2 of them, '

            + 'so that we end up with 2 cancel events next to each other'

},

        (task, should) => {

          cancelTest2(

            should,

            linearRampTest('1st linearRamp'),

            {valueThreshold: 0, curveThreshold: 5.9605e-8},

            (g, cancelTime, expectedConstant, cancelTime2) => {

              // Ramp from first cancel time to the end will be cancelled at

              // second cancel time.

              const v1 = expectedConstant;

              const t1 = cancelTime;

              const v2 = 2;

              const t2 = renderDuration;

              g[0].gain.linearRampToValueAtTime(v2, t2);

              g[2].gain.setValueAtTime(v1, t1);

              g[2].gain.linearRampToValueAtTime(v2, t2);

              const expectedConstant2 =

                audioParamLinearRamp(cancelTime2, v1, t1, v2, t2);

              return {

                constantEndTime: cancelTime,

                message: `2nd linearRamp(${v2}, ${t2})`,

                expectedConstant2

};

},

            (g, cancelTime2, expectedConstant2) => {

              // Ramp from second cancel time to the end.

              const v3 = 0;

              const t3 = renderDuration;

              g[0].gain.linearRampToValueAtTime(v3, t3);

              g[3].gain.setValueAtTime(expectedConstant2, cancelTime2);

              g[3].gain.linearRampToValueAtTime(v3, t3);

              return {

                constantEndTime2: cancelTime2,

                message2: `3rd linearRamp(${v3}, ${t3})`,

};

})

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

});

      audit.run();

      // Common function for doing a linearRamp test.  This just does a linear

      // ramp from 0 to v0 at from time 0 to t0.  Then another linear ramp is

      // scheduled from v0 to 0 from time t0 to t1.  This is the ramp that is to

      // be cancelled.

      function linearRampTest(message) {

        return function(g, v0, t0, cancelTime) {

          g[0].gain.setValueAtTime(0, 0);

          g[1].gain.setValueAtTime(0, 0);

          g[0].gain.linearRampToValueAtTime(v0, t0);

          g[1].gain.linearRampToValueAtTime(v0, t0);

          let v1 = 0;

          let t1 = renderDuration;

          g[0].gain.linearRampToValueAtTime(v1, t1);

          g[1].gain.linearRampToValueAtTime(v1, t1);

          expectedConstant =

              Math.fround(v0 + (v1 - v0) * (cancelTime - t0) / (t1 - t0));

          return {

            expectedConstant: expectedConstant,

            autoMessage:

                message + ': linearRampToValue(' + v1 + ', ' + t1 + ')',

            summary: message,

};

      // Run the cancellation test. A set of automations is created and

      // canceled.

//

      // |testerFunction| is a function that generates the automation to be

      // tested.  It is given an array of 3 gain nodes, the value and time of an

      // initial linear ramp, and the time where the cancellation should occur.

      // The function must do the automations for the first two gain nodes.  It

      // must return a dictionary with |expectedConstant| being the value at the

      // cancellation time, |autoMessage| for message to describe the test, and

      // |summary| for general summary message to be printed at the end of the

      // test.

//

      // |thresholdOptions| is a property bag that specifies the error threshold

      // to use. |thresholdOptions.valueThreshold| is the error threshold for

      // comparing the actual constant output after cancelling to the expected

      // value.  |thresholdOptions.curveThreshold| is the error threshold for

      // comparing the actual and expected automation curves before the

      // cancelation point.

//

      // For cancellation tests, |postCancelTest| is a function that schedules

      // some automation after the cancellation.  It takes 3 arguments: an array

      // of the gain nodes, the cancellation time, and the expected value at the

      // cancellation time.  This function must return a dictionary consisting

      // of |constantEndtime| indicating when the held constant from

      // cancellation stops being constant, |message| giving a summary of what

      // automation is being used, and |errorThreshold| that is the error

      // threshold between the expected curve and the actual curve.

//

      function cancelTest(

          should, testerFunction, thresholdOptions, postCancelTest) {

        // Create a context with three channels.  Channel 0 is the test channel

        // containing the actual output that includes the cancellation of

        // events.  Channel 1 is the expected data upto the cancellation so we

        // can verify the cancellation produced the correct result.  Channel 2

        // is for verifying events inserted after the cancellation so we can

        // verify that automations are correctly generated after the

        // cancellation point.

        let context =

            new OfflineAudioContext(3, renderDuration * sampleRate, sampleRate);

        // Test source is a constant signal

        let src = context.createBufferSource();

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

        src.loop = true;

        // We'll do the automation tests with three gain nodes.  One (g0) will

        // have cancelAndHoldAtTime and the other (g1) will not.  g1 is

        // used as the expected result for that automation up to the

        // cancellation point.  They should be the same.  The third node (g2) is

        // used for testing automations inserted after the cancellation point,

        // if any.  g2 is the expected result from the cancellation point to the

        // end of the test.

        let g0 = context.createGain();

        let g1 = context.createGain();

        let g2 = context.createGain();

        let v0 = 1;

        let t0 = 0.01;

        let cancelTime = renderDuration / 2;

        // Test automation here.  The tester function is responsible for setting

        // up the gain nodes with the desired automation for testing.

        autoResult = testerFunction([g0, g1, g2], v0, t0, cancelTime);

        let expectedConstant = autoResult.expectedConstant;

        let autoMessage = autoResult.autoMessage;

        let summaryMessage = autoResult.summary;

        // Cancel scheduled events somewhere in the middle of the test

        // automation.

        g0.gain.cancelAndHoldAtTime(cancelTime);

        let constantEndTime;

        if (postCancelTest) {

          postResult =

              postCancelTest([g0, g1, g2], cancelTime, expectedConstant);

          constantEndTime = postResult.constantEndTime;

        // Connect everything together (with a merger to make a two-channel

        // result).  Channel 0 is the test (with cancelAndHoldAtTime) and

        // channel 1 is the reference (without cancelAndHoldAtTime).

        // Channel 1 is used to verify that everything up to the cancellation

        // has the correct values.

        src.connect(g0);

        src.connect(g1);

        src.connect(g2);

        let merger = context.createChannelMerger(3);

        g0.connect(merger, 0, 0);

        g1.connect(merger, 0, 1);

        g2.connect(merger, 0, 2);

        merger.connect(context.destination);

        // Go!

        src.start();

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

          let actual = buffer.getChannelData(0);

          let expected = buffer.getChannelData(1);

          // The actual output should be a constant from the cancel time to the

          // end.  We use the last value of the actual output as the constant,

          // but we also want to compare that with what we thought it should

          // really be.

          let cancelFrame = Math.ceil(cancelTime * sampleRate);

          // Verify that the curves up to the cancel time are "identical".  The

          // should be but round-off may make them differ slightly due to the

          // way cancelling is done.

          let endFrame = Math.floor(cancelTime * sampleRate);

          should(

              actual.slice(0, endFrame),

              autoMessage + ' up to time ' + cancelTime)

              .beCloseToArray(

                  expected.slice(0, endFrame),

                  {absoluteThreshold: thresholdOptions.curveThreshold});

          // Verify the output after the cancellation is a constant.

          let actualTail;

          let constantEndFrame;

          if (postCancelTest) {

            constantEndFrame = Math.ceil(constantEndTime * sampleRate);

            actualTail = actual.slice(cancelFrame, constantEndFrame);

          } else {

            actualTail = actual.slice(cancelFrame);

          let actualConstant = actual[cancelFrame];

          should(

              actualTail,

              'Cancelling ' + autoMessage + ' at time ' + cancelTime)

              .beConstantValueOf(actualConstant);

          // Verify that the constant is the value we expect.

          should(

              actualConstant,

              'Expected value for cancelling ' + autoMessage + ' at time ' +

                  cancelTime)

              .beCloseTo(

                  expectedConstant,

                  {threshold: thresholdOptions.valueThreshold});

          // Verify the curve after the constantEndTime matches our

          // expectations.

          if (postCancelTest) {

            let c2 = buffer.getChannelData(2);

            should(actual.slice(constantEndFrame), postResult.message)

                .beCloseToArray(

                    c2.slice(constantEndFrame),

                    {absoluteThreshold: postResult.errorThreshold || 0});

});

      // Similar to cancelTest, but does 2 cancels.

      function cancelTest2(

          should, testerFunction, thresholdOptions,

          postCancelTest, postCancelTest2) {

        // Channel 0: Actual output that includes the cancellation of events.

        // Channel 1: Expected data up to the first cancellation.

        // Channel 2: Expected data from 1st cancellation to 2nd cancellation.

        // Channel 3: Expected data from 2nd cancellation to the end.

        const context =

          new OfflineAudioContext(4, renderDuration * sampleRate, sampleRate);

        const src = context.createConstantSource();

        // g0: Actual gain which will have cancelAndHoldAtTime called on it

        // twice.

        // g1: Expected gain from start to the 1st cancel.

        // g2: Expected gain from 1st cancel to the 2nd cancel.

        // g3: Expected gain from the 2nd cancel to the end.

        const g0 = context.createGain();

        const g1 = context.createGain();

        const g2 = context.createGain();

        const g3 = context.createGain();

        const v0 = 1;

        const t0 = 0.01;

        const cancelTime1 = renderDuration * 0.5;

        const cancelTime2 = renderDuration * 0.75;

        // Run testerFunction to generate the 1st ramp.

        const {

          expectedConstant, autoMessage, summaryMessage} =

            testerFunction([g0, g1, g2], v0, t0, cancelTime1);

        // 1st cancel, cancelling the 1st ramp.

        g0.gain.cancelAndHoldAtTime(cancelTime1);

        // Run postCancelTest to generate the 2nd ramp.

        const {

          constantEndTime, message, errorThreshold = 0, expectedConstant2} =

            postCancelTest(

              [g0, g1, g2], cancelTime1, expectedConstant, cancelTime2);

        // 2nd cancel, cancelling the 2nd ramp.

        g0.gain.cancelAndHoldAtTime(cancelTime2);

        // Run postCancelTest2 to generate the 3rd ramp.

        const {constantEndTime2, message2} =

          postCancelTest2([g0, g1, g2, g3], cancelTime2, expectedConstant2);

        // Connect everything together

        src.connect(g0);

        src.connect(g1);

        src.connect(g2);

        src.connect(g3);

        const merger = context.createChannelMerger(4);

        g0.connect(merger, 0, 0);

        g1.connect(merger, 0, 1);

        g2.connect(merger, 0, 2);

        g3.connect(merger, 0, 3);

        merger.connect(context.destination);

        // Go!

        src.start();

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

          const actual = buffer.getChannelData(0);

          const expected1 = buffer.getChannelData(1);

          const expected2 = buffer.getChannelData(2);

          const expected3 = buffer.getChannelData(3);

          const cancelFrame1 = Math.ceil(cancelTime1 * sampleRate);

          const cancelFrame2 = Math.ceil(cancelTime2 * sampleRate);

          const constantEndFrame1 = Math.ceil(constantEndTime * sampleRate);

          const constantEndFrame2 = Math.ceil(constantEndTime2 * sampleRate);

          const actualTail1 = actual.slice(cancelFrame1, constantEndFrame1);

          const actualTail2 = actual.slice(cancelFrame2, constantEndFrame2);

          const actualConstant1 = actual[cancelFrame1];

          const actualConstant2 = actual[cancelFrame2];

          // Verify first section curve

          should(

            actual.slice(0, cancelFrame1),

            autoMessage + ' up to time ' + cancelTime1)

            .beCloseToArray(

              expected1.slice(0, cancelFrame1),

              {absoluteThreshold: thresholdOptions.curveThreshold});

          // Verify that a value was held after 1st cancel

          should(

            actualTail1,

            'Cancelling ' + autoMessage + ' at time ' + cancelTime1)

            .beConstantValueOf(actualConstant1);

          // Verify that held value after 1st cancel was correct

          should(

            actualConstant1,

            'Expected value for cancelling ' + autoMessage + ' at time ' +

            cancelTime1)

            .beCloseTo(

              expectedConstant,

              {threshold: thresholdOptions.valueThreshold});

          // Verify middle section curve

          should(actual.slice(constantEndFrame1, cancelFrame2), message)

            .beCloseToArray(

              expected2.slice(constantEndFrame1, cancelFrame2),

              {absoluteThreshold: errorThreshold});

          // Verify that a value was held after 2nd cancel

          should(

            actualTail2,

            'Cancelling ' + message + ' at time ' + cancelTime2)

            .beConstantValueOf(actualConstant2);

          // Verify that held value after 2nd cancel was correct

          should(

            actualConstant2,

            'Expected value for cancelling ' + message + ' at time ' +

            cancelTime2)

            .beCloseTo(

              expectedConstant2,

              {threshold: thresholdOptions.valueThreshold});

          // Verify end section curve

          should(actual.slice(constantEndFrame2), message2)

            .beCloseToArray(

              expected3.slice(constantEndFrame2),

              {absoluteThreshold: errorThreshold || 0});

});

    </script>

  </body>

</html>

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings