| <!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> |
