<!DOCTYPE html>
<html>
  <head>
    <title>
      AudioBufferSourceNode - playbackRate test
    </title>
    <script src="../../resources/testharness.js"></script>
    <script src="../../resources/testharnessreport.js"></script>
    <script src="../resources/audit-util.js"></script>
    <script src="../resources/audit.js"></script>
  </head>
  <body>
    <script id="layout-test-code">
      let audit = Audit.createTaskRunner();

      // Any sample rate mutiple of 128 is valid for this test, but here it uses
      // 48000Hz because it is a commonly used number that happens to be
      // multiple of 128.
      let sampleRate = 32768;

      // The test iterates over 60 pitches starting from 36. (MIDI pitch of C2)
      let fundamentalPitch = 36;
      let numberOfPitches = 60;

      let noteDuration = Math.floor(0.025 * sampleRate) / sampleRate;
      let totalDuration = noteDuration * numberOfPitches;

      // Test constraints for each octave.
      let testConstraints = [
        {thresholdSNR: 97.215, thresholdDiffULP: 0.6446},
        {thresholdSNR: 97.212, thresholdDiffULP: 0.6446},
        {thresholdSNR: 97.217, thresholdDiffULP: 0.6446},
        {thresholdSNR: 97.196, thresholdDiffULP: 0.6485},
        {thresholdSNR: 97.074, thresholdDiffULP: 0.6915}
      ];

      function pitchToFrequency(midiPitch) {
        return 440 * Math.pow(2, (Math.floor(midiPitch) - 69) / 12);
      }

      function pitchDiffToPlaybackRate(midiPitchDiff) {
        return Math.pow(2, midiPitchDiff / 12);
      }

      function createSineWaveBuffer(context, frequency, duration) {
        let buffer = context.createBuffer(1, duration * sampleRate, sampleRate);
        let data = buffer.getChannelData(0);
        let omega = 2 * Math.PI * frequency / sampleRate;
        for (let i = 0; i < data.length; i++)
          data[i] = Math.sin(omega * i);

        return buffer;
      }

      // This is the fundamental buffer for playbackRate modulation. The
      // duration of this buffer is arbitrary but long enough to produce the
      // sound without running short.
      let fundamentalBuffer;

      // A unit test consists of 2 sources: the 'actual' source runs a buffer
      // with the playback rate modulated and the 'expected' source runs a
      // mathmatically generated sound buffer.
      function runUnitTest(context, noteStart, notePitch) {
        let actualSrc = context.createBufferSource();
        let expectedSrc = context.createBufferSource();
        let merger = context.createChannelMerger(2);

        actualSrc.buffer = fundamentalBuffer;
        expectedSrc.buffer = createSineWaveBuffer(
            context, pitchToFrequency(notePitch), noteDuration);
        actualSrc.playbackRate.value =
            pitchDiffToPlaybackRate(notePitch - fundamentalPitch);

        actualSrc.connect(merger, 0, 0);
        expectedSrc.connect(merger, 0, 1);
        merger.connect(context.destination);

        actualSrc.start(noteStart);
        actualSrc.stop(noteStart + noteDuration);
        expectedSrc.start(noteStart);
        expectedSrc.stop(noteStart + noteDuration);
      }


      // Test if AudioBufferSourceNode.playbackRate can playback at different
      // rates properly.
      audit.define('playbackrate-test', (task, should) => {
        let context =
            new OfflineAudioContext(2, totalDuration * sampleRate, sampleRate);
        fundamentalBuffer = createSineWaveBuffer(
            context, pitchToFrequency(fundamentalPitch), totalDuration);

        // Schedule tests up to 60 pitches above from the fundamental pitch.
        for (let iteration = 0; iteration < numberOfPitches; iteration++)
          runUnitTest(
              context, noteDuration * iteration, fundamentalPitch + iteration);

        // Once the rendering is complete, split the buffer into 5 octaves. Then
        // perform the SNR and the maximum difference ULP check for each octave
        // with different constraints.
        context.startRendering()
            .then(function(renderedBuffer) {
              let actual = renderedBuffer.getChannelData(0);
              let expected = renderedBuffer.getChannelData(1);
              let octaveLength = Math.floor(noteDuration * 12 * sampleRate);

              for (let i = 0; i < numberOfPitches / 12; i++) {
                let start = i * octaveLength;
                let end = (i + 1) * octaveLength;
                let octaveActual = actual.subarray(start, end);
                let octaveExpected = expected.subarray(start, end);

                compareBuffersWithConstraints(
                    should, octaveActual, octaveExpected, {
                      prefix: i,
                      thresholdSNR: testConstraints[i].thresholdSNR,
                      thresholdDiffULP: testConstraints[i].thresholdDiffULP
                    });
              }

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

      audit.run();
    </script>
  </body>
</html>