comparison procedures.cpp @ 11:977f541d6683

GPL and cosmetic changes

+/*
+    Harmonic sinusoidal modelling and tools
+
+    C++ code package for harmonic sinusoidal modelling and relevant signal processing.
+    Centre for Digital Music, Queen Mary, University of London.
+    This file copyright 2011 Wen Xue.
+
+    This program is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License as
+    published by the Free Software Foundation; either version 2 of the
+    License, or (at your option) any later version.
+*/
 //---------------------------------------------------------------------------
 
 #include <math.h>
 #include <string.h>
 #include <stddef.h>

 
   int Fr=(end-start-Wid)/Offst+1;
 
   for (int i=0; i<Fr; i++)
   {
-    RFFTCW(&data[i*Offst+start], Window, 0, 0, log2(Wid), w, x);
+    RFFTCW(&data[i*Offst+start], Window, 0, 0, Log2(Wid), w, x);
 
     if (Spec)
     {
       for (int j=0; j<Wid/2; j++)
         Spec[i][j]=sqrt(x[j].x*x[j].x+x[j].y*x[j].y)*amp;

   saved to dest[], and the last size2+zero sampled are saved to post_buffer[]; if not, the middle size1
   samples are saved to dest[], while pre_buffer[] and post_buffer[] are not used.
 */
 void FFTConv(double* dest, double* source1, int size1, double* source2, int size2, int zero, double* pre_buffer, double* post_buffer)
 {
-  int order=log2(size2-1)+1+1;
+  int order=Log2(size2-1)+1+1;
   int Wid=1<<order;
   int HWid=Wid/2;
   int Fr=size1/HWid;
   int res=size1-HWid*Fr;
   bool trunc=false;

   No return value.
 */
 void FFTConv(double* dest, double* source1, int size1, double* source2, int HWid, double* pre_buffer)
 {
   int Wid=HWid*2;
-  int order=log2(Wid);
+  int order=Log2(Wid);
   int Fr=size1/HWid;
   int res=size1-HWid*Fr;
 
   AllocateFFTBuffer(Wid, fft, w, x1);
   cdouble *x2=new cdouble[Wid];

 
   No return value. Identical dest and source1 allowed.
 */
 void FFTConv(unsigned char* dest, unsigned char* source1, int bps, int size1, double* source2, int size2, int zero, unsigned char* pre_buffer, unsigned char* post_buffer)
 {
-  int order=log2(size2-1)+1+1;
+  int order=Log2(size2-1)+1+1;
   int Wid=1<<order;
   int HWid=Wid/2;
   int Fr=size1/HWid;
   int res=size1-HWid*Fr;
   bool trunc=false;

 
   No return value. Identical data and dataout allowed
 */
 void FFTFilter(double* dataout, double* data, int Count, int Wid, int On, int Off)
 {
-  int Order=log2(Wid);
+  int Order=Log2(Wid);
   int HWid=Wid/2;
   int Fr=(Count-Wid)/HWid+1;
   AllocateFFTBuffer(Wid, ldata, w, x);
 
   double* win=new double[Wid];

 void FFTFilterOLA(double* dataout, double* data, int Count, int Wid, int On, int Off, double* pre_buffer)
 {
   AllocateFFTBuffer(Wid, spec, w, x);
   memset(x, 0, sizeof(cdouble)*Wid);
   for (int i=On+1; i<Off; i++) x[i].x=x[Wid-i].x=1-2*(i%2);
-  CIFFTR(x, log2(Wid), w, spec);
+  CIFFTR(x, Log2(Wid), w, spec);
   FFTConv(dataout, data, Count, spec, Wid, -Wid, pre_buffer, NULL);
   FreeFFTBuffer(spec);
 }//FFTFilterOLA
 //version for integer input and output, where BytesPerSample specifies the integer format.
 void FFTFilterOLA(unsigned char* dataout, unsigned char* data, int BytesPerSample, int Count, int Wid, int On, int Off, unsigned char* pre_buffer)
 {
   AllocateFFTBuffer(Wid, spec, w, x);
   memset(x, 0, sizeof(cdouble)*Wid);
   for (int i=On+1; i<Off; i++) x[i].x=x[Wid-i].x=1-2*(i%2);
-  CIFFTR(x, log2(Wid), w, spec);
+  CIFFTR(x, Log2(Wid), w, spec);
   FFTConv(dataout, data, BytesPerSample, Count, spec, Wid, -Wid, pre_buffer, NULL);
   FreeFFTBuffer(spec);
 }//FFTFilterOLA
 
 /**

     x[i].x=x[Wid-i].x=amp[i]*cos(ph[i]);
     x[i].y=amp[i]*sin(ph[i]);
     x[Wid-i].y=-x[i].y;
   }
   x[HWid].x=amp[HWid], x[HWid].y=0;
-  CIFFTR(x, log2(Wid), w, spec);
+  CIFFTR(x, Log2(Wid), w, spec);
   FFTConv(dataout, data, Count, spec, Wid, -Wid, pre_buffer, NULL);
   FreeFFTBuffer(spec);
 }//FFTFilterOLA
 
 /**

 
   No return value.
 */
 double FFTMask(double* dataout, double* data, int Count, int Wid, double DigiOn, double DigiOff, double maskcoef)
 {
-  int Order=log2(Wid);
+  int Order=Log2(Wid);
   int HWid=Wid/2;
   int Fr=(Count-Wid)/HWid+1;
   int On=Wid*DigiOn, Off=Wid*DigiOff;
   AllocateFFTBuffer(Wid, ldata, w, x);
 

 */
 void MFCC(int FrameWidth, int NumBands, int Ceps_Order, double* Data, double* Bands, double* C, double* Amps, cdouble* W, cdouble* X)
 {
   double tmp, b2s, b2c, b2e;
 
-  RFFTC(Data, 0, 0, log2(FrameWidth), W, X, 0);
+  RFFTC(Data, 0, 0, Log2(FrameWidth), W, X, 0);
   for (int i=0; i<=FrameWidth/2; i++) Amps[i]=X[i].x*X[i].x+X[i].y*X[i].y;
   
   for (int i=0; i<NumBands; i++)
   {
     tmp=0;

   double* Arg=new double[Count*Pad];
   AllocateFFTBuffer(Count*Pad, Amp, w, x);
   memset(Amp, 0, sizeof(double)*Count*Pad);
   memcpy(&Amp[Count*(Pad-1)/2], data, sizeof(double)*Count);
   ApplyWindow(Amp, Amp, params->Amp, Count);
-  RFFTC(Amp, Amp, Arg, log2(Count*Pad), w, x, 0);
+  RFFTC(Amp, Amp, Arg, Log2(Count*Pad), w, x, 0);
 
   SmoothPhase(Arg, Count*Pad/2+1);
   double result=Arg[Count*Pad/2]-Arg[0];
   delete[] Arg;
   FreeFFTBuffer(Amp);

 */
 void TFFilter(double* data, double* dataout, int Count, int Wid, TTFSpans* Spans, bool Pass, WindowType wt, double windp, int Sps, int TOffst)
 {
   int HWid=Wid/2;
   int Fr=Count/HWid-1;
-  int Order=log2(Wid);
+  int Order=Log2(Wid);
 
   int** lspan=new int*[Fr];
   double* lxspan=new double[Fr];
 
   lspan[0]=new int[Fr*Wid];

 //version on integer data, where BytesPerSample specified the integer format.
 void TFFilter(void* data, void* dataout, int BytesPerSample, int Count, int Wid, TTFSpans* Spans, bool Pass, WindowType wt, double windp, int Sps, int TOffst)
 {
   int HWid=Wid/2;
   int Fr=Count/HWid-1;
-  int Order=log2(Wid);
+  int Order=Log2(Wid);
 
   int** lspan=new int*[Fr];
   double* lxspan=new double[Fr];
 
   lspan[0]=new int[Fr*Wid];