comparison plugins/KeyDetect.cpp @ 242:3e882621e2dd

Add "rapid" option (frame overlap factor)

 
 #include "KeyDetect.h"
 
 using std::string;
 using std::vector;
-//using std::cerr;
-using std::endl;
 
 #include <cmath>
 
 
 // Order for circle-of-5ths plotting

     Plugin(inputSampleRate),
     m_stepSize(0),
     m_blockSize(0),
     m_tuningFrequency(440),
     m_length(10),
+    m_rapid(true),
     m_getKeyMode(0),
     m_inputFrame(0),
     m_prevKey(-1)
 {
 }

 }
 
 string
 KeyDetector::getCopyright() const
 {
-    return "Plugin by Katy Noland and Christian Landone.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+    return "Plugin by Katy Noland and Christian Landone.  Copyright (c) 2006-2019 QMUL - All Rights Reserved";
 }
 
 KeyDetector::ParameterList
 KeyDetector::getParameterDescriptors() const
 {

     desc.defaultValue = 10;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     list.push_back(desc);
 
+    desc.identifier = "rapid";
+    desc.name = "Rapid";
+    desc.unit = "";
+    desc.description = "Sample intervals without overlap, for speed";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = 1;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
     return list;
 }
 
 float
 KeyDetector::getParameter(std::string param) const

     if (param == "tuning") {
         return m_tuningFrequency;
     }
     if (param == "length") {
         return m_length;
+    }
+    if (param == "rapid") {
+        return m_rapid ? 1.f : 0.f;
     }
     std::cerr << "WARNING: KeyDetector::getParameter: unknown parameter \""
               << param << "\"" << std::endl;
     return 0.0;
 }

 {
     if (param == "tuning") {
         m_tuningFrequency = value;
     } else if (param == "length") {
         m_length = int(value + 0.1);
+    } else if (param == "rapid") {
+        m_rapid = (value > 0.5);
     } else {
         std::cerr << "WARNING: KeyDetector::setParameter: unknown parameter \""
                   << param << "\"" << std::endl;
     }
+
+    // force recalculate:
+    m_stepSize = 0;
+    m_blockSize = 0;
+}
+
+GetKeyMode::Config
+KeyDetector::getConfig() const
+{
+    GetKeyMode::Config config(m_inputSampleRate, m_tuningFrequency);
+    config.hpcpAverage = m_length;
+    config.medianAverage = m_length;
+    config.frameOverlapFactor = (m_rapid ? 1 : 8);
+    config.decimationFactor = 8;
+    return config;
 }
 
 bool
 KeyDetector::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {

     }
 
     if (channels < getMinChannelCount() ||
 	channels > getMaxChannelCount()) return false;
 
-    m_getKeyMode = new GetKeyMode(int(m_inputSampleRate + 0.1),
-                                  m_tuningFrequency,
-                                  m_length, m_length);
+    m_getKeyMode = new GetKeyMode(getConfig());
 
     m_stepSize = m_getKeyMode->getHopSize();
     m_blockSize = m_getKeyMode->getBlockSize();
 
     if (stepSize != m_stepSize || blockSize != m_blockSize) {

 void
 KeyDetector::reset()
 {
     if (m_getKeyMode) {
         delete m_getKeyMode;
-        m_getKeyMode = new GetKeyMode(int(m_inputSampleRate + 0.1),
-                                      m_tuningFrequency,
-                                      m_length, m_length);
+        m_getKeyMode = new GetKeyMode(getConfig());
     }
 
     if (m_inputFrame) {
         for( unsigned int i = 0; i < m_blockSize; i++ ) {
             m_inputFrame[ i ] = 0.0;

     for ( unsigned int i = 0 ; i < m_blockSize; i++ ) {
         m_inputFrame[i] = (double)inputBuffers[0][i];
     }
 
     int key = m_getKeyMode->process(m_inputFrame);
-    bool minor = m_getKeyMode->isModeMinor(key);
+
     int tonic = key;
     if (tonic > 12) tonic -= 12;
 
     int prevTonic = m_prevKey;
     if (prevTonic > 12) prevTonic -= 12;
+
+    bool minor = (key > 12);
+    bool prevMinor = (m_prevKey > 12);
 
     if (m_first || (tonic != prevTonic)) {
         Feature feature;
         feature.hasTimestamp = true;
         feature.timestamp = now;
         feature.values.push_back((float)tonic);
         feature.label = getKeyName(tonic, minor, false);
         returnFeatures[0].push_back(feature); // tonic
     }
 
-    if (m_first || (minor != (m_getKeyMode->isModeMinor(m_prevKey)))) {
+    if (m_first || (minor != prevMinor)) {
         Feature feature;
         feature.hasTimestamp = true;
         feature.timestamp = now;
         feature.values.push_back(minor ? 1.f : 0.f);
         feature.label = (minor ? "Minor" : "Major");

 KeyDetector::getRemainingFeatures()
 {
     return FeatureSet();
 }
 
-
 size_t
 KeyDetector::getPreferredStepSize() const
 {
     if (!m_stepSize) {
-        GetKeyMode gkm(int(m_inputSampleRate + 0.1),
-                       m_tuningFrequency, m_length, m_length);
+        GetKeyMode gkm(getConfig());
         m_stepSize = gkm.getHopSize();
         m_blockSize = gkm.getBlockSize();
     }
     return m_stepSize;
 }
 
 size_t
 KeyDetector::getPreferredBlockSize() const
 {
     if (!m_blockSize) {
-        GetKeyMode gkm(int(m_inputSampleRate + 0.1),
-                       m_tuningFrequency, m_length, m_length);
+        GetKeyMode gkm(getConfig());
         m_stepSize = gkm.getHopSize();
         m_blockSize = gkm.getBlockSize();
     }
     return m_blockSize;
 }