comparison Chordino.cpp @ 164:3c731acad404

Fix some problems from the plugin tester: zero sample rate with fixed sample type outputs; mismatching parameter id ("spectralshape" in Chordino, "s" in NNLSBase -- changing this in Chordino won't break anything as it would never have worked under that name anyway); some NaN values

     whiteningParam.defaultValue = 1.0;
     whiteningParam.isQuantized = false;
     list.push_back(whiteningParam);
 
     ParameterDescriptor spectralShapeParam;
-    spectralShapeParam.identifier = "spectralshape";
+    spectralShapeParam.identifier = "s";
     spectralShapeParam.name = "spectral shape";
     spectralShapeParam.description = "Determines how individual notes in the note dictionary look: higher values mean more dominant higher harmonics.";
     spectralShapeParam.unit = "";
     spectralShapeParam.minValue = 0.5;
     spectralShapeParam.maxValue = 0.9;

     if (debug_on) cerr << "--> getOutputDescriptors" << endl;
     OutputList list;
     
     int index = 0;
 
+    float featureRate =
+        (m_stepSize == 0) ? m_inputSampleRate/2048 : m_inputSampleRate/m_stepSize;
+    
     OutputDescriptor d7;
     d7.identifier = "simplechord";
     d7.name = "Chord Estimate";
     d7.description = "Estimated chord times and labels.";
     d7.unit = "";

     d7.binCount = 0;
     d7.hasKnownExtents = false;
     d7.isQuantized = false;
     d7.sampleType = OutputDescriptor::VariableSampleRate;
     d7.hasDuration = false;
-    d7.sampleRate = (m_stepSize == 0) ? m_inputSampleRate/2048 : m_inputSampleRate/m_stepSize;
+    d7.sampleRate = featureRate;
     list.push_back(d7);
     m_outputChords = index++;
     
     OutputDescriptor chordnotes;
     chordnotes.identifier = "chordnotes";

     chordnotes.maxValue = 127;
     chordnotes.isQuantized = true;
     chordnotes.quantizeStep = 1;
     chordnotes.sampleType = OutputDescriptor::VariableSampleRate;
     chordnotes.hasDuration = true;
-    chordnotes.sampleRate = (m_stepSize == 0) ? m_inputSampleRate/2048 : m_inputSampleRate/m_stepSize;
+    chordnotes.sampleRate = featureRate;
     list.push_back(chordnotes);
     m_outputChordnotes = index++;
     
     OutputDescriptor d8;
     d8.identifier = "harmonicchange";

     d8.hasFixedBinCount = true;
     d8.binCount = 1;
     d8.hasKnownExtents = false;
     d8.isQuantized = false;
     d8.sampleType = OutputDescriptor::FixedSampleRate;
+    d8.sampleRate = featureRate;
     d8.hasDuration = false;
     list.push_back(d8);
     m_outputHarmonicChange = index++;
   
     OutputDescriptor loglikelihood;

     loglikelihood.hasFixedBinCount = true;
     loglikelihood.binCount = 1;
     loglikelihood.hasKnownExtents = false;
     loglikelihood.isQuantized = false;
     loglikelihood.sampleType = OutputDescriptor::FixedSampleRate;
+    loglikelihood.sampleRate = featureRate;
     loglikelihood.hasDuration = false;
     list.push_back(loglikelihood);
     m_outputLoglikelihood = index++;
   
     return list;

     vector<float> chordchange = vector<float>(tunedSpec.size(),0);
     count = 0;
 
     FeatureList chromaList;
     
-    
+    bool clipwarned = false;
 
     for (FeatureList::iterator it = tunedSpec.begin(); it != tunedSpec.end(); ++it) {
         Feature currentTunedSpec = *it; // logfreq spectrum
         Feature currentChromas; // treble and bass chromagram
 

         }
 
         vector<float> origchroma = chroma;
         chroma.insert(chroma.begin(), basschroma.begin(), basschroma.end()); // just stack the both chromas 
         currentChromas.values = chroma;
- 
+
         if (m_doNormalizeChroma > 0) {
             vector<float> chromanorm = vector<float>(3,0);			
             switch (int(m_doNormalizeChroma)) {
             case 0: // should never end up here
                 break;

         double sumchordvalue = 0;
 	        
         for (int iChord = 0; iChord < nChord; iChord++) {
             tempchordvalue = 0;
             for (int iBin = 0; iBin < 12; iBin++) {
-                tempchordvalue += m_chorddict[24 * iChord + iBin] * chroma[iBin];                
+                tempchordvalue += m_chorddict[24 * iChord + iBin] * chroma[iBin];
             }
             for (int iBin = 12; iBin < 24; iBin++) {
                 tempchordvalue += m_chorddict[24 * iChord + iBin] * chroma[iBin];
             }
             if (iChord == nChord-1) tempchordvalue *= .7;
             if (tempchordvalue < 0) tempchordvalue = 0.0;
-            tempchordvalue = pow(1.3,tempchordvalue);
-            sumchordvalue+=tempchordvalue;
+            if (tempchordvalue > 20.0) {
+                if (!clipwarned) {
+                    cerr << "WARNING: interim chroma contains extreme chord value " << tempchordvalue << ", clipping this and any others that appear" << endl;
+                    clipwarned = true;
+                }
+                tempchordvalue = 10.0;
+            }
+            tempchordvalue = pow(1.3, tempchordvalue);
+            sumchordvalue += tempchordvalue;
             currentChordSalience.push_back(tempchordvalue);
         }
         if (sumchordvalue > 0) {
             for (int iChord = 0; iChord < nChord; iChord++) {
                 currentChordSalience[iChord] /= sumchordvalue;

                 oldnotes.push_back(chordnote_feature);
             }
         }
         /* calculating simple chord change prob */            
         for (int iChord = 0; iChord < nChord; iChord++) {
-            chordchange[iFrame-1] += delta[(iFrame-1)*nChord + iChord] * log(delta[(iFrame-1)*nChord + iChord]/delta[iFrame*nChord + iChord]);
+            double num = delta[(iFrame-1) * nChord + iChord];
+            double denom = delta[iFrame * nChord + iChord];
+            double eps = 1e-7;
+            if (denom < eps) denom = eps;
+            chordchange[iFrame-1] += num * log(num / denom + eps);
         }
     }
     
     float logscale = 0;
     for (int iFrame = 0; iFrame < nFrame; ++iFrame) {

     for (int iFrame = 0; iFrame < nFrame; iFrame++) {
         Feature chordchange_feature;
         chordchange_feature.hasTimestamp = true;
         chordchange_feature.timestamp = timestamps[iFrame];
         chordchange_feature.values.push_back(chordchange[iFrame]);
-        // cerr << chordchange[iFrame] << endl;
+//        cerr << "putting value " << chordchange[iFrame] << " at time " << chordchange_feature.timestamp << endl;
         fsOut[m_outputHarmonicChange].push_back(chordchange_feature);
     }
 
     free(delta);