(function(global) {
// Information about the starting/ending times and starting/ending values for
// each time interval.
let timeValueInfo;
// The difference between starting values between each time interval.
let startingValueDelta;
// For any automation function that has an end or target value, the end value
// is based the starting value of the time interval. The starting value will
// be increased or decreased by |startEndValueChange|. We choose half of
// |startingValueDelta| so that the ending value will be distinct from the
// starting value for next time interval. This allows us to detect where the
// ramp begins and ends.
let startEndValueChange;
// Default threshold to use for detecting discontinuities that should appear
// at each time interval.
let discontinuityThreshold;
// Time interval between value changes. It is best if 1 / numberOfTests is
// not close to timeInterval.
let timeIntervalInternal = .03;
let context;
// Make sure we render long enough to capture all of our test data.
function renderLength(numberOfTests) {
return timeToSampleFrame((numberOfTests + 1) * timeInterval, sampleRate);
}
// Create a constant reference signal with the given |value|. Basically the
// same as |createConstantBuffer|, but with the parameters to match the other
// create functions. The |endValue| is ignored.
function createConstantArray(
startTime, endTime, value, endValue, sampleRate) {
let startFrame = timeToSampleFrame(startTime, sampleRate);
let endFrame = timeToSampleFrame(endTime, sampleRate);
let length = endFrame - startFrame;
let buffer = createConstantBuffer(context, length, value);
return buffer.getChannelData(0);
}
function getStartEndFrames(startTime, endTime, sampleRate) {
// Start frame is the ceiling of the start time because the ramp starts at
// or after the sample frame. End frame is the ceiling because it's the
// exclusive ending frame of the automation.
let startFrame = Math.ceil(startTime * sampleRate);
let endFrame = Math.ceil(endTime * sampleRate);
return {startFrame: startFrame, endFrame: endFrame};
}
// Create a linear ramp starting at |startValue| and ending at |endValue|. The
// ramp starts at time |startTime| and ends at |endTime|. (The start and end
// times are only used to compute how many samples to return.)
function createLinearRampArray(
startTime, endTime, startValue, endValue, sampleRate) {
let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
let startFrame = frameInfo.startFrame;
let endFrame = frameInfo.endFrame;
let length = endFrame - startFrame;
let array = new Array(length);
let step = Math.fround(
(endValue - startValue) / (endTime - startTime) / sampleRate);
let start = Math.fround(
startValue +
(endValue - startValue) * (startFrame / sampleRate - startTime) /
(endTime - startTime));
let slope = (endValue - startValue) / (endTime - startTime);
// v(t) = v0 + (v1 - v0)*(t-t0)/(t1-t0)
for (k = 0; k < length; ++k) {
// array[k] = Math.fround(start + k * step);
let t = (startFrame + k) / sampleRate;
array[k] = startValue + slope * (t - startTime);
}
return array;
}
// Create an exponential ramp starting at |startValue| and ending at
// |endValue|. The ramp starts at time |startTime| and ends at |endTime|.
// (The start and end times are only used to compute how many samples to
// return.)
function createExponentialRampArray(
startTime, endTime, startValue, endValue, sampleRate) {
let deltaTime = endTime - startTime;
let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
let startFrame = frameInfo.startFrame;
let endFrame = frameInfo.endFrame;
let length = endFrame - startFrame;
let array = new Array(length);
let ratio = endValue / startValue;
// v(t) = v0*(v1/v0)^((t-t0)/(t1-t0))
for (let k = 0; k < length; ++k) {
let t = Math.fround((startFrame + k) / sampleRate);
array[k] = Math.fround(
startValue * Math.pow(ratio, (t - startTime) / deltaTime));
}
return array;
}
function discreteTimeConstantForSampleRate(timeConstant, sampleRate) {
return 1 - Math.exp(-1 / (sampleRate * timeConstant));
}
// Create a signal that starts at |startValue| and exponentially approaches
// the target value of |targetValue|, using a time constant of |timeConstant|.
// The ramp starts at time |startTime| and ends at |endTime|. (The start and
// end times are only used to compute how many samples to return.)
function createExponentialApproachArray(
startTime, endTime, startValue, targetValue, sampleRate, timeConstant) {
let startFrameFloat = startTime * sampleRate;
let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
let startFrame = frameInfo.startFrame;
let endFrame = frameInfo.endFrame;
let length = Math.floor(endFrame - startFrame);
let array = new Array(length);
let c = discreteTimeConstantForSampleRate(timeConstant, sampleRate);
let delta = startValue - targetValue;
// v(t) = v1 + (v0 - v1) * exp(-(t-t0)/tau)
for (let k = 0; k < length; ++k) {
let t = (startFrame + k) / sampleRate;
let value =
targetValue + delta * Math.exp(-(t - startTime) / timeConstant);
array[k] = value;
}
return array;
}
// Create a sine wave of the specified duration.
function createReferenceSineArray(
startTime, endTime, startValue, endValue, sampleRate) {
// Ignore |startValue| and |endValue| for the sine wave.
let curve = createSineWaveArray(
endTime - startTime, freqHz, sineAmplitude, sampleRate);
// Sample the curve appropriately.
let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
let startFrame = frameInfo.startFrame;
let endFrame = frameInfo.endFrame;
let length = Math.floor(endFrame - startFrame);
let array = new Array(length);
// v(t) = linearly interpolate between V[k] and V[k + 1] where k =
// floor((N-1)/duration*(t - t0))
let f = (length - 1) / (endTime - startTime);
for (let k = 0; k < length; ++k) {
let t = (startFrame + k) / sampleRate;
let indexFloat = f * (t - startTime);
let index = Math.floor(indexFloat);
if (index + 1 < length) {
let v0 = curve[index];
let v1 = curve[index + 1];
array[k] = v0 + (v1 - v0) * (indexFloat - index);
} else {
array[k] = curve[length - 1];
}
}
return array;
}
// Create a sine wave of the given frequency and amplitude. The sine wave is
// offset by half the amplitude so that result is always positive.
function createSineWaveArray(durationSeconds, freqHz, amplitude, sampleRate) {
let length = timeToSampleFrame(durationSeconds, sampleRate);
let signal = new Float32Array(length);
let omega = 2 * Math.PI * freqHz / sampleRate;
let halfAmplitude = amplitude / 2;
for (let k = 0; k < length; ++k) {
signal[k] = halfAmplitude + halfAmplitude * Math.sin(omega * k);
}
return signal;
}
// Return the difference between the starting value and the ending value for
// time interval |timeIntervalIndex|. We alternate between an end value that
// is above or below the starting value.
function endValueDelta(timeIntervalIndex) {
if (timeIntervalIndex & 1) {
return -startEndValueChange;
} else {
return startEndValueChange;
}
}
// Relative error metric
function relativeErrorMetric(actual, expected) {
return (actual - expected) / Math.abs(expected);
}
// Difference metric
function differenceErrorMetric(actual, expected) {
return actual - expected;
}
// Return the difference between the starting value at |timeIntervalIndex| and
// the starting value at the next time interval. Since we started at a large
// initial value, we decrease the value at each time interval.
function valueUpdate(timeIntervalIndex) {
return -startingValueDelta;
}
// Compare a section of the rendered data against our expected signal.
function comparePartialSignals(
should, rendered, expectedFunction, startTime, endTime, valueInfo,
sampleRate, errorMetric) {
let startSample = timeToSampleFrame(startTime, sampleRate);
let expected = expectedFunction(
startTime, endTime, valueInfo.startValue, valueInfo.endValue,
sampleRate, timeConstant);
let n = expected.length;
let maxError = -1;
let maxErrorIndex = -1;
for (let k = 0; k < n; ++k) {
// Make sure we don't pass these tests because a NaN has been generated in
// either the
// rendered data or the reference data.
if (!isValidNumber(rendered[startSample + k])) {
maxError = Infinity;
maxErrorIndex = startSample + k;
should(
isValidNumber(rendered[startSample + k]),
'NaN or infinity for rendered data at ' + maxErrorIndex)
.beTrue();
break;
}
if (!isValidNumber(expected[k])) {
maxError = Infinity;
maxErrorIndex = startSample + k;
should(
isValidNumber(expected[k]),
'NaN or infinity for rendered data at ' + maxErrorIndex)
.beTrue();
break;
}
let error = Math.abs(errorMetric(rendered[startSample + k], expected[k]));
if (error > maxError) {
maxError = error;
maxErrorIndex = k;
}
}
return {maxError: maxError, index: maxErrorIndex, expected: expected};
}
// Find the discontinuities in the data and compare the locations of the
// discontinuities with the times that define the time intervals. There is a
// discontinuity if the difference between successive samples exceeds the
// threshold.
function verifyDiscontinuities(should, values, times, threshold) {
let n = values.length;
let success = true;
let badLocations = 0;
let breaks = [];
// Find discontinuities.
for (let k = 1; k < n; ++k) {
if (Math.abs(values[k] - values[k - 1]) > threshold) {
breaks.push(k);
}
}
let testCount;
// If there are numberOfTests intervals, there are only numberOfTests - 1
// internal interval boundaries. Hence the maximum number of discontinuties
// we expect to find is numberOfTests - 1. If we find more than that, we
// have no reference to compare against. We also assume that the actual
// discontinuities are close to the expected ones.
//
// This is just a sanity check when something goes really wrong. For
// example, if the threshold is too low, every sample frame looks like a
// discontinuity.
if (breaks.length >= numberOfTests) {
testCount = numberOfTests - 1;
should(breaks.length, 'Number of discontinuities')
.beLessThan(numberOfTests);
success = false;
} else {
testCount = breaks.length;
}
// Compare the location of each discontinuity with the end time of each
// interval. (There is no discontinuity at the start of the signal.)
for (let k = 0; k < testCount; ++k) {
let expectedSampleFrame = timeToSampleFrame(times[k + 1], sampleRate);
if (breaks[k] != expectedSampleFrame) {
success = false;
++badLocations;
should(breaks[k], 'Discontinuity at index')
.beEqualTo(expectedSampleFrame);
}
}
if (badLocations) {
should(badLocations, 'Number of discontinuites at incorrect locations')
.beEqualTo(0);
success = false;
} else {
should(
breaks.length + 1,
'Number of tests started and ended at the correct time')
.beEqualTo(numberOfTests);
}
return success;
}
// Compare the rendered data with the expected data.
//
// testName - string describing the test
//
// maxError - maximum allowed difference between the rendered data and the
// expected data
//
// rendererdData - array containing the rendered (actual) data
//
// expectedFunction - function to compute the expected data
//
// timeValueInfo - array containing information about the start and end times
// and the start and end values of each interval.
//
// breakThreshold - threshold to use for determining discontinuities.
function compareSignals(
should, testName, maxError, renderedData, expectedFunction, timeValueInfo,
breakThreshold, errorMetric) {
let success = true;
let failedTestCount = 0;
let times = timeValueInfo.times;
let values = timeValueInfo.values;
let n = values.length;
let expectedSignal = [];
success =
verifyDiscontinuities(should, renderedData, times, breakThreshold);
for (let k = 0; k < n; ++k) {
let result = comparePartialSignals(
should, renderedData, expectedFunction, times[k], times[k + 1],
values[k], sampleRate, errorMetric);
expectedSignal =
expectedSignal.concat(Array.prototype.slice.call(result.expected));
should(
result.maxError,
'Max error for test ' + k + ' at offset ' +
(result.index + timeToSampleFrame(times[k], sampleRate)))
.beLessThanOrEqualTo(maxError);
}
should(
failedTestCount,
'Number of failed tests with an acceptable relative tolerance of ' +
maxError)
.beEqualTo(0);
}
// Create a function to test the rendered data with the reference data.
//
// testName - string describing the test
//
// error - max allowed error between rendered data and the reference data.
//
// referenceFunction - function that generates the reference data to be
// compared with the rendered data.
//
// jumpThreshold - optional parameter that specifies the threshold to use for
// detecting discontinuities. If not specified, defaults to
// discontinuityThreshold.
//
function checkResultFunction(
task, should, testName, error, referenceFunction, jumpThreshold,
errorMetric) {
return function(event) {
let buffer = event.renderedBuffer;
renderedData = buffer.getChannelData(0);
let threshold;
if (!jumpThreshold) {
threshold = discontinuityThreshold;
} else {
threshold = jumpThreshold;
}
compareSignals(
should, testName, error, renderedData, referenceFunction,
timeValueInfo, threshold, errorMetric);
task.done();
}
}
// Run all the automation tests.
//
// numberOfTests - number of tests (time intervals) to run.
//
// initialValue - The initial value of the first time interval.
//
// setValueFunction - function that sets the specified value at the start of a
// time interval.
//
// automationFunction - function that sets the end value for the time
// interval. It specifies how the value approaches the end value.
//
// An object is returned containing an array of start times for each time
// interval, and an array giving the start and end values for the interval.
function doAutomation(
numberOfTests, initialValue, setValueFunction, automationFunction) {
let timeInfo = [0];
let valueInfo = [];
let value = initialValue;
for (let k = 0; k < numberOfTests; ++k) {
let startTime = k * timeInterval;
let endTime = (k + 1) * timeInterval;
let endValue = value + endValueDelta(k);
// Set the value at the start of the time interval.
setValueFunction(value, startTime);
// Specify the end or target value, and how we should approach it.
automationFunction(endValue, startTime, endTime);
// Keep track of the start times, and the start and end values for each
// time interval.
timeInfo.push(endTime);
valueInfo.push({startValue: value, endValue: endValue});
value += valueUpdate(k);
}
return {times: timeInfo, values: valueInfo};
}
// Create the audio graph for the test and then run the test.
//
// numberOfTests - number of time intervals (tests) to run.
//
// initialValue - the initial value of the gain at time 0.
//
// setValueFunction - function to set the value at the beginning of each time
// interval.
//
// automationFunction - the AudioParamTimeline automation function
//
// testName - string indicating the test that is being run.
//
// maxError - maximum allowed error between the rendered data and the
// reference data
//
// referenceFunction - function that generates the reference data to be
// compared against the rendered data.
//
// jumpThreshold - optional parameter that specifies the threshold to use for
// detecting discontinuities. If not specified, defaults to
// discontinuityThreshold.
//
function createAudioGraphAndTest(
task, should, numberOfTests, initialValue, setValueFunction,
automationFunction, testName, maxError, referenceFunction, jumpThreshold,
errorMetric) {
// Create offline audio context.
context =
new OfflineAudioContext(2, renderLength(numberOfTests), sampleRate);
let constantBuffer =
createConstantBuffer(context, renderLength(numberOfTests), 1);
// We use an AudioGainNode here simply as a convenient way to test the
// AudioParam automation, since it's easy to pass a constant value through
// the node, automate the .gain attribute and observe the resulting values.
gainNode = context.createGain();
let bufferSource = context.createBufferSource();
bufferSource.buffer = constantBuffer;
bufferSource.connect(gainNode);
gainNode.connect(context.destination);
// Set up default values for the parameters that control how the automation
// test values progress for each time interval.
startingValueDelta = initialValue / numberOfTests;
startEndValueChange = startingValueDelta / 2;
discontinuityThreshold = startEndValueChange / 2;
// Run the automation tests.
timeValueInfo = doAutomation(
numberOfTests, initialValue, setValueFunction, automationFunction);
bufferSource.start(0);
context.oncomplete = checkResultFunction(
task, should, testName, maxError, referenceFunction, jumpThreshold,
errorMetric || relativeErrorMetric);
context.startRendering();
}
// Export local references to global scope. All the new objects in this file
// must be exported through this if it is to be used in the actual test HTML
// page.
let exports = {
'sampleRate': 44100,
'gainNode': null,
'timeInterval': timeIntervalInternal,
// Some suitable time constant so that we can see a significant change over
// a timeInterval. This is only needed by setTargetAtTime() which needs a
// time constant.
'timeConstant': timeIntervalInternal / 3,
'renderLength': renderLength,
'createConstantArray': createConstantArray,
'getStartEndFrames': getStartEndFrames,
'createLinearRampArray': createLinearRampArray,
'createExponentialRampArray': createExponentialRampArray,
'discreteTimeConstantForSampleRate': discreteTimeConstantForSampleRate,
'createExponentialApproachArray': createExponentialApproachArray,
'createReferenceSineArray': createReferenceSineArray,
'createSineWaveArray': createSineWaveArray,
'endValueDelta': endValueDelta,
'relativeErrorMetric': relativeErrorMetric,
'differenceErrorMetric': differenceErrorMetric,
'valueUpdate': valueUpdate,
'comparePartialSignals': comparePartialSignals,
'verifyDiscontinuities': verifyDiscontinuities,
'compareSignals': compareSignals,
'checkResultFunction': checkResultFunction,
'doAutomation': doAutomation,
'createAudioGraphAndTest': createAudioGraphAndTest
};
for (let reference in exports) {
global[reference] = exports[reference];
}
})(window);
Codebase Browser
chromium