<!doctype html>
<html>
  <head>
    <script src="../resources/js-test.js"></script>
    <script src="resources/compatibility.js"></script>
    <script src="resources/audio-testing.js"></script>
    <script src="resources/realtimeanalyser-testing.js"></script>
    <script src="resources/fft.js"></script>
    <title>Test Analyser getFloatFrequencyData and getByteFrequencyData, No Smoothing</title>
  </head>

  <body>
    <script>
      description("Test AnalyserNode getFloatFrequencyData and getByteFrequencyData, no Smoothing");
      window.jsTestIsAsync = true;

      // Use a power of two to eliminate any round-off in the computation of the times for
      // context.suspend().
      var sampleRate = 32768;

      // The largest FFT size for the analyser node is 32768.  We want to render longer than this so
      // that we have at least one complete buffer of data of 32768 samples.
      var renderFrames = 2 * 32768;
      var renderDuration = renderFrames / sampleRate;

      var audit = Audit.createTaskRunner();

      // Options for basic tests of the AnalyserNode frequency domain data.  The thresholds are
      // experimentally determined.
      var testConfig = [{
        order: 5,
        // For this order, need to specify a higher minDecibels value for the analyser because the
        // FFT doesn't get that small. This allows us to test that (a changed) minDecibels has an
        // effect and that we properly clip the byte data.
        minDecibels: -50,
        floatRelError: 6.8964e-7,
      }, {
        order: 6,
        floatRelError: 6.8366e-6
      }, {
        order: 7,
        floatRelError: 1.4602e-6
      }, {
        order: 8,
        floatRelError: 8.4828e-7
      }, {
        order: 9,
        floatRelError: 1.6568e-5
      }, {
        order: 10,
        floatRelError: 1.2765e-5
      }, {
        order: 11,
        floatRelError: 8.4920e-6,
      }, {
        order: 12,
        floatRelError: 4.3344e-7
      }, {
        order: 13,
        floatRelError: 2.2798e-7
      }, {
        order: 14,
        floatRelError: 1.1756e-7
      }, {
        order: 15,
        floatRelError: 1.1675e-7
      }];

      // True if all of the basic tests passed.
      var basicTestsPassed = true;

      // Generate tests for each entry in testConfig.
      for (var k = 0; k < testConfig.length; ++k) {
        var name = testConfig[k].order + "-order FFT";
        (function (config) {
           audit.defineTask(name, function (done) {
             basicFFTTest(config).then(done);
           });
        })(testConfig[k]);
      }

      // Just print a summary of the result of the above tests.
      audit.defineTask("summarize basic tests", function (done) {
        if (basicTestsPassed)
          testPassed("Basic frequency data computed correctly.\n");
        else
          testFailed("Basic frequency data computed incorrectly.\n");
        done();
      });

      // Test that smoothing isn't done and we have the expected data, calling getFloatFrequencyData
      // twice at different times.
      audit.defineTask("no smoothing", function (done) {
        // Use 128-point FFT for the test.  The actual order doesn't matter (but the error threshold
        // depends on the order).
        var options = {
          order: 7,
          smoothing: 0,
          floatRelError: 1.2548e-6
        };
        var graph = createGraph(options);
        var context = graph.context;
        var analyser = graph.analyser;

        // Be sure to suspend after the analyser fftSize so we get a full buffer of data.  We will
        // grab the FFT data to prime the pump for smoothing.  We don't need to check the results
        // (because this is tested above in the basicFFTTests).
        var suspendFrame = Math.max(128, analyser.fftSize);
        context.suspend(suspendFrame / sampleRate).then(function () {
          // Grab the time and frequency data.  But we don't care what values we get now; we just
          // want to prime the analyser.
          var freqData = new Float32Array(analyser.frequencyBinCount);

          // Grab the frequency domain data
          analyser.getFloatFrequencyData(freqData);
        }).then(context.resume.bind(context));

        // Grab another set of data after one rendering quantum.  We will test this to make sure
        // smoothing was not done.
        suspendFrame += 128;
        context.suspend(suspendFrame / sampleRate).then(function () {
          var timeData = new Float32Array(analyser.fftSize);
          var freqData = new Float32Array(analyser.frequencyBinCount);

          // Grab the time domain and frequency domain data
          analyser.getFloatTimeDomainData(timeData);
          analyser.getFloatFrequencyData(freqData);

          var expected = computeFFTMagnitude(timeData, options.order).map(linearToDb);
          var comparison = compareFloatFreq(Math.pow(2, options.order) + "-point float FFT",
            freqData, expected, options);
          basicTestsPassed = basicTestsPassed && comparison.success;

          if (comparison.success)
            testPassed("Smoothing constant of 0 correctly handled.\n");
          else
            testFailed("Smoothing constant of 0 incorrectly handled.\n");
        }).then(context.resume.bind(context));

        context.startRendering().then(done);
      });

      audit.defineTask("finish", function (done) {
        finishJSTest();
        done();
      });

      audit.runTasks();

      // Run a simple test of the AnalyserNode's frequency domain data.  Both the float and byte
      // frequency data are tested.  The byte tests depend on the float tests being correct.
      //
      // The parameters of the test are given by |options| which is a property bag consisting of the
      // following:
      //
      //  order:  Order of the FFT to test.
      //  smoothing:  smoothing time constant for the analyser.
      //  minDecibels:  min decibels value for the analyser.
      //  floatRelError:  max allowed relative error for the float FFT data
      function basicFFTTest(options) {
        var graph = createGraph(options);
        var context = graph.context;
        var analyser = graph.analyser;

        var suspendTime = Math.max(128, analyser.fftSize) / sampleRate;
        context.suspend(suspendTime).then(function () {
          var timeData = new Float32Array(analyser.fftSize);
          var freqData = new Float32Array(analyser.frequencyBinCount);

          // Grab the time domain and frequency domain data
          analyser.getFloatTimeDomainData(timeData);
          analyser.getFloatFrequencyData(freqData);

          var expected = computeFFTMagnitude(timeData, options.order).map(linearToDb);
          var comparison = compareFloatFreq(Math.pow(2, options.order) + "-point float FFT",
            freqData, expected, options);
          basicTestsPassed = basicTestsPassed && comparison.success;
          var expected = comparison.expected;

          // For the byte test to be better, check that there are some samples that are outside the
          // range of minDecibels and maxDecibels.  If there aren't the test should update the
          // minDecibels and maxDecibels values for the analyser.

          var minValue = Math.min(...expected);
          var maxValue = Math.max(...expected);

          basicTestsPassed = Should("Min FFT value", minValue)
            .beLessThanOrEqualTo(analyser.minDecibels) && basicTestsPassed;
          basicTestsPassed = Should("Max FFT value", maxValue)
            .beGreaterThanOrEqualTo(analyser.maxDecibels) && basicTestsPassed;

          // Test the byte frequency data.
          var byteFreqData = new Uint8Array(analyser.frequencyBinCount);
          var expectedByteData = new Float32Array(analyser.frequencyBinCount);
          analyser.getByteFrequencyData(byteFreqData);

          // Convert the expected float frequency data to byte data.
          var expectedByteData = convertFloatToByte(expected, analyser.minDecibels,
            analyser.maxDecibels);

          basicTestsPassed = Should(analyser.fftSize + "-point byte FFT", byteFreqData, {
            verbose: true
          }).beCloseToArray(expectedByteData, 0) && basicTestsPassed;

        }).then(context.resume.bind(context));

        return context.startRendering();
      }
    </script>
  </body>
</html>