comparison dsp/keydetection/GetKeyMode.cpp @ 457:8a8cf7296e58

Fix some code stying issues in dsp/keydetection/GetKeyMode.cpp

 
 #include <cstring>
 #include <cstdlib>
 
 // Chords profile
-static double MajProfile[36] = 
-{ 0.0384, 0.0629, 0.0258, 0.0121, 0.0146, 0.0106, 0.0364, 0.0610, 0.0267,
-  0.0126, 0.0121, 0.0086, 0.0364, 0.0623, 0.0279, 0.0275, 0.0414, 0.0186, 
-  0.0173, 0.0248, 0.0145, 0.0364, 0.0631, 0.0262, 0.0129, 0.0150, 0.0098,
-  0.0312, 0.0521, 0.0235, 0.0129, 0.0142, 0.0095, 0.0289, 0.0478, 0.0239};
-
-static double MinProfile[36] =
-{ 0.0375, 0.0682, 0.0299, 0.0119, 0.0138, 0.0093, 0.0296, 0.0543, 0.0257,
-  0.0292, 0.0519, 0.0246, 0.0159, 0.0234, 0.0135, 0.0291, 0.0544, 0.0248,
-  0.0137, 0.0176, 0.0104, 0.0352, 0.0670, 0.0302, 0.0222, 0.0349, 0.0164,
-  0.0174, 0.0297, 0.0166, 0.0222, 0.0401, 0.0202, 0.0175, 0.0270, 0.0146};
+static double MajProfile[36] = {
+    0.0384, 0.0629, 0.0258, 0.0121, 0.0146, 0.0106, 0.0364, 0.0610, 0.0267,
+    0.0126, 0.0121, 0.0086, 0.0364, 0.0623, 0.0279, 0.0275, 0.0414, 0.0186, 
+    0.0173, 0.0248, 0.0145, 0.0364, 0.0631, 0.0262, 0.0129, 0.0150, 0.0098,
+    0.0312, 0.0521, 0.0235, 0.0129, 0.0142, 0.0095, 0.0289, 0.0478, 0.0239};
+
+static double MinProfile[36] = { 
+    0.0375, 0.0682, 0.0299, 0.0119, 0.0138, 0.0093, 0.0296, 0.0543, 0.0257,
+    0.0292, 0.0519, 0.0246, 0.0159, 0.0234, 0.0135, 0.0291, 0.0544, 0.0248,
+    0.0137, 0.0176, 0.0104, 0.0352, 0.0670, 0.0302, 0.0222, 0.0349, 0.0164,
+    0.0174, 0.0297, 0.0166, 0.0222, 0.0401, 0.0202, 0.0175, 0.0270, 0.0146};
 //
     
 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////
 
 GetKeyMode::GetKeyMode( int sampleRate, float tuningFrequency,
-			double hpcpAverage, double medianAverage ) :
+                        double hpcpAverage, double medianAverage ) :
     m_hpcpAverage( hpcpAverage ),
     m_medianAverage( medianAverage ),
     m_ChrPointer(0),
     m_DecimatedBuffer(0),
     m_ChromaBuffer(0),

     m_DecimationFactor = 8;
         
     // Chromagram configuration parameters
     m_ChromaConfig.normalise = MathUtilities::NormaliseUnitMax;
     m_ChromaConfig.FS = lrint(sampleRate/(double)m_DecimationFactor);
-    if (m_ChromaConfig.FS < 1) m_ChromaConfig.FS = 1;
+    if (m_ChromaConfig.FS < 1) {
+        m_ChromaConfig.FS = 1;
+    }
 
     // Set C (= MIDI #12) as our base :
     // This implies that key = 1 => Cmaj, key = 12 => Bmaj, key = 13 => Cmin, etc.
-    m_ChromaConfig.min = Pitch::getFrequencyForPitch
-        (48, 0, tuningFrequency);
-    m_ChromaConfig.max = Pitch::getFrequencyForPitch
-        (96, 0, tuningFrequency);
+    m_ChromaConfig.min = Pitch::getFrequencyForPitch( 48, 0, tuningFrequency );
+    m_ChromaConfig.max = Pitch::getFrequencyForPitch( 96, 0, tuningFrequency );
 
     m_ChromaConfig.BPO = 36;
     m_ChromaConfig.CQThresh = 0.0054;
 
     // Chromagram inst.

     
     m_MedianFilterBuffer = new int[ m_MedianWinsize ];
     memset( m_MedianFilterBuffer, 0, sizeof(int)*m_MedianWinsize);
     
     m_SortedBuffer = new int[ m_MedianWinsize ];
