detune-limiting.html

Enable keyboard shortcuts

This test has a WPT meta file that expects 5 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /webaudio/the-audio-api/the-oscillatornode-interface/detune-limiting.html - WPT Dashboard Interop Dashboard

<!doctype html>

<html>

  <head>

    <title>

      Oscillator Detune Limits

    </title>

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

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

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

  </head>

  <body>

    <script>

      const sampleRate = 44100;

      const renderLengthSeconds = 0.125;

      let audit = Audit.createTaskRunner();

      audit.define(

            label: 'detune limits',

            description:

                'Oscillator with detune and frequency at Nyquist or above'

},

          (task, should) => {

            let context = new OfflineAudioContext(

                2, renderLengthSeconds * sampleRate, sampleRate);

            let merger = new ChannelMergerNode(

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

            merger.connect(context.destination);

            // For test oscillator, set the oscillator frequency to -Nyquist and

            // set detune to be a large number that would cause the detuned

            // frequency to be way above Nyquist.

            const oscFrequency = 1;

            const detunedFrequency = sampleRate;

            const detuneValue = Math.fround(1200 * Math.log2(detunedFrequency));

            let testOsc = new OscillatorNode(

                context, {frequency: oscFrequency, detune: detuneValue});

            testOsc.connect(merger, 0, 1);

            // For the reference oscillator, determine the computed oscillator

            // frequency using the values above and set that as the oscillator

            // frequency.

            let computedFreq = oscFrequency * Math.pow(2, detuneValue / 1200);

            let refOsc = new OscillatorNode(context, {frequency: computedFreq});

            refOsc.connect(merger, 0, 0);

            // Start 'em up and render

            testOsc.start();

            refOsc.start();

            context.startRendering()

                .then(renderedBuffer => {

                  let expected = renderedBuffer.getChannelData(0);

                  let actual = renderedBuffer.getChannelData(1);

                  // Let user know about the smaple rate so following messages

                  // make more sense.

                  should(context.sampleRate, 'Context sample rate')

                    .beEqualTo(context.sampleRate);

                  // Since the frequency is at Nyquist, the reference oscillator

                  // output should be zero.

                  should(

                      refOsc.frequency.value, 'Reference oscillator frequency')

                      .beGreaterThanOrEqualTo(context.sampleRate / 2);

                  should(

                      expected, `Osc(freq: ${refOsc.frequency.value}) output`)

                      .beConstantValueOf(0);

                  // The output from each oscillator should be the same.

                  should(

                      actual,

                      'Osc(freq: ' + oscFrequency + ', detune: ' + detuneValue +

                          ') output')

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

})

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

});

      audit.define(

            label: 'detune automation',

            description:

                'Oscillator output with detune automation should be zero ' +

                'above Nyquist'

},

          (task, should) => {

            let context = new OfflineAudioContext(

                1, renderLengthSeconds * sampleRate, sampleRate);

            const baseFrequency = 1;

            const rampEnd = renderLengthSeconds / 2;

            const detuneEnd = 1e7;

            let src = new OscillatorNode(context, {frequency: baseFrequency});

            src.detune.linearRampToValueAtTime(detuneEnd, rampEnd);

            src.connect(context.destination);

            src.start();

            context.startRendering()

                .then(renderedBuffer => {

                  let audio = renderedBuffer.getChannelData(0);

                  // At some point, the computed oscillator frequency will go

                  // above Nyquist.  Determine at what time this occurrs.  The

                  // computed frequency is f * 2^(d/1200) where |f| is the

                  // oscillator frequency and |d| is the detune value.  Thus,

                  // find |d| such that Nyquist = f*2^(d/1200). That is, d =

                  // 1200*log2(Nyquist/f)

                  let criticalDetune =

                      1200 * Math.log2(context.sampleRate / 2 / baseFrequency);

                  // Now figure out at what point on the linear ramp does the

                  // detune value reach this critical value.  For a linear ramp:

//

                  //   v(t) = V0+(V1-V0)*(t-T0)/(T1-T0)

//

                  // Thus,

//

                  //   t = ((T1-T0)*v(t) + T0*V1 - T1*V0)/(V1-V0)

//

                  // In this test, T0 = 0, V0 = 0, T1 = rampEnd, V1 =

                  // detuneEnd, and v(t) = criticalDetune

                  let criticalTime = (rampEnd * criticalDetune) / detuneEnd;

                  let criticalFrame =

                      Math.ceil(criticalTime * context.sampleRate);

                  should(

                      criticalFrame,

                      `Frame where detuned oscillator reaches Nyquist`)

                      .beEqualTo(criticalFrame);

                  should(

                      audio.slice(0, criticalFrame),

                      `osc[0:${criticalFrame - 1}]`)

                      .notBeConstantValueOf(0);

                  should(audio.slice(criticalFrame), `osc[${criticalFrame}:]`)

                      .beConstantValueOf(0);

})

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

});

      audit.run();

    </script>

  </body>

</html>