Allow saving reference file as a float32 WAV file

third_party/WebKit/LayoutTests/webaudio/resources/oscillator-testing.js

 // Notes about generated waveforms:
 //
 // QUESTION: Why does the wave shape not look like the exact shape (sharp edges)?
 // ANSWER: Because a shape with sharp edges has infinitely high frequency content.
 // Since a digital audio signal must be band-limited based on the nyquist frequency (half the sample-rate)
 // in order to avoid aliasing, this creates more rounded edges and "ringing" in the
 // appearance of the waveform.  See Nyquist-Shannon sampling theorem:
 // http://en.wikipedia.org/wiki/Nyquist%E2%80%93Shannon_sampling_theorem
 //
 // QUESTION: Why does the very end of the generated signal appear to get slightly weaker?
@@ skipping 67 matching lines @@
     gainNode.connect(context.destination);
 
     osc.start(0);
 
     osc.frequency.setValueAtTime(10, 0);
     osc.frequency.exponentialRampToValueAtTime(highFrequency, lengthInSeconds);
 }
 
 function calculateSNR(sPower, nPower)
 {
-    if (nPower == 0 && sPower > 0) {
-        return 1000;
-    }
     return 10 * Math.log10(sPower / nPower);
 }
 
 function loadReferenceAndRunTest(context, oscType, task, should) {
-     var bufferLoader = new BufferLoader(
-        context,
-        [ "../Oscillator/oscillator-" + oscType + "-expected.wav" ],
-        function (bufferList) {
-            reference = bufferList[0].getChannelData(0);
+    Audit
+        .loadFileFromUrl(
+            '../Oscillator/oscillator-' + oscType + '-expected.wav')
+        .then(response => {
+            return context.decodeAudioData(response);
+        })
+        .then(audioBuffer => {
+            reference = audioBuffer.getChannelData(0);
             generateExponentialOscillatorSweep(context, oscType);
-            context.oncomplete = () => {
-              checkResult(event, should, oscType);
-              task.done();
-            };
-            context.startRendering();
-        });
-
-    bufferLoader.load();
+            return context.startRendering();
+        })
+        .then(resultBuffer => {
+            checkResult(resultBuffer, should, oscType);
+        })
+        .then(() => task.done());
 }
 
-function checkResult (event, should, oscType) {
-    let renderedData = event.renderedBuffer.getChannelData(0);
+function checkResult (renderedBuffer, should, oscType) {
+    let renderedData = renderedBuffer.getChannelData(0);
     // Compute signal to noise ratio between the result and the reference. Also keep track
     // of the max difference (and position).
 
     var maxError = -1;
     var errorPosition = -1;
     var diffCount = 0;
 
     for (var k = 0; k < renderedData.length; ++k) {
         var diff = renderedData[k] - reference[k];
         noisePower += diff * diff;
         signalPower += reference[k] * reference[k];
         if (Math.abs(diff) > maxError) {
             maxError = Math.abs(diff);
             errorPosition = k;
         }
         // The reference file is a 16-bit WAV file, so we will almost never get an exact match
         // between it and the actual floating-point result.
-        if (diff > 1/waveScaleFactor) {
+        if (diff > 0) {
             diffCount++;
         }
     }
 
     var snr = calculateSNR(signalPower, noisePower);
     should(snr, "SNR")
         .beGreaterThanOrEqualTo(thresholdSNR);
-    should(maxError * waveScaleFactor, "Maximum difference in ulp (16-bits)")
-        .beLessThanOrEqualTo(thresholdDiff * waveScaleFactor);
+    should(maxError, "Maximum difference")
+        .beLessThanOrEqualTo(thresholdDiff);
 
     should(diffCount,
            "Number of differences between actual and expected result out of "
            + renderedData.length + " frames")
         .beLessThanOrEqualTo(thresholdDiffCount);
 
     var filename = "oscillator-" + oscType + "-actual.wav";
-    if (downloadAudioBuffer(event.renderedBuffer, filename))
+    if (downloadAudioBuffer(renderedBuffer, filename, true))
       should(true, "Saved reference file").message(filename, "");
 }
 
 function setThresholds(thresholds) {
     thresholdSNR = thresholds.snr;
-    thresholdDiff = thresholds.maxDiff / waveScaleFactor;
+    thresholdDiff = thresholds.maxDiff;
     thresholdDiffCount = thresholds.diffCount;
 }
 
 function runTest(context, oscType, description, task, should) {
   loadReferenceAndRunTest(context, oscType, task, should);
 }
 
-function createNewReference(oscType) {
-     if (!window.testRunner)
-         return;
-
-     context = new OfflineAudioContext(1, sampleRate * lengthInSeconds, sampleRate);
-     generateExponentialOscillatorSweep(context, oscType);
-
-     context.oncomplete = finishAudioTest;
-     context.startRendering();
-
-     testRunner.waitUntilDone();
-}
-
 return {
     sampleRate: sampleRate,
     lengthInSeconds: lengthInSeconds,
     thresholdSNR: thresholdSNR,
     thresholdDiff: thresholdDiff,
     thresholdDiffCount: thresholdDiffCount,
     waveScaleFactor: waveScaleFactor,
     setThresholds: setThresholds,
     runTest: runTest,
-    createNewReference: createNewReference,
 };
 
 }());