sub-sample-scheduling.html

<!doctype html>

<html>

  <head>

    <title>

      Test Sub-Sample Accurate Scheduling for ABSN

    </title>

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

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

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

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

  </head>

  <body>

    <script>

      // Power of two so there's no roundoff converting from integer frames to

      // time.

      let sampleRate = 32768;

      let audit = Audit.createTaskRunner();

      audit.define('sub-sample accurate start', (task, should) => {

        // There are two channels, one for each source.  Only need to render

        // quanta for this test.

        let context = new OfflineAudioContext(

            {numberOfChannels: 2, length: 8192, sampleRate: sampleRate});

        let merger = new ChannelMergerNode(

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

        merger.connect(context.destination);

        // Use a simple linear ramp for the sources with integer steps starting

        // at 1 to make it easy to verify and test that have sub-sample accurate

        // start.  Ramp starts at 1 so we can easily tell when the source

        // starts.

        let rampBuffer = new AudioBuffer(

            {length: context.length, sampleRate: context.sampleRate});

        let r = rampBuffer.getChannelData(0);

        for (let k = 0; k < r.length; ++k) {

          r[k] = k + 1;

        const src0 = new AudioBufferSourceNode(context, {buffer: rampBuffer});

        const src1 = new AudioBufferSourceNode(context, {buffer: rampBuffer});

        // Frame where sources should start. This is pretty arbitrary, but one

        // should be close to an integer and the other should be close to the

        // next integer.  We do this to catch the case where rounding of the

        // start frame is being done.  Rounding is incorrect.

        const startFrame = 33;

        const startFrame0 = startFrame + 0.1;

        const startFrame1 = startFrame + 0.9;

        src0.connect(merger, 0, 0);

        src1.connect(merger, 0, 1);

        src0.start(startFrame0 / context.sampleRate);

        src1.start(startFrame1 / context.sampleRate);

        context.startRendering()

            .then(audioBuffer => {

              const output0 = audioBuffer.getChannelData(0);

              const output1 = audioBuffer.getChannelData(1);

              // Compute the expected output by interpolating the ramp buffer of

              // the sources if they started at the given frame.

              const ramp = rampBuffer.getChannelData(0);

              const expected0 = interpolateRamp(ramp, startFrame0);

              const expected1 = interpolateRamp(ramp, startFrame1);

              // Verify output0 has the correct values

              // For information only

              should(startFrame0, 'src0 start frame').beEqualTo(startFrame0);

              // Output must be zero before the source start frame, and it must

              // be interpolated correctly after the start frame.  The

              // absoluteThreshold below is currently set for Chrome which does

              // linear interpolation.  This needs to be updated eventually if

              // other browsers do not user interpolation.

              should(

                  output0.slice(0, startFrame + 1), `output0[0:${startFrame}]`)

                  .beConstantValueOf(0);

              should(

                  output0.slice(startFrame + 1, expected0.length),

                  `output0[${startFrame + 1}:${expected0.length - 1}]`)

                  .beCloseToArray(

                      expected0.slice(startFrame + 1), {absoluteThreshold: 0});

              // Verify output1 has the correct values.  Same approach as for

              // output0.

              should(startFrame1, 'src1 start frame').beEqualTo(startFrame1);

              should(

                  output1.slice(0, startFrame + 1), `output1[0:${startFrame}]`)

                  .beConstantValueOf(0);

              should(

                  output1.slice(startFrame + 1, expected1.length),

                  `output1[${startFrame + 1}:${expected1.length - 1}]`)

                  .beCloseToArray(

                      expected1.slice(startFrame + 1), {absoluteThreshold: 0});

})

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

});

      audit.define('sub-sample accurate stop', (task, should) => {

        // There are threes channesl, one for each source.  Only need to render

        // quanta for this test.

        let context = new OfflineAudioContext(

            {numberOfChannels: 3, length: 128, sampleRate: sampleRate});

        let merger = new ChannelMergerNode(

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

        merger.connect(context.destination);

        // The source can be as simple constant for this test.

        let buffer = new AudioBuffer(

            {length: context.length, sampleRate: context.sampleRate});

        buffer.getChannelData(0).fill(1);

        const src0 = new AudioBufferSourceNode(context, {buffer: buffer});

        const src1 = new AudioBufferSourceNode(context, {buffer: buffer});

        const src2 = new AudioBufferSourceNode(context, {buffer: buffer});

        // Frame where sources should start. This is pretty arbitrary, but one

        // should be an integer, one should be close to an integer and the other

        // should be close to the next integer.  This is to catch the case where

        // rounding is used for the end frame.  Rounding is incorrect.

        const endFrame = 33;

        const endFrame1 = endFrame + 0.1;

        const endFrame2 = endFrame + 0.9;

        src0.connect(merger, 0, 0);

        src1.connect(merger, 0, 1);

        src2.connect(merger, 0, 2);

        src0.start(0);

        src1.start(0);

        src2.start(0);

        src0.stop(endFrame / context.sampleRate);

        src1.stop(endFrame1 / context.sampleRate);

        src2.stop(endFrame2 / context.sampleRate);

        context.startRendering()

          .then(audioBuffer => {

            let actual0 = audioBuffer.getChannelData(0);

            let actual1 = audioBuffer.getChannelData(1);

            let actual2 = audioBuffer.getChannelData(2);

            // Just verify that we stopped at the right time.

            // This is case where the end frame is an integer.  Since the first

            // output ends on an exact frame, the output must be zero at that

            // frame number.  We print the end frame for information only; it

            // makes interpretation of the rest easier.

            should(endFrame - 1, 'src0 end frame')

              .beEqualTo(endFrame - 1);

            should(actual0[endFrame - 1], `output0[${endFrame - 1}]`)

              .notBeEqualTo(0);

            should(actual0.slice(endFrame),

                   `output0[${endFrame}:]`)

              .beConstantValueOf(0);

            // The case where the end frame is just a little above an integer.

            // The output must not be zero just before the end and must be zero

            // after.

            should(endFrame1, 'src1 end frame')

              .beEqualTo(endFrame1);

            should(actual1[endFrame], `output1[${endFrame}]`)

              .notBeEqualTo(0);

            should(actual1.slice(endFrame + 1),

                   `output1[${endFrame + 1}:]`)

              .beConstantValueOf(0);

            // The case where the end frame is just a little below an integer.

            // The output must not be zero just before the end and must be zero

            // after.

            should(endFrame2, 'src2 end frame')

              .beEqualTo(endFrame2);

            should(actual2[endFrame], `output2[${endFrame}]`)

              .notBeEqualTo(0);

            should(actual2.slice(endFrame + 1),

                   `output2[${endFrame + 1}:]`)

              .beConstantValueOf(0);

})

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

});

      audit.define('sub-sample-grain', (task, should) => {

        let context = new OfflineAudioContext(

            {numberOfChannels: 2, length: 128, sampleRate: sampleRate});

        let merger = new ChannelMergerNode(

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

        merger.connect(context.destination);

        // The source can be as simple constant for this test.

        let buffer = new AudioBuffer(

            {length: context.length, sampleRate: context.sampleRate});

        buffer.getChannelData(0).fill(1);

        let src0 = new AudioBufferSourceNode(context, {buffer: buffer});

        let src1 = new AudioBufferSourceNode(context, {buffer: buffer});

        src0.connect(merger, 0, 0);

        src1.connect(merger, 0, 1);

        // Start a short grain.

        const src0StartGrain = 3.1;

        const src0EndGrain = 37.2;

        src0.start(

            src0StartGrain / context.sampleRate, 0,

            (src0EndGrain - src0StartGrain) / context.sampleRate);

        const src1StartGrain = 5.8;

        const src1EndGrain = 43.9;

        src1.start(

            src1StartGrain / context.sampleRate, 0,

            (src1EndGrain - src1StartGrain) / context.sampleRate);

        context.startRendering()

            .then(audioBuffer => {

              let output0 = audioBuffer.getChannelData(0);

              let output1 = audioBuffer.getChannelData(1);

              let expected = new Float32Array(context.length);

              // Compute the expected output for output0 and verify the actual

              // output matches.

              expected.fill(1);

              for (let k = 0; k <= Math.floor(src0StartGrain); ++k) {

                expected[k] = 0;

              for (let k = Math.ceil(src0EndGrain); k < expected.length; ++k) {

                expected[k] = 0;

              verifyGrain(should, output0, {

                startGrain: src0StartGrain,

                endGrain: src0EndGrain,

                sourceName: 'src0',

                outputName: 'output0'

});

              verifyGrain(should, output1, {

                startGrain: src1StartGrain,

                endGrain: src1EndGrain,

                sourceName: 'src1',

                outputName: 'output1'

});

})

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

});

      audit.define(

          'sub-sample accurate start with playbackRate', (task, should) => {

            // There are two channels, one for each source.  Only need to render

            // quanta for this test.

            let context = new OfflineAudioContext(

                {numberOfChannels: 2, length: 8192, sampleRate: sampleRate});

            let merger = new ChannelMergerNode(

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

            merger.connect(context.destination);

            // Use a simple linear ramp for the sources with integer steps

            // starting at 1 to make it easy to verify and test that have

            // sub-sample accurate start.  Ramp starts at 1 so we can easily

            // tell when the source starts.

            let buffer = new AudioBuffer(

                {length: context.length, sampleRate: context.sampleRate});

            let r = buffer.getChannelData(0);

            for (let k = 0; k < r.length; ++k) {

              r[k] = k + 1;

            // Two sources with different playback rates

            const src0 = new AudioBufferSourceNode(

                context, {buffer: buffer, playbackRate: .25});

            const src1 = new AudioBufferSourceNode(

                context, {buffer: buffer, playbackRate: 4});

            // Frame where sources start.  Pretty arbitrary but should not be an

            // integer.

            const startFrame = 17.8;

            src0.connect(merger, 0, 0);

            src1.connect(merger, 0, 1);

            src0.start(startFrame / context.sampleRate);

            src1.start(startFrame / context.sampleRate);

            context.startRendering()

                .then(audioBuffer => {

                  const output0 = audioBuffer.getChannelData(0);

                  const output1 = audioBuffer.getChannelData(1);

                  const frameBefore = Math.floor(startFrame);

                  const frameAfter = frameBefore + 1;

                  // Informative message so we know what the following output

                  // indices really mean.

                  should(startFrame, 'Source start frame')

                      .beEqualTo(startFrame);

                  // Verify the output

                  // With a startFrame of 17.8, the first output is at frame 18,

                  // but the actual start is at 17.8.  So we would interpolate

                  // the output 0.2 fraction of the way between 17.8 and 18, for

                  // an output of 1.2 for our ramp.  But the playback rate is

                  // 0.25, so we're really only 1/4 as far along as we think so

                  // the output is .2*0.25 of the way between 1 and 2 or 1.05.

                  const ramp0 = buffer.getChannelData(0)[0];

                  const ramp1 = buffer.getChannelData(0)[1];

                  const src0Output = ramp0 +

                      (ramp1 - ramp0) * (frameAfter - startFrame) *

                          src0.playbackRate.value;

                  let playbackMessage =

                      `With playbackRate ${src0.playbackRate.value}:`;

                  should(

                      output0[frameBefore],

                      `${playbackMessage} output0[${frameBefore}]`)

                      .beEqualTo(0);

                  should(

                      output0[frameAfter],

                      `${playbackMessage} output0[${frameAfter}]`)

                      .beCloseTo(src0Output, {threshold: 4.542e-8});

                  const src1Output = ramp0 +

                      (ramp1 - ramp0) * (frameAfter - startFrame) *

                          src1.playbackRate.value;

                  playbackMessage =

                      `With playbackRate ${src1.playbackRate.value}:`;

                  should(

                      output1[frameBefore],

                      `${playbackMessage} output1[${frameBefore}]`)

                      .beEqualTo(0);

                  should(

                      output1[frameAfter],

                      `${playbackMessage} output1[${frameAfter}]`)

                      .beCloseTo(src1Output, {threshold: 4.542e-8});

})

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

});

      audit.run();

      // Given an input ramp in |rampBuffer|, interpolate the signal assuming

      // this ramp is used for an ABSN that starts at frame |startFrame|, which

      // is not necessarily an integer.  For simplicity we just use linear

      // interpolation here.  The interpolation is not part of the spec but

      // this should be pretty close to whatever interpolation is being done.

      function interpolateRamp(rampBuffer, startFrame) {

        // |start| is the last zero sample before the ABSN actually starts.

        const start = Math.floor(startFrame);

        // One less than the rampBuffer because we can't linearly interpolate

        // the last frame.

        let result = new Float32Array(rampBuffer.length - 1);

        for (let k = 0; k <= start; ++k) {

          result[k] = 0;

        // Now start linear interpolation.

        let frame = startFrame;

        let index = 1;

        for (let k = start + 1; k < result.length; ++k) {

          let s0 = rampBuffer[index];

          let s1 = rampBuffer[index - 1];

          let delta = frame - k;

          let s = s1 - delta * (s0 - s1);

          result[k] = s;

          ++frame;

          ++index;

        return result;

      function verifyGrain(should, output, options) {

        let {startGrain, endGrain, sourceName, outputName} = options;

        let expected = new Float32Array(output.length);

        // Compute the expected output for output and verify the actual

        // output matches.

        expected.fill(1);

        for (let k = 0; k <= Math.floor(startGrain); ++k) {

          expected[k] = 0;

        for (let k = Math.ceil(endGrain); k < expected.length; ++k) {

          expected[k] = 0;

        should(startGrain, `${sourceName} grain start`).beEqualTo(startGrain);

        should(endGrain - startGrain, `${sourceName} grain duration`)

            .beEqualTo(endGrain - startGrain);

        should(endGrain, `${sourceName} grain end`).beEqualTo(endGrain);

        should(output, outputName).beEqualToArray(expected);

        should(

            output[Math.floor(startGrain)],

            `${outputName}[${Math.floor(startGrain)}]`)

            .beEqualTo(0);

        should(

            output[1 + Math.floor(startGrain)],

            `${outputName}[${1 + Math.floor(startGrain)}]`)

            .notBeEqualTo(0);

        should(

            output[Math.floor(endGrain)],

            `${outputName}[${Math.floor(endGrain)}]`)

            .notBeEqualTo(0);

        should(

            output[1 + Math.floor(endGrain)],

            `${outputName}[${1 + Math.floor(endGrain)}]`)

            .beEqualTo(0);

    </script>

  </body>

</html>

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings