snippet.html

    var calculateDFT = function(buffer, sampleRate) {
      var complexValues = [];
      
      for ( var k = 0; k < buffer.length/2; k ++ ) {
        var real = 0.0;
        var imag = 0.0;
        
        var binFrequency = k * (sampleRate / buffer.length);
        
        for ( var n = 0; n < buffer.length; n++ ) {
          var step = n * binFrequency / sampleRate;

          real += Math.cos(2*Math.PI * step) * signal[n];
          imag += Math.sin(2*Math.PI * step) * signal[n];
        }

        complexValues[k] = [real, imag];
      }
      
      return complexValues;
    }
    
    var calculateFFT = function(float real, float imag) {
      var bufferSize = real.length;
        
      if ( bufferSize == 1 ) {
        return [[real[0], imag[0]]];
      }
        
      if ( bufferSize % 2 != 0 ) throw "Invalid buffer size, must be a power of 2";
        
      var even_real = [];
      var even_imag = [];
      var odd_real  = [];
      var odd_imag  = [];
        
      // break up signal into odd and even parts
      for ( var k = 0; k < bufferSize/2; k++ ) {
        if ( typeof(imag) == 'undefined' ) { 
          // this is a non complex signal
          even_real[k] = real[2*k];
          even_imag[k] = 0.0;
          odd_real[k] = real[2*k+1];
          odd_imag[k] = 0.0;
        } else {
          even_real[k] = real[2*k];
          even_imag[k] = imag[2*k];
          odd_real[k] = real[2*k+1];
          odd_imag[k] = imag[2*k+1];
        }
      }
        
      var q = calculateFFT(even_real, even_imag);
      var r = calculateFFT(odd_real, odd_imag);

      complexValues = [];

      for ( var k = 0; k < bufferSize/2; k++ ) {
        var kth = -2 * k * Math.PI / bufferSize;
        var wk_real = Math.cos(kth);
        var wk_imag = Math.sin(kth);

        // Complex: q[k] + wk * r[k], must multiply the complex parts correctly into the tupple format [real, imag]
        complexValues[k] = [q[k][0] + (wk_real*r[k][0] - wk_imag*r[k][1]), q[k][1] + (wk_real*r[k][1] + wk_imag*r[k][0])];
        // Complex: q[k] - wk * r[k], must multiply the complex parts correctly into the tupple format [real, imag]
        complexValues[k + bufferSize/2] = [q[k][0] - (wk_real*r[k][0] - wk_imag*r[k][1]), q[k][1] - (wk_real*r[k][1] + wk_imag*r[k][0])];
      }
      
      return complexValues;
    }