comparison plugins/BarBeatTrack.cpp @ 146:c4837ed2eeb1

Merge mepd_new_params branch

 
 class BarBeatTrackerData
 {
 public:
     BarBeatTrackerData(float rate, const DFConfig &config) : dfConfig(config) {
-	df = new DetectionFunction(config);
+    df = new DetectionFunction(config);
         // decimation factor aims at resampling to c. 3KHz; must be power of 2
         int factor = MathUtilities::nextPowerOfTwo(rate / 3000);
 //        std::cerr << "BarBeatTrackerData: factor = " << factor << std::endl;
         downBeat = new DownBeat(rate, factor, config.stepSize);
     }
     ~BarBeatTrackerData() {
-	delete df;
+    delete df;
         delete downBeat;
     }
     void reset() {
-	delete df;
-	df = new DetectionFunction(dfConfig);
-	dfOutput.clear();
+    delete df;
+    df = new DetectionFunction(dfConfig);
+    dfOutput.clear();
         downBeat->resetAudioBuffer();
         origin = Vamp::RealTime::zeroTime;
     }
 
     DFConfig dfConfig;
     DetectionFunction *df;
     DownBeat *downBeat;
     vector<double> dfOutput;
     Vamp::RealTime origin;
 };
-    
+
 
 BarBeatTracker::BarBeatTracker(float inputSampleRate) :
     Vamp::Plugin(inputSampleRate),
     m_d(0),
-    m_bpb(4)
+    m_bpb(4),
+    m_alpha(0.9), 			// changes are as per the BeatTrack.cpp
+    m_tightness(4.),		// changes are as per the BeatTrack.cpp
+    m_inputtempo(120.),		// changes are as per the BeatTrack.cpp
+    m_constraintempo(false) // changes are as per the BeatTrack.cpp
 {
 }
 
 BarBeatTracker::~BarBeatTracker()
 {

 }
 
 int
 BarBeatTracker::getPluginVersion() const
 {
-    return 2;
+    return 3;
 }
 
 string
 BarBeatTracker::getCopyright() const
 {

     desc.defaultValue = 4;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     list.push_back(desc);
 
+    // changes are as per the BeatTrack.cpp
+    //Alpha Parameter of Beat Tracker
+    desc.identifier = "alpha";
+    desc.name = "Alpha";
+    desc.description = "Inertia - Flexibility Trade Off";
+    desc.minValue =  0.1;
+    desc.maxValue = 0.99;
+    desc.defaultValue = 0.90;
+    desc.unit = "";
+    desc.isQuantized = false;
+    list.push_back(desc);
+
+
+    // changes are as per the BeatTrack.cpp
+    //Tightness Parameter of Beat Tracker
+    desc.identifier = "tightness";
+    desc.name = "Tightness";
+    desc.description = "Inertia - Flexibility Trade Off 2";
+    desc.minValue =  3;
+    desc.maxValue = 7;
+    desc.defaultValue = 4;
+    desc.unit = "";
+    desc.isQuantized = true;
+    list.push_back(desc);
+
+    // changes are as per the BeatTrack.cpp
+    //User input tempo
+    desc.identifier = "inputtempo";
+    desc.name = "InputTempo";
+    desc.description = "User defined Tempo";
+    desc.minValue =  50;
+    desc.maxValue = 250;
+    desc.defaultValue = 120;
+    desc.unit = "BPM";
+    desc.isQuantized = true;
+    list.push_back(desc);
+
+    // changes are as per the BeatTrack.cpp
+    desc.identifier = "constraintempo";
+    desc.name = "Constrain Tempo";
+    desc.description = "Constrain tempo to use Gaussian weighting";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = 0;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.unit = "";
+    desc.valueNames.clear();
+    list.push_back(desc);
+
+
     return list;
 }
 
 float
 BarBeatTracker::getParameter(std::string name) const
 {
-    if (name == "bpb") return m_bpb;
+    if (name == "bpb") {
+        return m_bpb;
+    } else if (name == "alpha") {
+        return m_alpha;
+    } else if (name == "tightness") {
+        return m_tightness;
+    }  else if (name == "inputtempo") {
+        return m_inputtempo;
+    }  else if (name == "constraintempo") {
+        return m_constraintempo ? 1.0 : 0.0;
+    }
     return 0.0;
 }
 
 void
 BarBeatTracker::setParameter(std::string name, float value)
 {
-    if (name == "bpb") m_bpb = lrintf(value);
+    if (name == "bpb") {
+        m_bpb = lrintf(value);
+    } else if (name == "alpha") {
+        m_alpha = value;
+    } else if (name == "tightness") {
+        m_tightness = value;
+    } else if (name == "inputtempo") {
+        m_inputtempo = value;
+    } else if (name == "constraintempo") {
+        m_constraintempo = (value > 0.5);
+    }
 }
 
 bool
 BarBeatTracker::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {
     if (m_d) {
-	delete m_d;
-	m_d = 0;
+    delete m_d;
+    m_d = 0;
     }
 
     if (channels < getMinChannelCount() ||
-	channels > getMaxChannelCount()) {
+    channels > getMaxChannelCount()) {
         std::cerr << "BarBeatTracker::initialise: Unsupported channel count: "
                   << channels << std::endl;
         return false;
     }
 

     dfConfig.frameLength = blockSize;
     dfConfig.dbRise = 3;
     dfConfig.adaptiveWhitening = false;
     dfConfig.whiteningRelaxCoeff = -1;
     dfConfig.whiteningFloor = -1;
-    
+
     m_d = new BarBeatTrackerData(m_inputSampleRate, dfConfig);
     m_d->downBeat->setBeatsPerBar(m_bpb);
     return true;
 }
 

 BarBeatTracker::FeatureSet
 BarBeatTracker::process(const float *const *inputBuffers,
                         Vamp::RealTime timestamp)
 {
     if (!m_d) {
-	cerr << "ERROR: BarBeatTracker::process: "
-	     << "BarBeatTracker has not been initialised"
-	     << endl;
-	return FeatureSet();
+    cerr << "ERROR: BarBeatTracker::process: "
+         << "BarBeatTracker has not been initialised"
+         << endl;
+    return FeatureSet();
     }
 
     // We use time domain input, because DownBeat requires it -- so we
     // use the time-domain version of DetectionFunction::process which
     // does its own FFT.  It requires doubles as input, so we need to

 
 BarBeatTracker::FeatureSet
 BarBeatTracker::getRemainingFeatures()
 {
     if (!m_d) {
-	cerr << "ERROR: BarBeatTracker::getRemainingFeatures: "
-	     << "BarBeatTracker has not been initialised"
-	     << endl;
-	return FeatureSet();
+    cerr << "ERROR: BarBeatTracker::getRemainingFeatures: "
+         << "BarBeatTracker has not been initialised"
+         << endl;
+    return FeatureSet();
     }
 
     return barBeatTrack();
 }
 

         beatPeriod.push_back(0.0);
     }
     if (df.empty()) return FeatureSet();
 
     TempoTrackV2 tt(m_inputSampleRate, m_d->dfConfig.stepSize);
-    tt.calculateBeatPeriod(df, beatPeriod, tempi);
+
+    // changes are as per the BeatTrack.cpp - allow m_inputtempo and m_constraintempo to be set be the user
+    tt.calculateBeatPeriod(df, beatPeriod, tempi, m_inputtempo, m_constraintempo);
 
     vector<double> beats;
-    tt.calculateBeats(df, beatPeriod, beats);
+    // changes are as per the BeatTrack.cpp - allow m_alpha and m_tightness to be set be the user
+    tt.calculateBeats(df, beatPeriod, beats, m_alpha, m_tightness);
+
+ //   tt.calculateBeatPeriod(df, beatPeriod, tempi, 0., 0); // use default parameters
+
+  //  vector<double> beats;
+   // tt.calculateBeats(df, beatPeriod, beats, 0.9, 4.); // use default parameters until i fix this plugin too
 
     vector<int> downbeats;
     size_t downLength = 0;
     const float *downsampled = m_d->downBeat->getBufferedAudio(downLength);
     m_d->downBeat->findDownBeats(downsampled, downLength, beats, downbeats);

     vector<double> beatsd;
     m_d->downBeat->getBeatSD(beatsd);
 
 //    std::cerr << "BarBeatTracker: found downbeats at: ";
 //    for (int i = 0; i < downbeats.size(); ++i) std::cerr << downbeats[i] << " " << std::endl;
-                                 
+
     FeatureSet returnFeatures;
 
     char label[20];
 
     int dbi = 0;

         if (beat == m_bpb) beat = 0;
     }
 
     for (size_t i = 0; i < beats.size(); ++i) {
 
-	size_t frame = beats[i] * m_d->dfConfig.stepSize;
+    size_t frame = beats[i] * m_d->dfConfig.stepSize;
 
         if (dbi < downbeats.size() && i == downbeats[dbi]) {
             beat = 0;
             ++bar;
             ++dbi;

         // outputs are:
         //
         // 0 -> beats
         // 1 -> bars
         // 2 -> beat counter function
-        
-	Feature feature;
-	feature.hasTimestamp = true;
-	feature.timestamp = m_d->origin + Vamp::RealTime::frame2RealTime
-	    (frame, lrintf(m_inputSampleRate));
+
+    Feature feature;
+    feature.hasTimestamp = true;
+    feature.timestamp = m_d->origin + Vamp::RealTime::frame2RealTime
+        (frame, lrintf(m_inputSampleRate));
 
         sprintf(label, "%d", beat + 1);
         feature.label = label;
-	returnFeatures[0].push_back(feature); // labelled beats
+    returnFeatures[0].push_back(feature); // labelled beats
 
         feature.values.push_back(beat + 1);
         returnFeatures[2].push_back(feature); // beat function
 
         if (i > 0 && i <= beatsd.size()) {