Implement reset functions (fixes #498)
[vamp-aubio-plugins.git] / plugins / Tempo.cpp
1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
2
3 /*
4     Vamp feature extraction plugins using Paul Brossier's Aubio library.
5
6     Centre for Digital Music, Queen Mary, University of London.
7     This file copyright 2006 Chris Cannam.
8     
9     This program is free software; you can redistribute it and/or
10     modify it under the terms of the GNU General Public License as
11     published by the Free Software Foundation; either version 2 of the
12     License, or (at your option) any later version.  See the file
13     COPYING included with this distribution for more information.
14
15 */
16
17 #include <math.h>
18 #include "Tempo.h"
19
20 using std::string;
21 using std::vector;
22 using std::cerr;
23 using std::endl;
24
25 Tempo::Tempo(float inputSampleRate) :
26     Plugin(inputSampleRate),
27     m_ibuf(0),
28     m_beat(0),
29     m_bpm(0),
30     m_onsettype(OnsetComplex),
31     m_tempo(0),
32     m_threshold(0.3),
33     m_silence(-70)
34 {
35 }
36
37 Tempo::~Tempo()
38 {
39     if (m_ibuf) del_fvec(m_ibuf);
40     if (m_beat) del_fvec(m_beat);
41     if (m_tempo) del_aubio_tempo(m_tempo);
42 }
43
44 string
45 Tempo::getIdentifier() const
46 {
47     return "aubiotempo";
48 }
49
50 string
51 Tempo::getName() const
52 {
53     return "Aubio Beat Tracker";
54 }
55
56 string
57 Tempo::getDescription() const
58 {
59     return "Estimate the musical tempo and track beat positions";
60 }
61
62 string
63 Tempo::getMaker() const
64 {
65     return "Paul Brossier (method by Matthew Davies, plugin by Chris Cannam)";
66 }
67
68 int
69 Tempo::getPluginVersion() const
70 {
71     return 2;
72 }
73
74 string
75 Tempo::getCopyright() const
76 {
77     return "GPL";
78 }
79
80 bool
81 Tempo::initialise(size_t channels, size_t stepSize, size_t blockSize)
82 {
83     if (channels != 1) {
84         std::cerr << "Tempo::initialise: channels must be 1" << std::endl;
85         return false;
86     }
87
88     m_stepSize = stepSize;
89     m_blockSize = blockSize;
90
91     m_ibuf = new_fvec(stepSize);
92     m_beat = new_fvec(2);
93     
94     m_delay = Vamp::RealTime::frame2RealTime(3 * stepSize,
95                                              lrintf(m_inputSampleRate));
96
97     reset();
98
99     return true;
100 }
101
102 void
103 Tempo::reset()
104 {
105     if (m_tempo) del_aubio_tempo(m_tempo);
106
107     m_lastBeat = Vamp::RealTime::zeroTime - m_delay - m_delay;
108
109     m_tempo = new_aubio_tempo
110         (const_cast<char *>(getAubioNameForOnsetType(m_onsettype)),
111          m_blockSize,
112          m_stepSize,
113          lrintf(m_inputSampleRate));
114
115     aubio_tempo_set_silence(m_tempo, m_silence);
116     aubio_tempo_set_threshold(m_tempo, m_threshold);
117 }
118
119 size_t
120 Tempo::getPreferredStepSize() const
121 {
122     return 512;
123 }
124
125 size_t
126 Tempo::getPreferredBlockSize() const
127 {
128     return 2 * getPreferredStepSize();
129 }
130
131 Tempo::ParameterList
132 Tempo::getParameterDescriptors() const
133 {
134     ParameterList list;
135     
136     ParameterDescriptor desc;
137     desc.identifier = "onsettype";
138     desc.name = "Onset Detection Function Type";
139     desc.minValue = 0;
140     desc.maxValue = 7;
141     desc.defaultValue = (int)OnsetComplex;
142     desc.isQuantized = true;
143     desc.quantizeStep = 1;
144     desc.valueNames.push_back("Energy Based");
145     desc.valueNames.push_back("Spectral Difference");
146     desc.valueNames.push_back("High-Frequency Content");
147     desc.valueNames.push_back("Complex Domain");
148     desc.valueNames.push_back("Phase Deviation");
149     desc.valueNames.push_back("Kullback-Liebler");
150     desc.valueNames.push_back("Modified Kullback-Liebler");
151     desc.valueNames.push_back("Spectral Flux");
152     list.push_back(desc);
153
154     desc = ParameterDescriptor();
155     desc.identifier = "peakpickthreshold";
156     desc.name = "Peak Picker Threshold";
157     desc.minValue = 0;
158     desc.maxValue = 1;
159     desc.defaultValue = 0.3;
160     desc.isQuantized = false;
161     list.push_back(desc);
162
163     desc = ParameterDescriptor();
164     desc.identifier = "silencethreshold";
165     desc.name = "Silence Threshold";
166     desc.minValue = -120;
167     desc.maxValue = 0;
168     desc.defaultValue = -70;
169     desc.unit = "dB";
170     desc.isQuantized = false;
171     list.push_back(desc);
172
173     return list;
174 }
175
176 float
177 Tempo::getParameter(std::string param) const
178 {
179     if (param == "onsettype") {
180         return m_onsettype;
181     } else if (param == "peakpickthreshold") {
182         return m_threshold;
183     } else if (param == "silencethreshold") {
184         return m_silence;
185     } else {
186         return 0.0;
187     }
188 }
189
190 void
191 Tempo::setParameter(std::string param, float value)
192 {
193     if (param == "onsettype") {
194         switch (lrintf(value)) {
195         case 0: m_onsettype = OnsetEnergy; break;
196         case 1: m_onsettype = OnsetSpecDiff; break;
197         case 2: m_onsettype = OnsetHFC; break;
198         case 3: m_onsettype = OnsetComplex; break;
199         case 4: m_onsettype = OnsetPhase; break;
200         case 5: m_onsettype = OnsetKL; break;
201         case 6: m_onsettype = OnsetMKL; break;
202         case 7: m_onsettype = OnsetSpecFlux; break;
203         }
204     } else if (param == "peakpickthreshold") {
205         m_threshold = value;
206     } else if (param == "silencethreshold") {
207         m_silence = value;
208     }
209 }
210
211 Tempo::OutputList
212 Tempo::getOutputDescriptors() const
213 {
214     OutputList list;
215
216     OutputDescriptor d;
217     d.identifier = "beats";
218     d.name = "Beats";
219     d.unit = "";
220     d.hasFixedBinCount = true;
221     d.binCount = 0;
222     d.sampleType = OutputDescriptor::VariableSampleRate;
223     d.sampleRate = 0;
224     list.push_back(d);
225
226     d.identifier = "tempo";
227     d.name = "Tempo";
228     d.unit = "bpm";
229     d.hasFixedBinCount = true;
230     d.binCount = 1;
231     d.hasKnownExtents = false;
232     d.isQuantized = false;
233     d.sampleType = OutputDescriptor::OneSamplePerStep;
234     list.push_back(d);
235
236     return list;
237 }
238
239 Tempo::FeatureSet
240 Tempo::process(const float *const *inputBuffers, Vamp::RealTime timestamp)
241 {
242     for (size_t i = 0; i < m_stepSize; ++i) {
243         fvec_write_sample(m_ibuf, inputBuffers[0][i], i);
244     }
245
246     aubio_tempo_do(m_tempo, m_ibuf, m_beat);
247
248     bool istactus = m_beat->data[0];
249
250     m_bpm = aubio_tempo_get_bpm(m_tempo);
251
252     FeatureSet returnFeatures;
253
254     if (istactus == true) {
255         if (timestamp - m_lastBeat >= m_delay) {
256             Feature onsettime;
257             onsettime.hasTimestamp = true;
258             if (timestamp < m_delay) timestamp = m_delay;
259             onsettime.timestamp = timestamp - m_delay;
260             returnFeatures[0].push_back(onsettime);
261             m_lastBeat = timestamp;
262         }
263     }
264
265     if (m_bpm >= 30 && m_bpm <= 206) {
266         Feature tempo;
267         tempo.hasTimestamp = false;
268         tempo.values.push_back(m_bpm);
269         returnFeatures[1].push_back(tempo);
270     }
271
272     return returnFeatures;
273 }
274
275 Tempo::FeatureSet
276 Tempo::getRemainingFeatures()
277 {
278     return FeatureSet();
279 }
280