source: gs3-extensions/web-audio/trunk/js-dsp/component/wf-filter-bank.js@ 28388

var WFFilterBank = function(frameBufferLength,channels,samplerate,totalNumFrames) {

    this.frameBufferLength = frameBufferLength;
    this.channels = channels;
    this.samplerate = samplerate;
   
    this.totalNumFrames = totalNumFrames; // **** Not currently used 

    this.defaults();

    var fftWindowSize = Math.floor(this.frameBufferLength/channels); // check this is a power of 2??

    this.initCQT(fftWindowSize, fftWindowSize/2);

    //this.fft = new FFTCustom(fftWindowSize, this.samplerate);

    this.filterBankOut = new Float32Array(this.cqt_rec.cqtN);  // ditto above

    this.filterBankSequence = new Array();

    this.maxval = 0.0;

}

WFFilterBank.inherits(Component);

//----------------------------- OVERVIEW -----------------------------------------------------

WFFilterBank.staticfield('Component', {

    creator:     "David Bainbridge", 
    description: "Overview: Computes a frequency filter bank based on frequency spectrum input",
    name:        "filterBank", 
    tags:        "signal process, filter-bank",
    dependency: [ "dsp.js" ]
});

//------------------------------ INPUTS ------------------------------------------------------

WFFilterBank.staticfield('ComponentInputArray', [
    {
    name: "freqSpectrumInputFrames",
    description: "Frames of (mono) freqency spectrum input"
    }

]);


//------------------------------ PROPERTIES --------------------------------------------------

WFFilterBank.staticfield('ComponentPropertyArray', [
]);


//------------------------------ OUTPUTS -----------------------------------------------------

WFFilterBank.staticfield('ComponentOutputArray', [
    {
    name: "filterBankFrames",
    description: "Per frame filter bank"
    }
]);



WFFilterBank.prototype.reset = function()
{
    this.maxval = 0.0;
}


WFFilterBank.prototype.setMaxVal = function(v)
{
    this.maxval = v;
}


WFFilterBank.prototype.getMaxVal = function()
{
    return this.maxval;
}

WFFilterBank.prototype.getFilterBankSequence  = function() {
    return this.filterBankSequence;
}


// ******
// ******



WFFilterBank.prototype.defaults = function() {

    this.constantQ = 12;

    this.loEdge    = 55.0 * Math.pow(2.0, 2.5/12.0); // low C minus quater tone
    this.hiEdge    = 8000.0;
};


WFFilterBank.prototype.initializeCallback = function(ccp) {

}


//
// init Constant Q transform (http://en.wikipedia.org/wiki/Constant_Q_transform)
//
WFFilterBank.prototype.initCQT  = function(fftN, outN) {

    // Linear to log frequency map for FFT
    
    // BPO = bands per octave

    var info_mess = "filter-bank: { ";
    info_mess += "constantQ: " + this.constantQ;
    info_mess += ", fftN = " + fftN;
    info_mess += ", outN = " + outN;
    info_mess += ", sameplerate = " + this.samplerate;
    info_mess += ", loEdge = " + this.loEdge + " Hz"; 
    info_mess += ", hiEdge = " + this.hiEdge + " Hz";
    info_mess += " }";

    console.info(info_mess);

    var i,j;

    var BPO = this.constantQ; 
    var fratio = Math.pow(2.0,1.0/BPO);// Constant-Q bandwidth

    var cqtN =  Math.floor(Math.log(this.hiEdge/this.loEdge)/Math.log(fratio)); 
    if(cqtN<1) {
        console.error("cqtN not positive definite");
    }

    if (_dspdebug) {
    console.log("debug: cqtN = " + cqtN);
    }

    var fftfrqs = new Float32Array(outN); // Actual number of real FFT coefficients
    var logfrqs = new Float32Array(cqtN); // Number of constant-Q spectral bins
    var logfbws = new Float32Array(cqtN); // Bandwidths of constant-Q bins

    var CQT = new Float32Array(cqtN*outN); // The transformation matrix

    var mxnorm = new Float32Array(cqtN); // Normalization coefficients
    var N = fftN;     // N used as a (double)

    for(i=0; i < outN; i++) {
        fftfrqs[i] = i * this.samplerate / N;
    }

    for(i=0; i<cqtN; i++){
        logfrqs[i] = this.loEdge * Math.exp(Math.log(2.0)*i/BPO);
        logfbws[i] = Math.max(logfrqs[i] * (fratio - 1.0), this.samplerate / N);
    }
     
    var ovfctr = 0.5475; // Norm constant so CQT'*CQT close to 1.0
    var tmp,tmp2;
    var ptr;

    // Build the constant-Q transform (CQT)
    for(i=0,ptr=0; i<cqtN; i++){
        mxnorm[i]=0.0;
        tmp2=1.0/(ovfctr*logfbws[i]);
        for(j=0 ; j < outN; j++, ptr++){
            tmp=(logfrqs[i] - fftfrqs[j])*tmp2;
            tmp=Math.exp(-0.5*tmp*tmp);
        CQT[ptr]=tmp; // row major transform
            mxnorm[i]+=tmp*tmp;
        }      
        mxnorm[i]=2.0*Math.sqrt(mxnorm[i]);
    }

    // Normalize transform matrix for identity inverse
    for(i=0,ptr=0; i<cqtN; i++) {
        tmp = 1.0/mxnorm[i];
        for(j=0; j<outN; j++,ptr++) {
        CQT[ptr] *= tmp;
    }
    }

    var cqt_rec = { CQT: CQT, cqtN: cqtN, outN: outN };

    if (_dspdebug) {
    var CQT  = cqt_rec.CQT;
    var cqtN = cqt_rec.cqtN;
    var outN = cqt_rec.outN;

        //for(i=0,ptr=0; i<cqtN; i++){
        for(i=0,ptr=0; i<cqtN; i+=10){
        ptr = i*outN;
        var line = "";
        //for(j=0; j<outN; j++,ptr++) {
        for(j=0; j<outN; j+=20,ptr+=20) {
        line += CQT[ptr] + " ";
        }
        console.log(line);
    }
    }

    // store it in object
    this.cqt_rec = cqt_rec;

};


WFFilterBank.prototype.computeFilterBank = function(fftSpectrumIn,cqtOut)
{
    var CQT  = this.cqt_rec.CQT;
    var cqtN = this.cqt_rec.cqtN;
    var outN = this.cqt_rec.outN;

    // matrix product of CQT * fftSpectrumIn
    
    var a=cqtN;
    var i=0;

    while (a--) {
    cqtOut[i] = 0.0;

        var ptr2 = i * outN;
        var ptr3 = 0;

        var b = outN;
        while (b--) {

        cqtOut[i] += CQT[ptr2] * fftSpectrumIn[ptr3];

        ptr2++;
        ptr3++;
    }

    if (cqtOut[i]>this.maxval) {
        this.maxval = cqtOut[i];
    }

    i++;
    }
}

/*
WFFilterBank.prototype.computeTransform = function(signal) {

    // executeCallback
    // need to get signal from 'cc' rather than passed in directly as param

    this.fft.forward(signal);
    
    this.computeFilterBank(this.fft.powerSpectrum,this.filterBankOut);

    var filterBankCopy = new Float32Array(this.filterBankOut); // need a copy of the array (not just a reference)
    this.filterBankSequence.push(filterBankCopy); 

    if (_dspdebug) {
    var line = "";
    for (i=0; i<this.filterBankOut.length; i+=20) {
        line += this.filterBankOut[i] + " ";
    }
     
    console.log("filter bank: " + line);
    }

}

*/


WFFilterBank.prototype.executeCallBack = function(cc) {
    
    // typeof(cc) => ComponentContext
    
    // get the "[D" input

    //console.info("*** WFFilterBank::executeCallBack(): away to request 'inputFrames'");

    var frame = cc.getDataComponentFromInput("freqSpectrumInputFrames");

//    this.fft.forward(frame);
    
//    this.computeFilterBank(this.fft.powerSpectrum,this.filterBankOut);

    this.computeFilterBank(frame,this.filterBankOut);

    var filterBankCopy = new Float32Array(this.filterBankOut); // need a copy of the array (not just a reference)
    this.filterBankSequence.push(filterBankCopy); 

    cc.pushDataComponentToOutput("filterBankFrames",this.filterBankOut);

}