comparison plugins/OnsetDetect.cpp @ 30:ff5a09e45209

* add support for adaptive whitening

 
 OnsetDetector::OnsetDetector(float inputSampleRate) :
     Vamp::Plugin(inputSampleRate),
     m_d(0),
     m_dfType(DF_COMPLEXSD),
-    m_sensitivity(50)
+    m_sensitivity(50),
+    m_whiten(false)
 {
 }
 
 OnsetDetector::~OnsetDetector()
 {

     desc.valueNames.push_back("High-Frequency Content");
     desc.valueNames.push_back("Spectral Difference");
     desc.valueNames.push_back("Phase Deviation");
     desc.valueNames.push_back("Complex Domain");
     desc.valueNames.push_back("Broadband Energy Rise");
+    desc.valueNames.push_back("Spectral Magnitude");
     list.push_back(desc);
 
     desc.identifier = "sensitivity";
     desc.name = "Onset Detector Sensitivity";
     desc.description = "Sensitivity of peak-picker for onset detection";

     desc.quantizeStep = 1;
     desc.unit = "%";
     desc.valueNames.clear();
     list.push_back(desc);
 
+    desc.identifier = "whiten";
+    desc.name = "Adaptive Whitening";
+    desc.description = "Normalize frequency bin magnitudes relative to recent peak levels";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = 0;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.unit = "";
+    list.push_back(desc);
+
     return list;
 }
 
 float
 OnsetDetector::getParameter(std::string name) const

         case DF_HFC: return 0;
         case DF_SPECDIFF: return 1;
         case DF_PHASEDEV: return 2;
         default: case DF_COMPLEXSD: return 3;
         case DF_BROADBAND: return 4;
+        case DF_POWER: return 5;
         }
     } else if (name == "sensitivity") {
         return m_sensitivity;
+    } else if (name == "whiten") {
+        return m_whiten ? 1.0 : 0.0; 
     }
     return 0.0;
 }
 
 void
 OnsetDetector::setParameter(std::string name, float value)
 {
     if (name == "dftype") {
+        int dfType = m_dfType;
         switch (lrintf(value)) {
-        case 0: m_dfType = DF_HFC; break;
-        case 1: m_dfType = DF_SPECDIFF; break;
-        case 2: m_dfType = DF_PHASEDEV; break;
-        default: case 3: m_dfType = DF_COMPLEXSD; break;
-        case 4: m_dfType = DF_BROADBAND; break;
+        case 0: dfType = DF_HFC; break;
+        case 1: dfType = DF_SPECDIFF; break;
+        case 2: dfType = DF_PHASEDEV; break;
+        default: case 3: dfType = DF_COMPLEXSD; break;
+        case 4: dfType = DF_BROADBAND; break;
+        case 5: dfType = DF_POWER; break;
         }
+        if (dfType == m_dfType) return;
+        m_dfType = dfType;
+        m_program = "";
     } else if (name == "sensitivity") {
+        if (m_sensitivity == value) return;
         m_sensitivity = value;
+        m_program = "";
+    } else if (name == "whiten") {
+        if (m_whiten == (value > 0.5)) return;
+        m_whiten = (value > 0.5);
+        m_program = "";
     }
 }
 
 OnsetDetector::ProgramList
 OnsetDetector::getPrograms() const
 {
     ProgramList programs;
+    programs.push_back("");
     programs.push_back("General purpose");
     programs.push_back("Soft onsets");
     programs.push_back("Percussive onsets");
     return programs;
 }
 
 std::string
 OnsetDetector::getCurrentProgram() const
 {
-    if (m_program == "") return "General purpose";
+    if (m_program == "") return "";
     else return m_program;
 }
 
 void
 OnsetDetector::selectProgram(std::string program)
 {
     if (program == "General purpose") {
         setParameter("dftype", 3); // complex
         setParameter("sensitivity", 50);
+        setParameter("whiten", 0);
     } else if (program == "Soft onsets") {
         setParameter("dftype", 2); // phase deviation
         setParameter("sensitivity", 70);
+        setParameter("whiten", 0);
     } else if (program == "Percussive onsets") {
         setParameter("dftype", 4); // broadband energy rise
         setParameter("sensitivity", 40);
+        setParameter("whiten", 0);
     } else {
         return;
     }
     m_program = program;
 }

     dfConfig.DFType = m_dfType;
     dfConfig.stepSecs = float(stepSize) / m_inputSampleRate;
     dfConfig.stepSize = stepSize;
     dfConfig.frameLength = blockSize;
     dfConfig.dbRise = 6.0 - m_sensitivity / 16.6667;
+    dfConfig.adaptiveWhitening = m_whiten;
+    dfConfig.whiteningRelaxCoeff = -1;
+    dfConfig.whiteningFloor = -1;
     
     m_d = new OnsetDetectorData(dfConfig);
     return true;
 }
 

 	    (frame, lrintf(m_inputSampleRate));
 
 	returnFeatures[0].push_back(feature); // onsets are output 0
     }
 
-    for (int i = 0; i < ppParams.length; ++i) {
+    for (unsigned int i = 0; i < ppParams.length; ++i) {
         
         Feature feature;
 //        feature.hasTimestamp = false;
         feature.hasTimestamp = true;
 	size_t frame = i * m_d->dfConfig.stepSize;