pitchshift.js

"use strict"

var frameHop = require("frame-hop")
var overlapAdd = require("overlap-add")
var detectPitch = require("detect-pitch")
var pool = require("typedarray-pool")

function createWindow(n) {
  var result = new Float32Array(n)
  for(var i=0; i<n; ++i) {
    var t = i / (n-1)
    result[i] = 0.5 * (1.0 - Math.cos(2.0*Math.PI * t))
  }
  return result
}

function normalizeWindow(w, hop_size) {
  var n = w.length
  var nh = (n / hop_size)|0
  var scale = pool.mallocFloat32(n)
  for(var i=0; i<n; ++i) {
    var s = 0.0
    for(var j=0; j<nh; ++j) {
      s += w[(i + j*hop_size)%n]
    }
    scale[i] = s
  }
  for(var i=0; i<n; ++i) {
    w[i] /= scale[i]
  }
  pool.freeFloat32(scale)
}

//Applies window to signal
function applyWindow(X, W, frame) {
  var i, n = frame.length
  for(i=0; i<n; ++i) {
    X[i] = W[i] * frame[i]
  }
}

//Performs the actual pitch scaling
function scalePitch(out, x, nx, period, scale, shift, w) {
  var no = out.length
  for(var i=0; i<no; ++i) {
    var t  = i * scale + shift
    var ti = Math.floor(t)|0
    var tf = t - ti
    var x1 = x[ti%nx]
    var x2 = x[(ti+1)%nx]
    var v = (1.0 - tf) * x1 + tf * x2
    out[i] = w[i] * v
  }
}

//Match start/end points of signal to avoid popping artefacts
function findMatch(x, start, step) {
  var a = x[0], b = x[step], c = x[2*step]
  var n = x.length
  var best_d = 8
  var best_i = start
  for(var i=start; i<n-2*step; ++i) {
    var s = x[i]-a, t = x[i+step]-b, u=x[i+2*step]-c
    var d = s*s + t*t + u*u
    if( d < best_d ) {
      best_d = d
      best_i = i
    }
  }
  return best_i
}

function roundToNearestDivisor(n, period) {
  var lo = period, hi = period
  while(2*lo > period) {
    if(n % lo === 0) {
      return lo
    }
    --lo
    if(n % hi === 0) {
      return hi
    }
    ++hi
  }
  return period
}

function pitchShift(onData, onTune, options) {
  options = options || {}
  
  var frame_size  = options.frameSize || 2048
  var hop_size    = options.hopSize || (frame_size>>>2)
  var sample_rate = options.sampleRate || 44100
  var data_size   = options.maxDataSize || undefined
  var a_window    = options.analysisWindow || createWindow(frame_size)
  var s_window    = options.synthesisWindow || createWindow(frame_size)
  var threshold   = options.freqThreshold || 0.9
  var start_bin   = options.minPeriod || Math.max(16, Math.floor(sample_rate / 1000))|0
  var scale_threshold = options.harmonicScale || 0.2
  
  var detect_params = {
    threshold: threshold,
    start_bin: start_bin
  }
  
  var t           = 0
  var cur         = new Float32Array(frame_size)
  
  if(frame_size % hop_size !== 0) {
    throw new Error("Hop size must divide frame size")
  }
  
  //Normalize synthesis window
  normalizeWindow(s_window, hop_size)
  
  var addFrame = overlapAdd(frame_size, hop_size, onData)
  var delay = 0
  var pfreq = 0.0
  
  function doPitchShift(frame) {

    //Apply window
    applyWindow(cur, a_window, frame)
    
    //Compute pitch, period and sample rate
    var period = detectPitch(cur, detect_params)
    
    //Calculate frame size
    var fsize = frame_size>>1
    if(period > 0) {
      fsize = (Math.max(1, Math.floor(0.5*frame_size/period)) * period)|0
    }
    fsize = findMatch(frame, fsize|0, Math.max(1, period/20)|0)
 
    //Compute pitch
    var pitch = 0.0
    if(period > 0) {
      pitch = sample_rate / period
    }
    for(var k=10; k>0; --k) {
      var s = +(1<<k)
      if(Math.abs(s*pfreq - pitch) < scale_threshold * pitch) {
        pitch = pitch / s
      }
    }
    pfreq = pitch
    
    //Apply scale factor
    var scale_f = onTune(t / sample_rate, pitch)
    
    //Apply scaling
    delay = ((delay % fsize) + fsize) % fsize
    scalePitch(cur, frame, fsize, period|0, scale_f, delay, s_window)
    
    //Update counters
    delay += hop_size * (scale_f - 1.0)
    t += hop_size
    
    //Add frame
    addFrame(cur)
  }
  
  return frameHop(frame_size, hop_size, doPitchShift, data_size)
}
module.exports = pitchShift