(function(window) {

  var VAD = function(options) {
    // Default options
    this.options = {
      fftSize: 512,
      bufferLen: 512, 
      voice_stop: function() {},
      voice_start: function() {},
      smoothingTimeConstant: 0.99, 
      energy_offset: 1e-8, // The initial offset.
      energy_threshold_ratio_pos: 2, // Signal must be twice the offset
      energy_threshold_ratio_neg: 0.5, // Signal must be half the offset
      energy_integration: 1, // Size of integration change compared to the signal per second.
      filter: [
        {f: 200, v:0}, // 0 -> 200 is 0
        {f: 2000, v:1} // 200 -> 2k is 1
      ],
      source: null,
      context: null
    };

    // User options
    for(var option in options) {
      if(options.hasOwnProperty(option)) {
        this.options[option] = options[option];
      }
    }

    // Require source
   if(!this.options.source)
     throw new Error("The options must specify a MediaStreamAudioSourceNode.");

    // Set this.options.context
    this.options.context = this.options.source.context;

    // Calculate time relationships
    this.hertzPerBin = this.options.context.sampleRate / this.options.fftSize;
    this.iterationFrequency = this.options.context.sampleRate / this.options.bufferLen;
    this.iterationPeriod = 1 / this.iterationFrequency;

    var DEBUG = true;
    if(DEBUG) console.log(
      'Vad' +
      ' | sampleRate: ' + this.options.context.sampleRate +
      ' | hertzPerBin: ' + this.hertzPerBin +
      ' | iterationFrequency: ' + this.iterationFrequency +
      ' | iterationPeriod: ' + this.iterationPeriod
    );

    this.setFilter = function(shape) {
      this.filter = [];
      for(var i = 0, iLen = this.options.fftSize / 2; i < iLen; i++) {
        this.filter[i] = 0;
        for(var j = 0, jLen = shape.length; j < jLen; j++) {
          if(i * this.hertzPerBin < shape[j].f) {
            this.filter[i] = shape[j].v;
            break; // Exit j loop
          }
        }
      }
    }

    this.setFilter(this.options.filter);

    this.ready = {};
    this.vadState = false; // True when Voice Activity Detected

    // Energy detector props
    this.energy_offset = this.options.energy_offset;
    this.energy_threshold_pos = this.energy_offset * this.options.energy_threshold_ratio_pos;
    this.energy_threshold_neg = this.energy_offset * this.options.energy_threshold_ratio_neg;

    this.voiceTrend = 0;
    this.voiceTrendMax = 10;
    this.voiceTrendMin = -10;
    this.voiceTrendStart = 5;
    this.voiceTrendEnd = -5;

    // Create analyser 
    this.analyser = this.options.context.createAnalyser();
    this.analyser.smoothingTimeConstant = this.options.smoothingTimeConstant; // 0.99;
    this.analyser.fftSize = this.options.fftSize;

    this.floatFrequencyData = new Float32Array(this.analyser.frequencyBinCount);

    // Setup local storage of the Linear FFT data
    this.floatFrequencyDataLinear = new Float32Array(this.floatFrequencyData.length);

    // Connect this.analyser
    this.options.source.connect(this.analyser); 

    // Create ScriptProcessorNode
    this.scriptProcessorNode = this.options.context.createScriptProcessor(this.options.bufferLen, 1, 1);

    // Connect scriptProcessorNode (Theretically, not required)
    this.scriptProcessorNode.connect(this.options.context.destination);

    // Create callback to update/analyze floatFrequencyData
    var self = this;
    this.scriptProcessorNode.onaudioprocess = function(event) {
      self.analyser.getFloatFrequencyData(self.floatFrequencyData);
      self.update();
      self.monitor();
    };

    // Connect scriptProcessorNode
    this.options.source.connect(this.scriptProcessorNode);

    // log stuff
    this.logging = false;
    this.log_i = 0;
    this.log_limit = 100;

    this.triggerLog = function(limit) {
      this.logging = true;
      this.log_i = 0;
      this.log_limit = typeof limit === 'number' ? limit : this.log_limit;
    }

    this.log = function(msg) {
      if(this.logging && this.log_i < this.log_limit) {
        this.log_i++;
        console.log(msg);
      } else {
        this.logging = false;
      }
    }

    this.update = function() {
      // Update the local version of the Linear FFT
      var fft = this.floatFrequencyData;
      for(var i = 0, iLen = fft.length; i < iLen; i++) {
        this.floatFrequencyDataLinear[i] = Math.pow(10, fft[i] / 10);
      }
      this.ready = {};
    }

    this.getEnergy = function() {
      if(this.ready.energy) {
        return this.energy;
      }

      var energy = 0;
      var fft = this.floatFrequencyDataLinear;

      for(var i = 0, iLen = fft.length; i < iLen; i++) {
        energy += this.filter[i] * fft[i] * fft[i];
      }

      this.energy = energy;
      this.ready.energy = true;

      return energy;
    }

    this.monitor = function() {
      var energy = this.getEnergy();
      var signal = energy - this.energy_offset;

      if(signal > this.energy_threshold_pos) {
        this.voiceTrend = (this.voiceTrend + 1 > this.voiceTrendMax) ? this.voiceTrendMax : this.voiceTrend + 1;
      } else if(signal < -this.energy_threshold_neg) {
        this.voiceTrend = (this.voiceTrend - 1 < this.voiceTrendMin) ? this.voiceTrendMin : this.voiceTrend - 1;
      } else {
        // voiceTrend gets smaller
        if(this.voiceTrend > 0) {
          this.voiceTrend--;
        } else if(this.voiceTrend < 0) {
          this.voiceTrend++;
        }
      }

      var start = false, end = false;
      if(this.voiceTrend > this.voiceTrendStart) {
        // Start of speech detected
        start = true;
      } else if(this.voiceTrend < this.voiceTrendEnd) {
        // End of speech detected
        end = true;
      }

      // Integration brings in the real-time aspect through the relationship with the frequency this functions is called.
      var integration = signal * this.iterationPeriod * this.options.energy_integration;

      // Idea?: The integration is affected by the voiceTrend magnitude? - Not sure. Not doing atm.

      // The !end limits the offset delta boost till after the end is detected.
      if(integration > 0 || !end) {
        this.energy_offset += integration;
      } else {
        this.energy_offset += integration * 10;
      }
      this.energy_offset = this.energy_offset < 0 ? 0 : this.energy_offset;
      this.energy_threshold_pos = this.energy_offset * this.options.energy_threshold_ratio_pos;
      this.energy_threshold_neg = this.energy_offset * this.options.energy_threshold_ratio_neg;

      // Broadcast the messages
      if(start && !this.vadState) {
        this.vadState = true;
        this.options.voice_start();
      }
      if(end && this.vadState) {
        this.vadState = false;
        this.options.voice_stop();
      }

      this.log(
        'e: ' + energy +
        ' | e_of: ' + this.energy_offset +
        ' | e+_th: ' + this.energy_threshold_pos +
        ' | e-_th: ' + this.energy_threshold_neg +
        ' | signal: ' + signal +
        ' | int: ' + integration +
        ' | voiceTrend: ' + this.voiceTrend +
        ' | start: ' + start +
        ' | end: ' + end
      );

      return signal;
    }
  };

  window.VAD = VAD;

})(window);

from https://github.com/kdavis-mozilla/vad.js/blob/master/lib/vad.js