forked from mirrors/gecko-dev
5d6b51256b
Backed out changeset 61356e1447e3 (bug 1823953) Backed out changeset 85785505b6d6 (bug 1823953) Backed out changeset 46a61cbfe8a8 (bug 1833654) Backed out changeset 83e3de80337b (bug 1833654) Backed out changeset 1a10c12874ac (bug 1840399) Backed out changeset 6b087145b67f (bug 1833654) Backed out changeset b9ac857ad43f (bug 1840399) Backed out changeset 4b841e8dd033 (bug 1823953) Backed out changeset 650e35803834 (bug 1823953) Backed out changeset c11b58ac0709 (bug 1823953) Backed out changeset c0249c90bc31 (bug 1823953) Backed out changeset 8929288d5aec (bug 1823953) Backed out changeset 828792b886bd (bug 1823953) Backed out changeset 873f1d4a8875 (bug 1840869) Backed out changeset a25abd05302c (bug 1823953) Backed out changeset d4b1eb442c36 (bug 1840399) Backed out changeset c25509d72a96 (bug 1840399) Backed out changeset 0f72a0626a28 (bug 1840402) Backed out changeset 82e7574364ce (bug 1840399) Backed out changeset 93073105f063 (bug 1840399) Backed out changeset 56ec8e3405e9 (bug 1840399) Backed out changeset ff15dad37ab8 (bug 1840399) Backed out changeset 0655ebd61eda (bug 1840399) Backed out changeset 7bca1ae06c7d (bug 1828912) Backed out changeset 8a5a849cfe5f (bug 1828912) Backed out changeset 3d8422a2038a (bug 1828912) Backed out changeset f08ee5de9370 (bug 1823953) Backed out changeset a4eb210620ff (bug 1823953) Backed out changeset aa8914cd55be (bug 1839391) Backed out changeset 3ea1f43e4024 (bug 1823953) Backed out changeset 3efe02ffa1c8 (bug 1826382) Backed out changeset 81c4553ec23d (bug 1839391) Backed out changeset 130894e4a781 (bug 1839391) Backed out changeset 9a0247b0fc85 (bug 1839391) Backed out changeset 11a923064382 (bug 1839391) Backed out changeset 98ffb66160c3 (bug 1837160) Backed out changeset a80dda9a220a (bug 1837160) Backed out changeset 251b4ef97a2b (bug 1837160) Backed out changeset 7372632eb32f (bug 1837160) Backed out changeset c5d54bc3ee26 (bug 1839389) Backed out changeset b232ec1bbc2d (bug 1833654) Backed out changeset fc7ba125c2fe (bug 1833654) Backed out changeset 8a47f6882e61 (bug 1823953) Backed out changeset e29810541b53 (bug 1828912) Backed out changeset bcf10730c8c9 (bug 1828912) Backed out changeset 8df8290b6c33 (bug 1826382) Backed out changeset 2811d12803cf (bug 1826382) Backed out changeset 3fc718561ec9 (bug 1826382) Backed out changeset 7827183776e1 (bug 1823953) Backed out changeset a3eb5f228d9a (bug 1826382) Backed out changeset 3113ad2e0987 (bug 1823953) Backed out changeset 4b1dc01525af (bug 1823953) Backed out changeset f7f4a7585ceb (bug 1823953) Backed out changeset 93042f1becec (bug 1823953) Backed out changeset b9ca30a0a066 (bug 1823953) Backed out changeset 1000c4a6a92a (bug 1823953) Backed out changeset 05dc13775fd6 (bug 1823953)
388 lines
12 KiB
HTML
388 lines
12 KiB
HTML
<!DOCTYPE HTML>
|
|
<html>
|
|
<head>
|
|
<title>Test the decodeAudioData API and Resampling</title>
|
|
<script src="/tests/SimpleTest/SimpleTest.js"></script>
|
|
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
|
|
</head>
|
|
<body>
|
|
<pre id="test">
|
|
<script src="webaudio.js" type="text/javascript"></script>
|
|
<script type="text/javascript">
|
|
|
|
// These routines have been copied verbatim from WebKit, and are used in order
|
|
// to convert a memory buffer into a wave buffer.
|
|
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;
|
|
}
|
|
|
|
</script>
|
|
<script class="testbody" type="text/javascript">
|
|
|
|
SimpleTest.waitForExplicitFinish();
|
|
|
|
// fuzzTolerance and fuzzToleranceMobile are used to determine fuzziness
|
|
// thresholds. They're needed to make sure that we can deal with neglibible
|
|
// differences in the binary buffer caused as a result of resampling the
|
|
// audio. fuzzToleranceMobile is typically larger on mobile platforms since
|
|
// we do fixed-point resampling as opposed to floating-point resampling on
|
|
// those platforms.
|
|
var files = [
|
|
// An ogg file, 44.1khz, mono
|
|
{
|
|
url: "ting-44.1k-1ch.ogg",
|
|
valid: true,
|
|
expectedUrl: "ting-44.1k-1ch.wav",
|
|
numberOfChannels: 1,
|
|
frames: 30592,
|
|
sampleRate: 44100,
|
|
duration: 0.693,
|
|
fuzzTolerance: 5,
|
|
fuzzToleranceMobile: 1284
|
|
},
|
|
// An ogg file, 44.1khz, stereo
|
|
{
|
|
url: "ting-44.1k-2ch.ogg",
|
|
valid: true,
|
|
expectedUrl: "ting-44.1k-2ch.wav",
|
|
numberOfChannels: 2,
|
|
frames: 30592,
|
|
sampleRate: 44100,
|
|
duration: 0.693,
|
|
fuzzTolerance: 6,
|
|
fuzzToleranceMobile: 2544
|
|
},
|
|
// An ogg file, 48khz, mono
|
|
{
|
|
url: "ting-48k-1ch.ogg",
|
|
valid: true,
|
|
expectedUrl: "ting-48k-1ch.wav",
|
|
numberOfChannels: 1,
|
|
frames: 33297,
|
|
sampleRate: 48000,
|
|
duration: 0.693,
|
|
fuzzTolerance: 5,
|
|
fuzzToleranceMobile: 1388
|
|
},
|
|
// An ogg file, 48khz, stereo
|
|
{
|
|
url: "ting-48k-2ch.ogg",
|
|
valid: true,
|
|
expectedUrl: "ting-48k-2ch.wav",
|
|
numberOfChannels: 2,
|
|
frames: 33297,
|
|
sampleRate: 48000,
|
|
duration: 0.693,
|
|
fuzzTolerance: 14,
|
|
fuzzToleranceMobile: 2752
|
|
},
|
|
// Make sure decoding a wave file results in the same buffer (for both the
|
|
// resampling and non-resampling cases)
|
|
{
|
|
url: "ting-44.1k-1ch.wav",
|
|
valid: true,
|
|
expectedUrl: "ting-44.1k-1ch.wav",
|
|
numberOfChannels: 1,
|
|
frames: 30592,
|
|
sampleRate: 44100,
|
|
duration: 0.693,
|
|
fuzzTolerance: 0,
|
|
fuzzToleranceMobile: 0
|
|
},
|
|
{
|
|
url: "ting-48k-1ch.wav",
|
|
valid: true,
|
|
expectedUrl: "ting-48k-1ch.wav",
|
|
numberOfChannels: 1,
|
|
frames: 33297,
|
|
sampleRate: 48000,
|
|
duration: 0.693,
|
|
fuzzTolerance: 0,
|
|
fuzzToleranceMobile: 0
|
|
},
|
|
// // A wave file
|
|
// //{ url: "24bit-44khz.wav", valid: true, expectedUrl: "24bit-44khz-expected.wav" },
|
|
// A non-audio file
|
|
{ url: "invalid.txt", valid: false, sampleRate: 44100 },
|
|
// A webm file with no audio
|
|
{ url: "noaudio.webm", valid: false, sampleRate: 48000 },
|
|
// A video ogg file with audio
|
|
{
|
|
url: "audio.ogv",
|
|
valid: true,
|
|
expectedUrl: "audio-expected.wav",
|
|
numberOfChannels: 2,
|
|
sampleRate: 44100,
|
|
frames: 47680,
|
|
duration: 1.0807,
|
|
fuzzTolerance: 106,
|
|
fuzzToleranceMobile: 3482
|
|
},
|
|
{
|
|
url: "nil-packet.ogg",
|
|
expectedUrl: null,
|
|
valid: true,
|
|
numberOfChannels: 2,
|
|
sampleRate: 48000,
|
|
frames: 18600,
|
|
duration: 0.3874,
|
|
}
|
|
];
|
|
|
|
// Returns true if the memory buffers are less different that |fuzz| bytes
|
|
function fuzzyMemcmp(buf1, buf2, fuzz) {
|
|
var result = true;
|
|
var difference = 0;
|
|
is(buf1.length, buf2.length, "same length");
|
|
for (var i = 0; i < buf1.length; ++i) {
|
|
if (Math.abs(buf1[i] - buf2[i])) {
|
|
++difference;
|
|
}
|
|
}
|
|
if (difference > fuzz) {
|
|
ok(false, "Expected at most " + fuzz + " bytes difference, found " + difference + " bytes");
|
|
}
|
|
return difference <= fuzz;
|
|
}
|
|
|
|
function getFuzzTolerance(test) {
|
|
var kIsMobile =
|
|
navigator.userAgent.includes("Mobile") || // b2g
|
|
navigator.userAgent.includes("Android"); // android
|
|
return kIsMobile ? test.fuzzToleranceMobile : test.fuzzTolerance;
|
|
}
|
|
|
|
function bufferIsSilent(buffer) {
|
|
for (var i = 0; i < buffer.length; ++i) {
|
|
if (buffer.getChannelData(0)[i] != 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function checkAudioBuffer(buffer, test) {
|
|
if (buffer.numberOfChannels != test.numberOfChannels) {
|
|
is(buffer.numberOfChannels, test.numberOfChannels, "Correct number of channels");
|
|
return;
|
|
}
|
|
ok(Math.abs(buffer.duration - test.duration) < 1e-3, "Correct duration");
|
|
if (Math.abs(buffer.duration - test.duration) >= 1e-3) {
|
|
ok(false, "got: " + buffer.duration + ", expected: " + test.duration);
|
|
}
|
|
is(buffer.sampleRate, test.sampleRate, "Correct sample rate");
|
|
is(buffer.length, test.frames, "Correct length");
|
|
|
|
var wave = createWaveFileData(buffer);
|
|
if (test.expectedWaveData) {
|
|
ok(fuzzyMemcmp(wave, test.expectedWaveData, getFuzzTolerance(test)), "Received expected decoded data");
|
|
}
|
|
}
|
|
|
|
function checkResampledBuffer(buffer, test, callback) {
|
|
if (buffer.numberOfChannels != test.numberOfChannels) {
|
|
is(buffer.numberOfChannels, test.numberOfChannels, "Correct number of channels");
|
|
return;
|
|
}
|
|
ok(Math.abs(buffer.duration - test.duration) < 1e-3, "Correct duration");
|
|
if (Math.abs(buffer.duration - test.duration) >= 1e-3) {
|
|
ok(false, "got: " + buffer.duration + ", expected: " + test.duration);
|
|
}
|
|
// Take into account the resampling when checking the size
|
|
var expectedLength = test.frames * buffer.sampleRate / test.sampleRate;
|
|
SimpleTest.ok(
|
|
Math.abs(buffer.length - expectedLength) < 1.0,
|
|
"Correct length - got " + buffer.length +
|
|
", expected about " + expectedLength
|
|
);
|
|
|
|
// Playback the buffer in the original context, to resample back to the
|
|
// original rate and compare with the decoded buffer without resampling.
|
|
cx = test.nativeContext;
|
|
var expected = cx.createBufferSource();
|
|
expected.buffer = test.expectedBuffer;
|
|
expected.start();
|
|
var inverse = cx.createGain();
|
|
inverse.gain.value = -1;
|
|
expected.connect(inverse);
|
|
inverse.connect(cx.destination);
|
|
var resampled = cx.createBufferSource();
|
|
resampled.buffer = buffer;
|
|
resampled.start();
|
|
// This stop should do nothing, but it tests for bug 937475
|
|
resampled.stop(test.frames / cx.sampleRate);
|
|
resampled.connect(cx.destination);
|
|
cx.oncomplete = function(e) {
|
|
ok(!bufferIsSilent(e.renderedBuffer), "Expect buffer not silent");
|
|
// Resampling will lose the highest frequency components, so we should
|
|
// pass the difference through a low pass filter. However, either the
|
|
// input files don't have significant high frequency components or the
|
|
// tolerance in compareBuffers() is too high to detect them.
|
|
compareBuffers(e.renderedBuffer,
|
|
cx.createBuffer(test.numberOfChannels,
|
|
test.frames, test.sampleRate));
|
|
callback();
|
|
}
|
|
cx.startRendering();
|
|
}
|
|
|
|
function runResampling(test, response, callback) {
|
|
var sampleRate = test.sampleRate == 44100 ? 48000 : 44100;
|
|
var cx = new OfflineAudioContext(1, 1, sampleRate);
|
|
cx.decodeAudioData(response, function onSuccess(asyncResult) {
|
|
is(asyncResult.sampleRate, sampleRate, "Correct sample rate");
|
|
|
|
checkResampledBuffer(asyncResult, test, callback);
|
|
}, function onFailure() {
|
|
ok(false, "Expected successful decode with resample");
|
|
callback();
|
|
});
|
|
}
|
|
|
|
function runTest(test, response, callback) {
|
|
// We need to copy the array here, because decodeAudioData will detach the
|
|
// array's buffer.
|
|
var compressedAudio = response.slice(0);
|
|
var expectCallback = false;
|
|
var cx = new OfflineAudioContext(test.numberOfChannels || 1,
|
|
test.frames || 1, test.sampleRate);
|
|
cx.decodeAudioData(response, function onSuccess(asyncResult) {
|
|
ok(expectCallback, "Success callback should fire asynchronously");
|
|
ok(test.valid, "Did expect success for test " + test.url);
|
|
|
|
checkAudioBuffer(asyncResult, test);
|
|
|
|
test.expectedBuffer = asyncResult;
|
|
test.nativeContext = cx;
|
|
runResampling(test, compressedAudio, callback);
|
|
}, function onFailure(e) {
|
|
ok(e instanceof DOMException, "We want to see an exception here");
|
|
is(e.name, "EncodingError", "Exception name matches");
|
|
ok(expectCallback, "Failure callback should fire asynchronously");
|
|
ok(!test.valid, "Did expect failure for test " + test.url);
|
|
callback();
|
|
});
|
|
expectCallback = true;
|
|
}
|
|
|
|
function loadTest(test, callback) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", test.url, true);
|
|
xhr.responseType = "arraybuffer";
|
|
xhr.onload = function() {
|
|
if (!test.expectedUrl) {
|
|
runTest(test, xhr.response, callback);
|
|
return;
|
|
}
|
|
var getExpected = new XMLHttpRequest();
|
|
getExpected.open("GET", test.expectedUrl, true);
|
|
getExpected.responseType = "arraybuffer";
|
|
getExpected.onload = function() {
|
|
test.expectedWaveData = new Uint8Array(getExpected.response);
|
|
runTest(test, xhr.response, callback);
|
|
};
|
|
getExpected.send();
|
|
};
|
|
xhr.send();
|
|
}
|
|
|
|
function loadNextTest() {
|
|
if (files.length) {
|
|
loadTest(files.shift(), loadNextTest);
|
|
} else {
|
|
SimpleTest.finish();
|
|
}
|
|
}
|
|
|
|
loadNextTest();
|
|
|
|
</script>
|
|
</pre>
|
|
</body>
|
|
</html>
|