The Tor Browser: comparison content/media/webaudio/test/blink/audio-testing.js

comparison: content/media/webaudio/test/blink/audio-testing.js

content/media/webaudio/test/blink/audio-testing.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:07d2348a38f0
+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.");
+}
+}