4f96b0529da16f9e66cfb209035d8e048146fd8c
[vamp-aubio-plugins.git] / plugins / Notes.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-2008 Chris Cannam and QMUL.
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 "Notes.h"
19
20 #include <algorithm>
21
22 using std::string;
23 using std::vector;
24 using std::cerr;
25 using std::endl;
26
27 Notes::Notes(float inputSampleRate) :
28     Plugin(inputSampleRate),
29     m_ibuf(0),
30     m_onset(0),
31     m_pitch(0),
32     m_onsetdet(0),
33     m_onsettype(OnsetComplex),
34     m_pitchdet(0),
35     m_pitchtype(PitchYinFFT),
36     m_threshold(0.3),
37     m_silence(-70),
38     m_minioi(4),
39     m_median(6),
40     m_minpitch(27),
41     m_maxpitch(95),
42     m_wrapRange(false),
43     m_avoidLeaps(false),
44     m_prevPitch(-1)
45 {
46 }
47
48 Notes::~Notes()
49 {
50     if (m_onsetdet) del_aubio_onset(m_onsetdet);
51     if (m_pitchdet) del_aubio_pitch(m_pitchdet);
52     if (m_ibuf) del_fvec(m_ibuf);
53     if (m_onset) del_fvec(m_onset);
54     if (m_pitch) del_fvec(m_pitch);
55 }
56
57 string
58 Notes::getIdentifier() const
59 {
60     return "aubionotes";
61 }
62
63 string
64 Notes::getName() const
65 {
66     return "Aubio Note Tracker";
67 }
68
69 string
70 Notes::getDescription() const
71 {
72     return "Estimate note onset positions, pitches and durations";
73 }
74
75 string
76 Notes::getMaker() const
77 {
78     return "Paul Brossier (plugin by Chris Cannam)";
79 }
80
81 int
82 Notes::getPluginVersion() const
83 {
84     return 4;
85 }
86
87 string
88 Notes::getCopyright() const
89 {
90     return "GPL";
91 }
92
93 bool
94 Notes::initialise(size_t channels, size_t stepSize, size_t blockSize)
95 {
96     if (channels != 1) {
97         std::cerr << "Notes::initialise: channels must be 1" << std::endl;
98         return false;
99     }
100
101     m_stepSize = stepSize;
102     m_blockSize = blockSize;
103
104     m_ibuf = new_fvec(stepSize);
105     m_onset = new_fvec(1);
106     m_pitch = new_fvec(1);
107
108     m_onsetdet = new_aubio_onset
109         (const_cast<char *>(getAubioNameForOnsetType(m_onsettype)),
110          blockSize,
111          stepSize,
112          lrintf(m_inputSampleRate));
113     
114     aubio_onset_set_threshold(m_onsetdet, m_threshold);
115     aubio_onset_set_silence(m_onsetdet, m_silence);
116     aubio_onset_set_minioi(m_onsetdet, m_minioi);
117
118     m_pitchdet = new_aubio_pitch
119         (const_cast<char *>(getAubioNameForPitchType(m_pitchtype)),
120          blockSize,
121          stepSize,
122          lrintf(m_inputSampleRate));
123
124     aubio_pitch_set_unit(m_pitchdet, "freq");
125
126     m_count = 0;
127     m_delay = Vamp::RealTime::frame2RealTime((4 + m_median) * m_stepSize,
128                                        lrintf(m_inputSampleRate));
129     m_currentOnset = Vamp::RealTime::zeroTime;
130     m_haveCurrent = false;
131     m_prevPitch = -1;
132
133     return true;
134 }
135
136 void
137 Notes::reset()
138 {
139 }
140
141 size_t
142 Notes::getPreferredStepSize() const
143 {
144     return 512;
145 }
146
147 size_t
148 Notes::getPreferredBlockSize() const
149 {
150     return 4 * getPreferredStepSize();
151 }
152
153 Notes::ParameterList
154 Notes::getParameterDescriptors() const
155 {
156     ParameterList list;
157     
158     ParameterDescriptor desc;
159     desc.identifier = "onsettype";
160     desc.name = "Onset Detection Function Type";
161     desc.minValue = 0;
162     desc.maxValue = 7;
163     desc.defaultValue = (int)OnsetComplex;
164     desc.isQuantized = true;
165     desc.quantizeStep = 1;
166     desc.valueNames.push_back("Energy Based");
167     desc.valueNames.push_back("Spectral Difference");
168     desc.valueNames.push_back("High-Frequency Content");
169     desc.valueNames.push_back("Complex Domain");
170     desc.valueNames.push_back("Phase Deviation");
171     desc.valueNames.push_back("Kullback-Liebler");
172     desc.valueNames.push_back("Modified Kullback-Liebler");
173     desc.valueNames.push_back("Spectral Flux");
174     list.push_back(desc);
175
176     desc = ParameterDescriptor();
177     desc.identifier = "pitchtype";
178     desc.name = "Pitch Detection Function Type";
179     desc.minValue = 0;
180     desc.maxValue = 4;
181     desc.defaultValue = (int)PitchYinFFT;
182     desc.isQuantized = true;
183     desc.quantizeStep = 1;
184     desc.valueNames.push_back("YIN Frequency Estimator");
185     desc.valueNames.push_back("Spectral Comb");
186     desc.valueNames.push_back("Schmitt");
187     desc.valueNames.push_back("Fast Harmonic Comb");
188     desc.valueNames.push_back("YIN with FFT");
189     list.push_back(desc);
190
191     desc = ParameterDescriptor();
192     desc.identifier = "minpitch";
193     desc.name = "Minimum Pitch";
194     desc.minValue = 0;
195     desc.maxValue = 127;
196     desc.defaultValue = 32;
197     desc.unit = "MIDI units";
198     desc.isQuantized = true;
199     desc.quantizeStep = 1;
200     list.push_back(desc);
201
202     desc = ParameterDescriptor();
203     desc.identifier = "maxpitch";
204     desc.name = "Maximum Pitch";
205     desc.minValue = 0;
206     desc.maxValue = 127;
207     desc.defaultValue = 95;
208     desc.unit = "MIDI units";
209     desc.isQuantized = true;
210     desc.quantizeStep = 1;
211     list.push_back(desc);
212
213     desc = ParameterDescriptor();
214     desc.identifier = "wraprange";
215     desc.name = "Fold Higher or Lower Notes into Range";
216     desc.minValue = 0;
217     desc.maxValue = 1;
218     desc.defaultValue = 0;
219     desc.isQuantized = true;
220     desc.quantizeStep = 1;
221     list.push_back(desc);
222
223     desc = ParameterDescriptor();
224     desc.identifier = "avoidleaps";
225     desc.name = "Avoid Multi-Octave Jumps";
226     desc.minValue = 0;
227     desc.maxValue = 1;
228     desc.defaultValue = 0;
229     desc.isQuantized = true;
230     desc.quantizeStep = 1;
231     list.push_back(desc);
232
233     desc = ParameterDescriptor();
234     desc.identifier = "peakpickthreshold";
235     desc.name = "Peak Picker Threshold";
236     desc.minValue = 0;
237     desc.maxValue = 1;
238     desc.defaultValue = 0.3;
239     desc.isQuantized = false;
240     list.push_back(desc);
241
242     desc = ParameterDescriptor();
243     desc.identifier = "silencethreshold";
244     desc.name = "Silence Threshold";
245     desc.minValue = -120;
246     desc.maxValue = 0;
247     desc.defaultValue = -70;
248     desc.unit = "dB";
249     desc.isQuantized = false;
250     list.push_back(desc);
251
252     desc = ParameterDescriptor();
253     desc.identifier = "minioi";
254     desc.name = "Minimum Inter-Onset Interval";
255     desc.minValue = 0;
256     desc.maxValue = 40;
257     desc.defaultValue = 4;
258     desc.unit = "ms";
259     desc.isQuantized = true;
260     desc.quantizeStep = 1;
261     list.push_back(desc);
262
263     return list;
264 }
265
266 float
267 Notes::getParameter(std::string param) const
268 {
269     if (param == "onsettype") {
270         return m_onsettype;
271     } else if (param == "pitchtype") {
272         return m_pitchtype;
273     } else if (param == "peakpickthreshold") {
274         return m_threshold;
275     } else if (param == "silencethreshold") {
276         return m_silence;
277     } else if (param == "minpitch") {
278         return m_minpitch;
279     } else if (param == "maxpitch") {
280         return m_maxpitch;
281     } else if (param == "wraprange") {
282         return m_wrapRange ? 1.0 : 0.0;
283     } else if (param == "avoidleaps") {
284         return m_avoidLeaps ? 1.0 : 0.0;
285     } else if (param == "minioi") {
286         return m_minioi;
287     } else {
288         return 0.0;
289     }
290 }
291
292 void
293 Notes::setParameter(std::string param, float value)
294 {
295     if (param == "onsettype") {
296         switch (lrintf(value)) {
297         case 0: m_onsettype = OnsetEnergy; break;
298         case 1: m_onsettype = OnsetSpecDiff; break;
299         case 2: m_onsettype = OnsetHFC; break;
300         case 3: m_onsettype = OnsetComplex; break;
301         case 4: m_onsettype = OnsetPhase; break;
302         case 5: m_onsettype = OnsetKL; break;
303         case 6: m_onsettype = OnsetMKL; break;
304         case 7: m_onsettype = OnsetSpecFlux; break;
305         }
306     } else if (param == "pitchtype") {
307         switch (lrintf(value)) {
308         case 0: m_pitchtype = PitchYin; break;
309         case 1: m_pitchtype = PitchMComb; break;
310         case 2: m_pitchtype = PitchSchmitt; break;
311         case 3: m_pitchtype = PitchFComb; break;
312         case 4: m_pitchtype = PitchYinFFT; break;
313         }
314     } else if (param == "peakpickthreshold") {
315         m_threshold = value;
316     } else if (param == "silencethreshold") {
317         m_silence = value;
318     } else if (param == "minpitch") {
319         m_minpitch = lrintf(value);
320     } else if (param == "maxpitch") {
321         m_maxpitch = lrintf(value);
322     } else if (param == "wraprange") {
323         m_wrapRange = (value > 0.5);
324     } else if (param == "avoidleaps") {
325         m_avoidLeaps = (value > 0.5);
326     } else if (param == "minioi") {
327         m_minioi = value;
328     }
329 }
330
331 Notes::OutputList
332 Notes::getOutputDescriptors() const
333 {
334     OutputList list;
335
336     OutputDescriptor d;
337     d.identifier = "notes";
338     d.name = "Notes";
339     d.unit = "Hz";
340     d.hasFixedBinCount = true;
341
342     d.binCount = 2;
343     d.binNames.push_back("Frequency");
344     d.binNames.push_back("Velocity");
345     d.hasDuration = true;
346
347     d.hasKnownExtents = false;
348     d.isQuantized = false;
349     d.sampleType = OutputDescriptor::VariableSampleRate;
350     d.sampleRate = 0;
351     list.push_back(d);
352
353     return list;
354 }
355
356 Notes::FeatureSet
357 Notes::process(const float *const *inputBuffers, Vamp::RealTime timestamp)
358 {
359     for (size_t i = 0; i < m_stepSize; ++i) {
360         fvec_write_sample(m_ibuf, inputBuffers[0][i], i);
361     }
362
363     aubio_onset_do(m_onsetdet, m_ibuf, m_onset);
364     aubio_pitch_do(m_pitchdet, m_ibuf, m_pitch);
365
366     bool isonset = m_onset->data[0];
367     float frequency = m_pitch->data[0];
368
369     m_notebuf.push_back(frequency);
370     if (m_notebuf.size() > m_median) m_notebuf.pop_front();
371
372     float level = aubio_level_detection(m_ibuf, m_silence);
373
374     FeatureSet returnFeatures;
375
376     if (isonset) {
377         if (level == 1.) {
378             isonset = false;
379             m_count = 0;
380             if (m_haveCurrent) pushNote(returnFeatures, timestamp);
381         } else {
382             m_count = 1;
383         }
384     } else {
385         if (m_count > 0) ++m_count;
386         if (m_count == m_median) {
387             if (m_haveCurrent) pushNote(returnFeatures, timestamp);
388             m_currentOnset = timestamp;
389             m_currentLevel = level;
390             m_haveCurrent = true;
391         }
392     }
393
394     m_lastTimeStamp = timestamp;
395     return returnFeatures;
396 }
397
398 Notes::FeatureSet
399 Notes::getRemainingFeatures()
400 {
401     FeatureSet returnFeatures;
402     if (m_haveCurrent) pushNote(returnFeatures, m_lastTimeStamp);
403     return returnFeatures;
404 }
405
406 void
407 Notes::pushNote(FeatureSet &fs, const Vamp::RealTime &offTime)
408 {
409     std::deque<float> toSort = m_notebuf;
410     std::sort(toSort.begin(), toSort.end());
411     float median = toSort[toSort.size()/2];
412     if (median < 45.0) return;
413
414     float freq = median;
415     int midiPitch = (int)floor(aubio_freqtomidi(freq) + 0.5);
416     
417     if (m_avoidLeaps) {
418         if (m_prevPitch >= 0) {
419             while (midiPitch < m_prevPitch - 12) {
420                 midiPitch += 12;
421                 freq *= 2;
422             }
423             while (midiPitch > m_prevPitch + 12) {
424                 midiPitch -= 12;
425                 freq /= 2;
426             }
427         }
428     }
429
430     while (midiPitch < m_minpitch) {
431         if (!m_wrapRange) return;
432         midiPitch += 12;
433         freq *= 2;
434     }
435
436     while (midiPitch > m_maxpitch) {
437         if (!m_wrapRange) return;
438         midiPitch -= 12;
439         freq /= 2;
440     }
441
442     m_prevPitch = midiPitch;
443
444     Feature feature;
445     feature.hasTimestamp = true;
446     if (m_currentOnset < m_delay) m_currentOnset = m_delay;
447     feature.timestamp = m_currentOnset - m_delay;
448     feature.values.push_back(freq);
449
450     feature.values.push_back
451         (Vamp::RealTime::realTime2Frame
452          (offTime, lrintf(m_inputSampleRate)) -
453          Vamp::RealTime::realTime2Frame
454          (m_currentOnset, lrintf(m_inputSampleRate)));
455     feature.hasDuration = false;
456
457     feature.values.push_back(m_currentLevel);
458     fs[0].push_back(feature);
459 }
460