<!DOCTYPE html>
<html>
  <head>
    <title>
      SetTarget Followed by Linear or Exponential Ramp Is Continuous
    </title>
    <script src="../../imported/w3c/web-platform-tests/resources/testharness.js"></script>
    <script src="../../resources/testharnessreport.js"></script>
    <script src="../resources/audit-util.js"></script>
    <script src="../resources/audit.js"></script>
    <script src="../resources/audioparam-testing.js"></script>
  </head>
  <body>
    <script id="layout-test-code">
      let sampleRate = 48000;
      let renderQuantum = 128;
      // Test doesn't need to run for very long.
      let renderDuration = 0.1;
      // Where the ramp should end
      let rampEndTime = renderDuration - .05;
      let renderFrames = renderDuration * sampleRate;
      let timeConstant = 0.01;

      let audit = Audit.createTaskRunner();

      // All of the tests start a SetTargetAtTime after one rendering quantum.
      // The following tests handle various cases where a linear or exponential
      // ramp is scheduled at or after SetTargetAtTime starts.

      audit.define('linear ramp replace', (task, should) => {
        // Schedule a linear ramp to start at the same time as SetTargetAtTime.
        // This effectively replaces the SetTargetAtTime as if it never existed.
        runTest(should, 'Linear ramp', {
          automationFunction: function(audioparam, endValue, endTime) {
            audioparam.linearRampToValueAtTime(endValue, endTime);
          },
          referenceFunction: linearResult,
          automationTime: renderQuantum / sampleRate,
          thresholdSetTarget: 0,
          thresholdRamp: 1.26765e-6
        }).then(() => task.done());
      });

      audit.define('delayed linear ramp', (task, should) => {
        // Schedule a linear ramp to start after the SetTargetAtTime has already
        // started rendering. This is the main test to verify that the linear
        // ramp is continuous with the SetTargetAtTime curve.
        runTest(should, 'Delayed linear ramp', {
          automationFunction: function(audioparam, endValue, endTime) {
            audioparam.linearRampToValueAtTime(endValue, endTime);
          },
          referenceFunction: linearResult,
          automationTime: 4 * renderQuantum / sampleRate,
          thresholdSetTarget: 3.43632e-7,
          thresholdRamp: 1.07972e-6
        }).then(() => task.done());
      });

      audit.define('expo ramp replace', (task, should) => {
        // Like "linear ramp replace", but with an exponential ramp instead.
        runTest(should, 'Exponential ramp', {
          automationFunction: function(audioparam, endValue, endTime) {
            audioparam.exponentialRampToValueAtTime(endValue, endTime);
          },
          referenceFunction: exponentialResult,
          automationTime: renderQuantum / sampleRate,
          thresholdSetTarget: 0,
          thresholdRamp: 1.14441e-5
        }).then(() => task.done());
      });

      audit.define('delayed expo ramp', (task, should) => {
        // Like "delayed linear ramp", but with an exponential ramp instead.
        runTest(should, 'Delayed exponential ramp', {
          automationFunction: function(audioparam, endValue, endTime) {
            audioparam.exponentialRampToValueAtTime(endValue, endTime);
          },
          referenceFunction: exponentialResult,
          automationTime: 4 * renderQuantum / sampleRate,
          thresholdSetTarget: 3.43632e-7,
          thresholdRamp: 4.29154e-6
        }).then(() => task.done());
      });

      audit.run();

      function computeExpectedResult(
          automationTime, timeConstant, endValue, endTime, rampFunction) {
        // The result is a constant value of 1 for one rendering quantum, then a
        // SetTarget event lasting to |automationTime|, at which point a ramp
        // starts which ends at |endValue| at |endTime|.  Then the rest of curve
        // should be held constant at |endValue|.
        let initialPart = new Array(renderQuantum);
        initialPart.fill(1);

        // Generate 1 extra frame so that we know where to start the linear
        // ramp.  The last sample of the array is where the ramp should start
        // from.
        let setTargetPart = createExponentialApproachArray(
            renderQuantum / sampleRate, automationTime + 1 / sampleRate, 1, 0,
            sampleRate, timeConstant);
        let setTargetLength = setTargetPart.length;

        // Generate the ramp starting at |automationTime| with a value from last
        // value of the SetTarget curve above.
        let rampPart = rampFunction(
            automationTime, endTime, setTargetPart[setTargetLength - 1],
            endValue, sampleRate);

        // Finally finish out the rest with a constant value of |endValue|, if
        // needed.
        let finalPart =
            new Array(Math.floor((renderDuration - endTime) * sampleRate));
        finalPart.fill(endValue);

        // Return the four parts separately for testing.
        return {
          initialPart: initialPart,
          setTargetPart: setTargetPart.slice(0, setTargetLength - 1),
          rampPart: rampPart,
          tailPart: finalPart
        };
      }

      function linearResult(automationTime, timeConstant, endValue, endTime) {
        return computeExpectedResult(
            automationTime, timeConstant, endValue, endTime,
            createLinearRampArray);
      }

      function exponentialResult(
          automationTime, timeConstant, endValue, endTime) {
        return computeExpectedResult(
            automationTime, timeConstant, endValue, endTime,
            createExponentialRampArray);
      }

      // Run test to verify that a SetTarget followed by a ramp produces a
      // continuous curve. |prefix| is a string to use as a prefix for the
      // messages. |options| is a dictionary describing how the test is run:
      //
      //   |options.automationFunction|
      //     The function to use to start the automation, which should be a
      //     linear or exponential ramp automation.  This function has three
      //     arguments:
      //       audioparam - the AudioParam to be automated
      //       endValue   - the end value of the ramp
      //       endTime    - the end time fo the ramp.
      //   |options.referenceFunction|
      //     The function to generated the expected result.  This function has
      //     four arguments:
      //       automationTime - the value of  |options.automationTime|
      //       timeConstant   - time constant used for SetTargetAtTime
      //       rampEndValue   - end value for the ramp (same value used for
      //       automationFunction) rampEndTime    - end time for the ramp (same
      //       value used for automationFunction)
      //   |options.automationTime|
      //     Time at which the |automationFunction| is called to start the
      //     automation.
      //   |options.thresholdSetTarget|
      //     Threshold to use for verifying that the initial (if any)
      //     SetTargetAtTime portion had the correct values.
      //   |options.thresholdRamp|
      //     Threshold to use for verifying that the ramp portion had the
      //     correct values.
      function runTest(should, prefix, options) {
        let automationFunction = options.automationFunction;
        let referenceFunction = options.referenceFunction;
        let automationTime = options.automationTime;
        let thresholdSetTarget = options.thresholdSetTarget || 0;
        let thresholdRamp = options.thresholdRamp || 0;

        // End value for the ramp.  Fairly arbitrary, but should be distinctly
        // different from the target value for SetTargetAtTime and the initial
        // value of gain.gain.
        let rampEndValue = 2;
        let context = new OfflineAudioContext(1, renderFrames, sampleRate);

        // A constant source of amplitude 1.
        let source = context.createBufferSource();
        source.buffer = createConstantBuffer(context, 1, 1);
        source.loop = true;

        let gain = context.createGain();

        // The SetTarget starts after one rendering quantum.
        gain.gain.setTargetAtTime(
            0, renderQuantum / context.sampleRate, timeConstant);

        // Schedule the ramp at |automationTime|.  If this time is past the
        // first rendering quantum, the SetTarget event will run for a bit
        // before running the ramp.  Otherwise, the SetTarget should be
        // completely replaced by the ramp.
        context.suspend(automationTime).then(function() {
          automationFunction(gain.gain, rampEndValue, rampEndTime);
          context.resume();
        });

        source.connect(gain);
        gain.connect(context.destination);

        source.start();

        return context.startRendering().then(function(resultBuffer) {
          let success = true;
          let result = resultBuffer.getChannelData(0);
          let expected = referenceFunction(
              automationTime, timeConstant, rampEndValue, rampEndTime);

          // Verify each part of the curve separately.
          let startIndex = 0;
          let length = expected.initialPart.length;

          // Verify that the initial part of the curve is constant.
          should(result.slice(0, length), prefix + ': Initial part')
              .beCloseToArray(expected.initialPart);

          // Verify the SetTarget part of the curve, if the SetTarget did
          // actually run.
          startIndex += length;
          length = expected.setTargetPart.length;
          if (length) {
            should(
                result.slice(startIndex, startIndex + length),
                prefix + ': SetTarget part')
                .beCloseToArray(
                    expected.setTargetPart,
                    {absoluteThreshold: thresholdSetTarget});
          } else {
            should(!length, prefix + ': SetTarget part')
                .message(
                    'was correctly replaced by the ramp',
                    'was incorrectly replaced by the ramp');
          }

          // Verify the ramp part of the curve
          startIndex += length;
          length = expected.rampPart.length;
          should(result.slice(startIndex, startIndex + length), prefix)
              .beCloseToArray(
                  expected.rampPart, {absoluteThreshold: thresholdRamp});

          // Verify that the end of the curve after the ramp (if any) is a
          // constant.
          startIndex += length;
          should(result.slice(startIndex), prefix + ': Tail part')
              .beCloseToArray(expected.tailPart);

        });
      }
    </script>
  </body>
</html>