audio-testing.js - mozsearch

Enable keyboard shortcuts

if (window.testRunner)

    testRunner.overridePreference("WebKitWebAudioEnabled", "1");

function writeString(s, a, offset) {

    for (var i = 0; i < s.length; ++i) {

        a[offset + i] = s.charCodeAt(i);

function writeInt16(n, a, offset) {

    n = Math.floor(n);

    var b1 = n & 255;

    var b2 = (n >> 8) & 255;

    a[offset + 0] = b1;

    a[offset + 1] = b2;

function writeInt32(n, a, offset) {

    n = Math.floor(n);

    var b1 = n & 255;

    var b2 = (n >> 8) & 255;

    var b3 = (n >> 16) & 255;

    var b4 = (n >> 24) & 255;

    a[offset + 0] = b1;

    a[offset + 1] = b2;

    a[offset + 2] = b3;

    a[offset + 3] = b4;

function writeAudioBuffer(audioBuffer, a, offset) {

    var n = audioBuffer.length;

    var channels = audioBuffer.numberOfChannels;

    for (var i = 0; i < n; ++i) {

        for (var k = 0; k < channels; ++k) {

            var buffer = audioBuffer.getChannelData(k);

            var sample = buffer[i] * 32768.0;

            // Clip samples to the limitations of 16-bit.

            // If we don't do this then we'll get nasty wrap-around distortion.

            if (sample < -32768)

                sample = -32768;

            if (sample > 32767)

                sample = 32767;

            writeInt16(sample, a, offset);

            offset += 2;

function createWaveFileData(audioBuffer) {

    var frameLength = audioBuffer.length;

    var numberOfChannels = audioBuffer.numberOfChannels;

    var sampleRate = audioBuffer.sampleRate;

    var bitsPerSample = 16;

    var byteRate = sampleRate * numberOfChannels * bitsPerSample/8;

    var blockAlign = numberOfChannels * bitsPerSample/8;

    var wavDataByteLength = frameLength * numberOfChannels * 2; // 16-bit audio

    var headerByteLength = 44;

    var totalLength = headerByteLength + wavDataByteLength;

    var waveFileData = new Uint8Array(totalLength);

    var subChunk1Size = 16; // for linear PCM

    var subChunk2Size = wavDataByteLength;

    var chunkSize = 4 + (8 + subChunk1Size) + (8 + subChunk2Size);

    writeString("RIFF", waveFileData, 0);

    writeInt32(chunkSize, waveFileData, 4);

    writeString("WAVE", waveFileData, 8);

    writeString("fmt ", waveFileData, 12);

    writeInt32(subChunk1Size, waveFileData, 16);      // SubChunk1Size (4)

    writeInt16(1, waveFileData, 20);                  // AudioFormat (2)

    writeInt16(numberOfChannels, waveFileData, 22);   // NumChannels (2)

    writeInt32(sampleRate, waveFileData, 24);         // SampleRate (4)

    writeInt32(byteRate, waveFileData, 28);           // ByteRate (4)

    writeInt16(blockAlign, waveFileData, 32);         // BlockAlign (2)

    writeInt32(bitsPerSample, waveFileData, 34);      // BitsPerSample (4)

    writeString("data", waveFileData, 36);

    writeInt32(subChunk2Size, waveFileData, 40);      // SubChunk2Size (4)

    // Write actual audio data starting at offset 44.

    writeAudioBuffer(audioBuffer, waveFileData, 44);

    return waveFileData;

function createAudioData(audioBuffer) {

    return createWaveFileData(audioBuffer);

function finishAudioTest(event) {

    var audioData = createAudioData(event.renderedBuffer);

    testRunner.setAudioData(audioData);

    testRunner.notifyDone();

// Create an impulse in a buffer of length sampleFrameLength

function createImpulseBuffer(context, sampleFrameLength) {

    var audioBuffer = context.createBuffer(1, sampleFrameLength, context.sampleRate);

    var n = audioBuffer.length;

    var dataL = audioBuffer.getChannelData(0);

    for (var k = 0; k < n; ++k) {

        dataL[k] = 0;

    dataL[0] = 1;

    return audioBuffer;

// Create a buffer of the given length with a linear ramp having values 0 <= x < 1.

function createLinearRampBuffer(context, sampleFrameLength) {

    var audioBuffer = context.createBuffer(1, sampleFrameLength, context.sampleRate);

    var n = audioBuffer.length;

    var dataL = audioBuffer.getChannelData(0);

    for (var i = 0; i < n; ++i)

        dataL[i] = i / n;

    return audioBuffer;

// Create a buffer of the given length having a constant value.

function createConstantBuffer(context, sampleFrameLength, constantValue) {

    var audioBuffer = context.createBuffer(1, sampleFrameLength, context.sampleRate);

    var n = audioBuffer.length;

    var dataL = audioBuffer.getChannelData(0);

    for (var i = 0; i < n; ++i)

        dataL[i] = constantValue;

    return audioBuffer;

// Create a stereo impulse in a buffer of length sampleFrameLength

function createStereoImpulseBuffer(context, sampleFrameLength) {

    var audioBuffer = context.createBuffer(2, sampleFrameLength, context.sampleRate);

    var n = audioBuffer.length;

    var dataL = audioBuffer.getChannelData(0);

    var dataR = audioBuffer.getChannelData(1);

    for (var k = 0; k < n; ++k) {

        dataL[k] = 0;

        dataR[k] = 0;

    dataL[0] = 1;

    dataR[0] = 1;

    return audioBuffer;

// Convert time (in seconds) to sample frames.

function timeToSampleFrame(time, sampleRate) {

    return Math.floor(0.5 + time * sampleRate);

// Compute the number of sample frames consumed by start with

// the specified |grainOffset|, |duration|, and |sampleRate|.

function grainLengthInSampleFrames(grainOffset, duration, sampleRate) {

    var startFrame = timeToSampleFrame(grainOffset, sampleRate);

    var endFrame = timeToSampleFrame(grainOffset + duration, sampleRate);

    return endFrame - startFrame;

// True if the number is not an infinity or NaN

function isValidNumber(x) {

    return !isNaN(x) && (x != Infinity) && (x != -Infinity);

function shouldThrowTypeError(func, text) {

    var ok = false;

    try {

        func();

    } catch (e) {

        if (e instanceof TypeError) {

            ok = true;

    if (ok) {

        testPassed(text + " threw TypeError.");

    } else {

        testFailed(text + " should throw TypeError.");