setTargetAtTime-after-event-within-block.html

Enable keyboard shortcuts

This WPT test may be referenced by the following Test IDs:
- /webaudio/the-audio-api/the-audioparam-interface/setTargetAtTime-after-event-within-block.html - WPT Dashboard Interop Dashboard

<!DOCTYPE html>

<title>Test setTargetAtTime after an event in the same processing block</title>

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

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

<script>

promise_test(function() {

  const bufferSize = 179;

  const valueStartOffset = 42;

  const targetStartOffset = 53;

  const sampleRate = 48000;

  const scheduledValue = -0.5;

  var context = new OfflineAudioContext(1, bufferSize, sampleRate);

  var gain = context.createGain();

  gain.gain.setValueAtTime(scheduledValue, valueStartOffset/sampleRate);

  gain.gain.setTargetAtTime(scheduledValue, targetStartOffset/sampleRate,

                            128/sampleRate);

  gain.connect(context.destination);

  // Apply unit DC signal to gain node.

  var source = context.createBufferSource();

  source.buffer =

    function() {

      var buffer = context.createBuffer(1, 1, context.sampleRate);

      buffer.getChannelData(0)[0] = 1.0;

      return buffer;

    }();

  source.loop = true;

  source.start();

  source.connect(gain);

  return context.startRendering().

    then(function(buffer) {

      assert_equals(buffer.length, bufferSize, "output buffer length");

      var output = buffer.getChannelData(0);

      var i = 0;

      for (; i < valueStartOffset; ++i) {

        // "Its default value is 1."

        assert_equals(output[i], 1.0, "default gain at sample " + i);

      for (; i < buffer.length; ++i) {

        // "If the next event (having time T1) after this SetValue event is

        // not of type LinearRampToValue or ExponentialRampToValue, then, for

        // T0≤t<T1: v(t)=V".

        // "Start exponentially approaching the target value at the given time

        // with a rate having the given time constant."

        // The target is the same value, and so the SetValue value continues.

        assert_equals(output[i], scheduledValue,

                      "scheduled value at sample " + i);

});

}, "setTargetAtTime() after setValueAtTime()");

promise_test(async function() {

  const bufferSize = 129;

  const sampleRate = 16384;

  const startSample1 = 125;

  const target1 = Math.fround(-1./Math.expm1(-1.));

  // Intentionally testing the second curve before and after the

  // rendering quantum boundary.

  const startSample2 = startSample1 + 1;

  const target2 = 0.;

  const timeConstant = 1./sampleRate;

  const tolerance = Math.pow(2, -24); // Allow single precision math.

  const context = new OfflineAudioContext(1, bufferSize, sampleRate);

  const source = new ConstantSourceNode(context, {offset: 0.});

  source.start();

  source.offset.setTargetAtTime(target1, startSample1/sampleRate,

                                timeConstant);

  source.offset.setTargetAtTime(target2, startSample2/sampleRate,

                                timeConstant);

  source.connect(context.destination);

  const buffer = await context.startRendering();

  assert_equals(buffer.length, bufferSize, "output buffer length");

  const output = buffer.getChannelData(0);

  for (let i = 0; i <= startSample1; ++i) {

    assert_equals(output[i], 0., "initial offset at sample " + i);

  assert_approx_equals(

    output[startSample2],

    Math.fround(target1 * -Math.expm1(-(startSample2 - startSample1))),

    tolerance,

    "scheduled value at startSample2");

  assert_approx_equals(

    output[startSample2 + 1],

    Math.fround(output[startSample2] * Math.exp(-1.)),

    tolerance,

    "scheduled value at startSample2 + 1");

  assert_approx_equals(

    output[startSample2 + 2],

    Math.fround(output[startSample2] * Math.exp(-2.)),

    tolerance,

    "scheduled value at startSample2 + 2");

}, "setTargetAtTime() after setTargetAtTime()");

</script>