c@27: /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
c@27: 
c@27: /*
c@27:     QM Vamp Plugin Set
c@27: 
c@27:     Centre for Digital Music, Queen Mary, University of London.
c@27:     All rights reserved.
c@27: */
c@27: 
c@27: #include "BeatTrack.h"
c@27: 
c@27: #include <dsp/onsets/DetectionFunction.h>
c@27: #include <dsp/onsets/PeakPicking.h>
c@27: #include <dsp/tempotracking/TempoTrack.h>
c@27: 
c@27: using std::string;
c@27: using std::vector;
c@27: using std::cerr;
c@27: using std::endl;
c@27: 
c@27: float BeatTracker::m_stepSecs = 0.01161;
c@27: 
c@27: class BeatTrackerData
c@27: {
c@27: public:
c@27:     BeatTrackerData(const DFConfig &config) : dfConfig(config) {
c@27: 	df = new DetectionFunction(config);
c@27:     }
c@27:     ~BeatTrackerData() {
c@27: 	delete df;
c@27:     }
c@27:     void reset() {
c@27: 	delete df;
c@27: 	df = new DetectionFunction(dfConfig);
c@27: 	dfOutput.clear();
c@85:         origin = Vamp::RealTime::zeroTime;
c@27:     }
c@27: 
c@27:     DFConfig dfConfig;
c@27:     DetectionFunction *df;
c@27:     vector<double> dfOutput;
c@85:     Vamp::RealTime origin;
c@27: };
c@27:     
c@27: 
c@27: BeatTracker::BeatTracker(float inputSampleRate) :
c@27:     Vamp::Plugin(inputSampleRate),
c@27:     m_d(0),
c@30:     m_dfType(DF_COMPLEXSD),
c@30:     m_whiten(false)
c@27: {
c@27: }
c@27: 
c@27: BeatTracker::~BeatTracker()
c@27: {
c@27:     delete m_d;
c@27: }
c@27: 
c@27: string
c@27: BeatTracker::getIdentifier() const
c@27: {
c@27:     return "qm-tempotracker";
c@27: }
c@27: 
c@27: string
c@27: BeatTracker::getName() const
c@27: {
c@27:     return "Tempo and Beat Tracker";
c@27: }
c@27: 
c@27: string
c@27: BeatTracker::getDescription() const
c@27: {
c@27:     return "Estimate beat locations and tempo";
c@27: }
c@27: 
c@27: string
c@27: BeatTracker::getMaker() const
c@27: {
c@50:     return "Queen Mary, University of London";
c@27: }
c@27: 
c@27: int
c@27: BeatTracker::getPluginVersion() const
c@27: {
c@27:     return 3;
c@27: }
c@27: 
c@27: string
c@27: BeatTracker::getCopyright() const
c@27: {
c@50:     return "Plugin by Christian Landone and Matthew Davies.  Copyright (c) 2006-2008 QMUL - All Rights Reserved";
c@27: }
c@27: 
c@27: BeatTracker::ParameterList
c@27: BeatTracker::getParameterDescriptors() const
c@27: {
c@27:     ParameterList list;
c@27: 
c@27:     ParameterDescriptor desc;
c@27:     desc.identifier = "dftype";
c@27:     desc.name = "Onset Detection Function Type";
c@27:     desc.description = "Method used to calculate the onset detection function";
c@27:     desc.minValue = 0;
c@31:     desc.maxValue = 4;
c@27:     desc.defaultValue = 3;
c@27:     desc.isQuantized = true;
c@27:     desc.quantizeStep = 1;
c@27:     desc.valueNames.push_back("High-Frequency Content");
c@27:     desc.valueNames.push_back("Spectral Difference");
c@27:     desc.valueNames.push_back("Phase Deviation");
c@27:     desc.valueNames.push_back("Complex Domain");
c@27:     desc.valueNames.push_back("Broadband Energy Rise");
c@27:     list.push_back(desc);
c@27: 
c@30:     desc.identifier = "whiten";
c@30:     desc.name = "Adaptive Whitening";
c@30:     desc.description = "Normalize frequency bin magnitudes relative to recent peak levels";
c@30:     desc.minValue = 0;
c@30:     desc.maxValue = 1;
c@30:     desc.defaultValue = 0;
c@30:     desc.isQuantized = true;
c@30:     desc.quantizeStep = 1;
c@30:     desc.unit = "";
c@30:     desc.valueNames.clear();
c@30:     list.push_back(desc);
c@30: 
c@27:     return list;
c@27: }
c@27: 
c@27: float
c@27: BeatTracker::getParameter(std::string name) const
c@27: {
c@27:     if (name == "dftype") {
c@27:         switch (m_dfType) {
c@27:         case DF_HFC: return 0;
c@27:         case DF_SPECDIFF: return 1;
c@27:         case DF_PHASEDEV: return 2;
c@27:         default: case DF_COMPLEXSD: return 3;
c@27:         case DF_BROADBAND: return 4;
c@27:         }
c@30:     } else if (name == "whiten") {
c@30:         return m_whiten ? 1.0 : 0.0; 
c@27:     }
c@27:     return 0.0;
c@27: }
c@27: 
c@27: void
c@27: BeatTracker::setParameter(std::string name, float value)
c@27: {
c@27:     if (name == "dftype") {
c@27:         switch (lrintf(value)) {
c@27:         case 0: m_dfType = DF_HFC; break;
c@27:         case 1: m_dfType = DF_SPECDIFF; break;
c@27:         case 2: m_dfType = DF_PHASEDEV; break;
c@27:         default: case 3: m_dfType = DF_COMPLEXSD; break;
c@27:         case 4: m_dfType = DF_BROADBAND; break;
c@27:         }
c@30:     } else if (name == "whiten") {
c@30:         m_whiten = (value > 0.5);
c@27:     }
c@27: }
c@27: 
c@27: bool
c@27: BeatTracker::initialise(size_t channels, size_t stepSize, size_t blockSize)
c@27: {
c@27:     if (m_d) {
c@27: 	delete m_d;
c@27: 	m_d = 0;
c@27:     }
c@27: 
c@27:     if (channels < getMinChannelCount() ||
c@27: 	channels > getMaxChannelCount()) {
c@27:         std::cerr << "BeatTracker::initialise: Unsupported channel count: "
c@27:                   << channels << std::endl;
c@27:         return false;
c@27:     }
c@27: 
c@28:     if (stepSize != getPreferredStepSize()) {
c@28:         std::cerr << "ERROR: BeatTracker::initialise: Unsupported step size for this sample rate: "
c@28:                   << stepSize << " (wanted " << (getPreferredStepSize()) << ")" << std::endl;
c@27:         return false;
c@27:     }
c@27: 
c@28:     if (blockSize != getPreferredBlockSize()) {
c@29:         std::cerr << "WARNING: BeatTracker::initialise: Sub-optimal block size for this sample rate: "
c@28:                   << blockSize << " (wanted " << getPreferredBlockSize() << ")" << std::endl;
c@28: //        return false;
c@27:     }
c@27: 
c@27:     DFConfig dfConfig;
c@27:     dfConfig.DFType = m_dfType;
c@27:     dfConfig.stepSecs = float(stepSize) / m_inputSampleRate;
c@27:     dfConfig.stepSize = stepSize;
c@27:     dfConfig.frameLength = blockSize;
c@27:     dfConfig.dbRise = 3;
c@30:     dfConfig.adaptiveWhitening = m_whiten;
c@30:     dfConfig.whiteningRelaxCoeff = -1;
c@30:     dfConfig.whiteningFloor = -1;
c@27:     
c@27:     m_d = new BeatTrackerData(dfConfig);
c@27:     return true;
c@27: }
c@27: 
c@27: void
c@27: BeatTracker::reset()
c@27: {
c@27:     if (m_d) m_d->reset();
c@27: }
c@27: 
c@27: size_t
c@27: BeatTracker::getPreferredStepSize() const
c@27: {
c@27:     size_t step = size_t(m_inputSampleRate * m_stepSecs + 0.0001);
c@27: //    std::cerr << "BeatTracker::getPreferredStepSize: input sample rate is " << m_inputSampleRate << ", step size is " << step << std::endl;
c@27:     return step;
c@27: }
c@27: 
c@27: size_t
c@27: BeatTracker::getPreferredBlockSize() const
c@27: {
c@28:     size_t theoretical = getPreferredStepSize() * 2;
c@28: 
c@52:     // I think this is not necessarily going to be a power of two, and
c@52:     // the host might have a problem with that, but I'm not sure we
c@52:     // can do much about it here
c@28:     return theoretical;
c@27: }
c@27: 
c@27: BeatTracker::OutputList
c@27: BeatTracker::getOutputDescriptors() const
c@27: {
c@27:     OutputList list;
c@27: 
c@27:     OutputDescriptor beat;
c@27:     beat.identifier = "beats";
c@27:     beat.name = "Beats";
c@27:     beat.description = "Estimated metrical beat locations";
c@27:     beat.unit = "";
c@27:     beat.hasFixedBinCount = true;
c@27:     beat.binCount = 0;
c@27:     beat.sampleType = OutputDescriptor::VariableSampleRate;
c@27:     beat.sampleRate = 1.0 / m_stepSecs;
c@27: 
c@27:     OutputDescriptor df;
c@27:     df.identifier = "detection_fn";
c@27:     df.name = "Onset Detection Function";
c@27:     df.description = "Probability function of note onset likelihood";
c@27:     df.unit = "";
c@27:     df.hasFixedBinCount = true;
c@27:     df.binCount = 1;
c@27:     df.hasKnownExtents = false;
c@27:     df.isQuantized = false;
c@27:     df.sampleType = OutputDescriptor::OneSamplePerStep;
c@27: 
c@27:     OutputDescriptor tempo;
c@27:     tempo.identifier = "tempo";
c@27:     tempo.name = "Tempo";
c@27:     tempo.description = "Locked tempo estimates";
c@27:     tempo.unit = "bpm";
c@27:     tempo.hasFixedBinCount = true;
c@27:     tempo.binCount = 1;
c@31:     tempo.hasKnownExtents = false;
c@31:     tempo.isQuantized = false;
c@27:     tempo.sampleType = OutputDescriptor::VariableSampleRate;
c@27:     tempo.sampleRate = 1.0 / m_stepSecs;
c@27: 
c@27:     list.push_back(beat);
c@27:     list.push_back(df);
c@27:     list.push_back(tempo);
c@27: 
c@27:     return list;
c@27: }
c@27: 
c@27: BeatTracker::FeatureSet
c@27: BeatTracker::process(const float *const *inputBuffers,
c@85:                      Vamp::RealTime timestamp)
c@27: {
c@27:     if (!m_d) {
c@27: 	cerr << "ERROR: BeatTracker::process: "
c@27: 	     << "BeatTracker has not been initialised"
c@27: 	     << endl;
c@27: 	return FeatureSet();
c@27:     }
c@27: 
c@27:     size_t len = m_d->dfConfig.frameLength / 2;
c@27: 
c@27:     double *magnitudes = new double[len];
c@27:     double *phases = new double[len];
c@27: 
c@27:     // We only support a single input channel
c@27: 
c@27:     for (size_t i = 0; i < len; ++i) {
c@27: 
c@27:         magnitudes[i] = sqrt(inputBuffers[0][i*2  ] * inputBuffers[0][i*2  ] +
c@27:                              inputBuffers[0][i*2+1] * inputBuffers[0][i*2+1]);
c@27: 
c@27: 	phases[i] = atan2(-inputBuffers[0][i*2+1], inputBuffers[0][i*2]);
c@27:     }
c@27: 
c@27:     double output = m_d->df->process(magnitudes, phases);
c@27: 
c@27:     delete[] magnitudes;
c@27:     delete[] phases;
c@27: 
c@85:     if (m_d->dfOutput.empty()) m_d->origin = timestamp;
c@85: 
c@27:     m_d->dfOutput.push_back(output);
c@27: 
c@27:     FeatureSet returnFeatures;
c@27: 
c@27:     Feature feature;
c@27:     feature.hasTimestamp = false;
c@27:     feature.values.push_back(output);
c@27: 
c@27:     returnFeatures[1].push_back(feature); // detection function is output 1
c@27:     return returnFeatures;
c@27: }
c@27: 
c@27: BeatTracker::FeatureSet
c@27: BeatTracker::getRemainingFeatures()
c@27: {
c@27:     if (!m_d) {
c@27: 	cerr << "ERROR: BeatTracker::getRemainingFeatures: "
c@27: 	     << "BeatTracker has not been initialised"
c@27: 	     << endl;
c@27: 	return FeatureSet();
c@27:     }
c@27: 
c@27:     double aCoeffs[] = { 1.0000, -0.5949, 0.2348 };
c@27:     double bCoeffs[] = { 0.1600,  0.3200, 0.1600 };
c@27: 
c@27:     TTParams ttParams;
c@27:     ttParams.winLength = 512;
c@27:     ttParams.lagLength = 128;
c@27:     ttParams.LPOrd = 2;
c@27:     ttParams.LPACoeffs = aCoeffs;
c@27:     ttParams.LPBCoeffs = bCoeffs;
c@27:     ttParams.alpha = 9;
c@27:     ttParams.WinT.post = 8;
c@27:     ttParams.WinT.pre = 7;
c@27: 
c@27:     TempoTrack tempoTracker(ttParams);
c@27: 
c@27:     vector<double> tempos;
c@27:     vector<int> beats = tempoTracker.process(m_d->dfOutput, &tempos);
c@27: 
c@27:     FeatureSet returnFeatures;
c@27: 
c@27:     char label[100];
c@27: 
c@27:     for (size_t i = 0; i < beats.size(); ++i) {
c@27: 
c@27: 	size_t frame = beats[i] * m_d->dfConfig.stepSize;
c@27: 
c@27: 	Feature feature;
c@27: 	feature.hasTimestamp = true;
c@85: 	feature.timestamp = m_d->origin + Vamp::RealTime::frame2RealTime
c@27: 	    (frame, lrintf(m_inputSampleRate));
c@27: 
c@27: 	float bpm = 0.0;
c@27: 	int frameIncrement = 0;
c@27: 
c@27: 	if (i < beats.size() - 1) {
c@27: 
c@27: 	    frameIncrement = (beats[i+1] - beats[i]) * m_d->dfConfig.stepSize;
c@27: 
c@27: 	    // one beat is frameIncrement frames, so there are
c@27: 	    // samplerate/frameIncrement bps, so
c@27: 	    // 60*samplerate/frameIncrement bpm
c@27: 
c@27: 	    if (frameIncrement > 0) {
c@27: 		bpm = (60.0 * m_inputSampleRate) / frameIncrement;
c@27: 		bpm = int(bpm * 100.0 + 0.5) / 100.0;
c@27:                 sprintf(label, "%.2f bpm", bpm);
c@27:                 feature.label = label;
c@27: 	    }
c@27: 	}
c@27: 
c@27: 	returnFeatures[0].push_back(feature); // beats are output 0
c@27:     }
c@27: 
c@27:     double prevTempo = 0.0;
c@27: 
c@27:     for (size_t i = 0; i < tempos.size(); ++i) {
c@27: 
c@27:         size_t frame = i * m_d->dfConfig.stepSize * ttParams.lagLength;
c@27: 
c@27: //        std::cerr << "unit " << i << ", step size " << m_d->dfConfig.stepSize << ", hop " << ttParams.lagLength << ", frame = " << frame << std::endl;
c@27:         
c@27:         if (tempos[i] > 1 && int(tempos[i] * 100) != int(prevTempo * 100)) {
c@27:             Feature feature;
c@27:             feature.hasTimestamp = true;
c@85:             feature.timestamp = m_d->origin + Vamp::RealTime::frame2RealTime
c@27:                 (frame, lrintf(m_inputSampleRate));
c@27:             feature.values.push_back(tempos[i]);
c@27:             sprintf(label, "%.2f bpm", tempos[i]);
c@27:             feature.label = label;
c@27:             returnFeatures[2].push_back(feature); // tempo is output 2
c@27:         }
c@27:     }
c@27: 
c@27:     return returnFeatures;
c@27: }
c@27: