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

var WFChromaTransform = function(transformMode,frameBufferLength,channels,samplerate,totalNumFrames) {

    this.getset = {};

    this.transformMode = transformMode;

    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.chromaFeaturesOut = new Float32Array(this.numChromaBins); // Init once here, space is reused per calculation
    this.filterBankOut = new Float32Array(this.cqt_rec.cqtN);  // ditto above

    this.chromaFeaturesSequence = new Array();
    this.filterBankSequence = new Array();

    this.maxval = { freqSpectrum: 0.0, freqPowerSpectrum: 0.0, filterBank: 0.0, chromaFeatures: 0.0 };

}

WFChromaTransform.inherits(Component);

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

WFChromaTransform.staticfield('Component', {

    creator:     "David Bainbridge", 
    description: "Overview: To be written ...",
    name:        "Chromagram", 
    tags:        "signal process, chromagram",
    dependency: [ "dsp.js" ]
});

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

WFChromaTransform.staticfield('ComponentInputArray', [
/*
    {
    name: "signal",
    description: "A Signal object with \"fileLocation\" metadata, indicating the " 
        + "location of the corresponding audio file."
    }
*/
    {
    name: "inputFrames",
    description: "Frames of mono-audio input"
    }

]);


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

WFChromaTransform.staticfield('ComponentPropertyArray', [

]);


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

WFChromaTransform.staticfield('ComponentOutputArray', [

    {
    name: "output",
    description: "Chroma bins"
    }
]);




WFChromaTransform.prototype.reset = function()
{
    this.maxval.freqSpectrum = 0.0;
    this.maxval.freqPowerSpectrum = 0.0;
    this.maxval.filterBank = 0.0;
    this.maxval.chromaFeatures = 0.0;
}

WFChromaTransform.prototype.setTransformMode  = function(transformMode) {
    this.transformMode = transformMode;
}

WFChromaTransform.prototype.getTransformMode  = function() {
    return this.transformMode;
}

WFChromaTransform.prototype.setMaxVal = function(v)
{
    this.maxval[this.transformMode] = v;
}


WFChromaTransform.prototype.getMaxVal = function()
{
    var maxVal = this.maxval[this.transformMode];

    return maxVal;
}

WFChromaTransform.prototype.getChromaFeaturesSequence  = function() {
    return this.chromaFeaturesSequence;
}

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


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



WFChromaTransform.prototype.defaults = function() {

    this.constantQ = 12;
    this.numOctaves = 1;
    this.numChromaBins = this.constantQ * this.numOctaves;

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

};


WFChromaTransform.prototype.initializeCallback = function(ccp) {


    this.progress = 0;
    this.ssm = null;
}


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

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

    var info_mess = "chroma-transform: { ";
    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;

};


WFChromaTransform.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.filterBank) {
        this.maxval.filterBank = cqtOut[i];
    }

    i++;
    }
}

WFChromaTransform.prototype.computeChroma  = function(cqtIn, chromaOut) {

    // compute CHROMA
    
    var cqtN = cqtIn.length;

    var log10 = Math.log(10);

    var a = this.numChromaBins;

    var i=0;

    while(a--){
        var c = 1;

    // folder higher up octaves into the first one
    var ptr1_val = 0;

        //for(var b=this.constantQ+i; b<cqtN; b+=this.constantQ){
        for(var b=i; b<cqtN; b+=this.numChromaBins){
        ptr1_val += cqtIn[b];
            c++;
        }   
    ptr1_val /= c; // Normalize by number of bands summed

    // ***** can generate negative values ???
        //ptr1_val = Math.log( ptr1_val ) / log10;

    chromaOut[i] = ptr1_val;

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

        i++;
    }
}

WFChromaTransform.prototype.computeChromaAlt = function(spectrumIn,chromaOut) {


    var CB = chromaOut.length; // num chroma bins

    for (var i=0; i<CB; i++) {
    chromaOut[i] = 0.0;
    }

    var CR = 440/32.0;
    var fs = this.samplerate;
    var fL = (this.frameBufferLength/this.channels); // **** mod by me

    var log2 = Math.log(2);

    for (var k=this.loEdge; k<=this.hiEdge; k++) {
        var ind = Math.round(CB*Math.log((k)*fs/fL/CR)/log2);
        var mod_ind = ind%CB;
        chromaOut[mod_ind] += spectrumIn[k];

    if (chromaOut[mod_ind]>this.maxval.chromaFeatures) {
        this.maxval.chromaFeatures = chromaOut[mod_ind];
    }

    }

}


WFChromaTransform.prototype.computeTransform = function(filterBankFrame) {


    //this.fft.forward(monoAudioFrame);
    
    //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); 

    this.computeChroma(this.filterBankOut,this.chromaFeaturesOut);
    //this.computeChromaAlt(this.fft.powerSpectrum,this.chromaFeaturesOut);

    this.computeChroma(filterBankFrame,this.chromaFeaturesOut);

    var chromaFeaturesCopy = new Float32Array(this.chromaFeaturesOut); // need a copy of the array (not just a reference)
    this.chromaFeaturesSequence.push(chromaFeaturesCopy); 
}



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

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

    var frame = cc.getDataComponentFromInput("inputFrames");
/*
    var mess = "";
    for (var i=0; i<frame.length; i+=200) {
    mess += frame[i] + ", ";
    }
    console.log("**** WF Chroma Trans: data samples = " + mess);
*/

    this.computeTransform(frame);
}


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


WFChromaTransform.prototype.dotProduct = function(v1,v2) {
    var vlen = v1.length;

    var d = 0;

    for (var i=0; i<vlen; i++) {
    d = d + (v1[i]*v2[i]);
    }

    return d;
}

WFChromaTransform.prototype.vectorLength = function(v) {
    var vlen = v.length;

    var l = 0.0;

    for (var i=0; i<vlen; i++) {
    l = l + (v[i]*v[i]);
    }

    l = Math.sqrt(l);

    return l;
}


WFChromaTransform.prototype.computeSelfSimilarityMatrix = function(chromaFeaturesSequence) {

    var num_frames = chromaFeaturesSequence.length;

    var norm_lengths = new Float32Array(num_frames);

    this.csm = new Array(num_frames) ; // chroma (self) similarity matrix
    for (var i=0; i<num_frames; i++) {
    this.csm[i] = new Float32Array(num_frames);
    this.csm[i][i]=1.0;

    norm_lengths[i] = this.vectorLength(chromaFeaturesSequence[i]);
    }

    
    var total_calcs = num_frames*num_frames;
    var c = 0;
    this.progress = 0;

    var i = 0;

    (function(outerThis) {
    //for (var i=0; i<num_frames-1; i++) {
    

    for (var j=i+1; j<num_frames; j++) {

        outerThis.progress = Math.round((100.0*c)/total_calcs);

        outerThis.csm[i][j] = outerThis.dotProduct(chromaFeaturesSequence[i],chromaFeaturesSequence[j])/(norm_lengths[i]*norm_lengths[j]);

            outerThis.csm[j][i] = outerThis.csm[i][j];
        c+=2;
    }
    i++;

    if (i<num_frames-1) {
        setTimeout(arguments.callee,0,outerThis);
    }    
    else {
        outerThis.progress = 100;
    }
    })(this);


}