| <!DOCTYPE html> |
| <!-- |
| Tests that AudioBufferSourceNode supports loop-points with .loopStart and .loopEnd. |
| --> |
| <html> |
| <head> |
| <title> |
| audiobuffersource-loop-points.html |
| </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> |
| <script src="../resources/audio-file-utils.js"></script> |
| </head> |
| <body> |
| <script id="layout-test-code"> |
| let audit = Audit.createTaskRunner(); |
| |
| // Use power of two to eliminate round-off in computing frames from time |
| // and vice versa. |
| let sampleRate = 32768; |
| let numberOfNotes = 60; // play over a 5 octave range |
| // Make sure noteDuration, noteSilence, and noteSpacing are exactly whole |
| // frames. |
| let noteDuration = Math.floor(0.025 * sampleRate) / sampleRate; |
| // Leave about 5ms of silence between each "note" |
| let noteSilence = Math.floor(0.005 * sampleRate) / sampleRate; |
| let noteSpacing = noteDuration + noteSilence; |
| let lengthInSeconds = numberOfNotes * noteSpacing; |
| |
| let context = 0; |
| let expectedAudio; |
| |
| function createTestBuffer(frequency, sampleRate) { |
| // Create a buffer containing two periods at this frequency. |
| // The 1st half is a pure sine wave period scaled by a linear ramp from |
| // 0 -> 1. The 2nd half of the buffer corresponds exactly to one pure |
| // sine wave period. |
| let onePeriodDuration = 1 / frequency; |
| let sampleFrameLength = 2 * onePeriodDuration * sampleRate; |
| |
| let audioBuffer = |
| context.createBuffer(1, sampleFrameLength, sampleRate); |
| |
| let n = audioBuffer.length; |
| let channelData = audioBuffer.getChannelData(0); |
| |
| for (let i = 0; i < n; ++i) { |
| let sample = Math.sin(frequency * 2.0 * Math.PI * i / sampleRate); |
| |
| // Linear ramp from 0 -> 1 for the first period. |
| // Stay at 1 for the 2nd period. |
| let scale = i < n / 2 ? i / (n / 2) : 1; |
| sample *= scale; |
| |
| channelData[i] = sample; |
| } |
| |
| return audioBuffer; |
| } |
| |
| function playNote(buffer, time, duration, playbackRate) { |
| let source = context.createBufferSource(); |
| source.buffer = buffer; |
| source.playbackRate.value = playbackRate; |
| |
| let gainNode = context.createGain(); |
| source.connect(gainNode); |
| gainNode.connect(context.destination); |
| |
| // Loop the 2nd half of the buffer. |
| // We should be able to hear any problems as glitches if the looping |
| // incorrectly indexes to anywhere outside of the desired loop-points, |
| // since only the 2nd half is a perfect sine-wave cycle, while the 1st |
| // half of the buffer contains a linear ramp of a sine-wave cycle. |
| source.loop = true; |
| source.loopStart = 0.5 * buffer.duration; |
| source.loopEnd = buffer.duration; |
| |
| // Play for the given duration. |
| source.start(time); |
| source.stop(time + duration); |
| |
| // Apply a quick linear fade-out to avoid a click at the end of the |
| // note. |
| gainNode.gain.value = 1; |
| gainNode.gain.setValueAtTime(1, time + duration - 0.005); |
| gainNode.gain.linearRampToValueAtTime(0, time + duration); |
| } |
| |
| audit.define( |
| { |
| label: 'initialize', |
| description: 'Set up context and expected results' |
| }, |
| async (task, should) => { |
| // Create offline audio context. |
| should( |
| () => {context = new OfflineAudioContext( |
| 2, sampleRate * lengthInSeconds, sampleRate)}, |
| 'Creating context for testing') |
| .notThrow(); |
| |
| const arrayBuffer = await Audit.loadFileFromUrl( |
| 'resources/audiobuffersource-loop-points-expected.wav'); |
| expectedAudio = await context.decodeAudioData(arrayBuffer); |
| task.done(); |
| }); |
| |
| audit.define( |
| { |
| label: 'test', |
| description: 'Test loop points and compare with expected results' |
| }, |
| (task, should) => { |
| // Create the test buffer. |
| // We'll loop this with the loop-points set for the 2nd half of this |
| // buffer. |
| let buffer = createTestBuffer(440.0, sampleRate); |
| |
| // Play all the notes as a chromatic scale. |
| for (let i = 0; i < numberOfNotes; ++i) { |
| let time = i * noteSpacing; |
| // start three octaves down |
| let semitone = i - numberOfNotes / 2; |
| |
| // Convert from semitone to rate. |
| let playbackRate = Math.pow(2, semitone / 12); |
| |
| playNote(buffer, time, noteDuration, playbackRate); |
| } |
| |
| context.startRendering() |
| .then(renderedAudio => { |
| // Compute a threshold based on the maximum error, |maxUlp|, |
| // in ULP. This is experimentally determined. Assuming that |
| // the reference file is a 16-bit wav file, the max values in |
| // the wave file are +/- 32768. |
| let maxUlp = 0; |
| let threshold = maxUlp / 32768; |
| |
| for (let k = 0; k < renderedAudio.numberOfChannels; ++k) { |
| should( |
| renderedAudio.getChannelData(k), |
| 'Rendered audio for channel ' + k) |
| .beCloseToArray( |
| expectedAudio.getChannelData(k), |
| {absoluteThreshold: threshold}); |
| } |
| |
| const filename = 'audiobuffersource-loop-points-actual.wav'; |
| if (downloadAudioBuffer(renderedAudio, filename, true)) { |
| should(true, 'Saved reference file').message(filename, ''); |
| } |
| }) |
| .then(() => task.done()); |
| }); |
| |
| audit.run(); |
| </script> |
| </body> |
| </html> |