-    memset( m_SortedBuffer, 0, sizeof(int)*m_MedianWinsize);	
-    
-    m_Decimator = new Decimator
-        ( m_ChromaFrameSize*m_DecimationFactor, m_DecimationFactor );
+    memset( m_SortedBuffer, 0, sizeof(int)*m_MedianWinsize);
+    
+    m_Decimator = new Decimator( m_ChromaFrameSize*m_DecimationFactor, m_DecimationFactor );
 
     m_keyStrengths = new double[24];
 }
 
 GetKeyMode::~GetKeyMode()
 {
-
     delete m_Chroma;
     delete m_Decimator;
     
     delete [] m_DecimatedBuffer;
     delete [] m_ChromaBuffer;

     double mY = MathUtilities::mean( pData2, length );
     
     double sum1 = 0;
     double sum2 = 0;
     
-    for( unsigned int i = 0; i <length; i++ )
-    {
+    for( unsigned int i = 0; i <length; i++ ) {
         num += ( pData1[i] - mX ) * ( pData2[i] - mY );
 
         sum1 += ( (pData1[i]-mX) * (pData1[i]-mX) );
         sum2 += ( (pData2[i]-mY) * (pData2[i]-mY) );
     }
-	
+
     den = sqrt(sum1 * sum2);
-	
-    if( den>0 )
+
+    if( den>0 ) {
         retVal = num/den;
-    else
+    } else {
         retVal = 0;
-
+    }
 
     return retVal;
 }
 
 int GetKeyMode::process(double *PCMData)
 {
     int key;
-
     unsigned int j,k;
 
     //////////////////////////////////////////////
     m_Decimator->process( PCMData, m_DecimatedBuffer);
 
-    m_ChrPointer = m_Chroma->process( m_DecimatedBuffer );		
+    m_ChrPointer = m_Chroma->process( m_DecimatedBuffer );
 
     // The Cromagram has the center of C at bin 0, while the major
     // and minor profiles have the center of C at 1. We want to have
     // the correlation for C result also at 1.
     // To achieve this we have to shift two times:

     }
     std::cout << std::endl;
 */
     // populate hpcp values;
     int cbidx;
-    for( j = 0; j < m_BPO; j++ )
-    {
+    for( j = 0; j < m_BPO; j++ ) {
         cbidx = (m_bufferindex * m_BPO) + j;
         m_ChromaBuffer[ cbidx ] = m_ChrPointer[j];
     }
 
     //keep track of input buffers;
-    if( m_bufferindex++ >= m_ChromaBuffersize - 1) 
+    if( m_bufferindex++ >= m_ChromaBuffersize - 1) {
         m_bufferindex = 0;
+    }
 
     // track filling of chroma matrix
-    if( m_ChromaBufferFilling++ >= m_ChromaBuffersize)
+    if( m_ChromaBufferFilling++ >= m_ChromaBuffersize) {
         m_ChromaBufferFilling = m_ChromaBuffersize;
-
-    //calculate mean 		
-    for( k = 0; k < m_BPO; k++ )
-    {
+    }
+
+    //calculate mean
+    for( k = 0; k < m_BPO; k++ ) {
         double mnVal = 0.0;
-        for( j = 0; j < m_ChromaBufferFilling; j++ )
-        {
+        for( j = 0; j < m_ChromaBufferFilling; j++ ) {
             mnVal += m_ChromaBuffer[ k + (j*m_BPO) ];
         }
 
         m_MeanHPCP[k] = mnVal/(double)m_ChromaBufferFilling;
     }
 
 
-    for( k = 0; k < m_BPO; k++ )
-    {
+    for( k = 0; k < m_BPO; k++ ) {
         m_MajCorr[k] = krumCorr( m_MeanHPCP, MajProfile, m_BPO );
         m_MinCorr[k] = krumCorr( m_MeanHPCP, MinProfile, m_BPO );
 
         MathUtilities::circShift( MajProfile, m_BPO, 1 );
         MathUtilities::circShift( MinProfile, m_BPO, 1 );
     }
-	
-    for( k = 0; k < m_BPO; k++ )
-    {
+
+    for( k = 0; k < m_BPO; k++ ) {
         m_Keys[k] = m_MajCorr[k];
         m_Keys[k+m_BPO] = m_MinCorr[k];
     }
 
     for (k = 0; k < 24; ++k) {
         m_keyStrengths[k] = 0;
     }
 
-    for( k = 0; k < m_BPO*2; k++ )
-    {
+    for( k = 0; k < m_BPO*2; k++ ) {
         int idx = k / (m_BPO/12);
         int rem = k % (m_BPO/12);
         if (rem == 0 || m_Keys[k] > m_keyStrengths[idx]) {
             m_keyStrengths[idx] = m_Keys[k];
         }

 
 
     //Median filtering
 
     // track Median buffer initial filling
-    if( m_MedianBufferFilling++ >= m_MedianWinsize)
+    if( m_MedianBufferFilling++ >= m_MedianWinsize) {
         m_MedianBufferFilling = m_MedianWinsize;
-		
+    }
+
     //shift median buffer
-    for( k = 1; k < m_MedianWinsize; k++ )
-    {
+    for( k = 1; k < m_MedianWinsize; k++ ) {
         m_MedianFilterBuffer[ k - 1 ] = m_MedianFilterBuffer[ k ];
     }
 
     //write new key value into median buffer
     m_MedianFilterBuffer[ m_MedianWinsize - 1 ] = key;
 
 
     //Copy median into sorting buffer, reversed
     unsigned int ijx = 0;
-    for( k = 0; k < m_MedianWinsize; k++ )
-    {
+    for( k = 0; k < m_MedianWinsize; k++ ) {
         m_SortedBuffer[k] = m_MedianFilterBuffer[m_MedianWinsize-1-ijx];
         ijx++;
     }
 
     qsort(m_SortedBuffer, m_MedianBufferFilling, sizeof(unsigned int),

     int sortlength = m_MedianBufferFilling;
     int midpoint = (int)ceil((double)sortlength/2);
 
 //  std::cout << "midpoint = " << midpoint << endl;
 
-    if( midpoint <= 0 )
+    if( midpoint <= 0 ) {
         midpoint = 1;
+    }
 
     key = m_SortedBuffer[midpoint-1];
 
 // std::cout << "returning key = " << key << endl;