c@0
|
1
|
c@0
|
2 // This is a skeleton file for use in creating your own plugin
|
c@0
|
3 // libraries. Replace MyPlugin and myPlugin throughout with the name
|
c@0
|
4 // of your first plugin class, and fill in the gaps as appropriate.
|
c@0
|
5
|
c@0
|
6
|
c@14
|
7 #include "TempogramPlugin.h"
|
c@25
|
8
|
c@4
|
9
|
c@0
|
10 using Vamp::FFT;
|
c@7
|
11 using Vamp::RealTime;
|
c@0
|
12 using namespace std;
|
c@0
|
13
|
c@14
|
14 TempogramPlugin::TempogramPlugin(float inputSampleRate) :
|
c@0
|
15 Plugin(inputSampleRate),
|
c@18
|
16 m_inputBlockSize(0), //host parameter
|
c@18
|
17 m_inputStepSize(0), //host parameter
|
c@29
|
18 m_noveltyCurveMinDB(-74), //parameter
|
c@29
|
19 m_noveltyCurveMinV(0), //set in initialise()
|
c@18
|
20 m_noveltyCurveCompressionConstant(1000), //parameter
|
c@18
|
21 m_tempogramLog2WindowLength(10), //parameter
|
c@29
|
22 m_tempogramWindowLength(0), //set in initialise()
|
c@18
|
23 m_tempogramLog2FftLength(m_tempogramLog2WindowLength), //parameter
|
c@29
|
24 m_tempogramFftLength(0), //set in initialise()
|
c@18
|
25 m_tempogramLog2HopSize(6), //parameter
|
c@29
|
26 m_tempogramHopSize(0), //set in initialise()
|
c@18
|
27 m_tempogramMinBPM(30), //parameter
|
c@18
|
28 m_tempogramMaxBPM(480), //parameter
|
c@18
|
29 m_tempogramMinBin(0), //set in initialise()
|
c@18
|
30 m_tempogramMaxBin(0), //set in initialise()
|
c@29
|
31 m_tempogramMinLag(0), //set in initialise()
|
c@29
|
32 m_tempogramMaxLag(0), //set in initialise()
|
c@18
|
33 m_cyclicTempogramMinBPM(30), //reset in initialise()
|
c@18
|
34 m_cyclicTempogramNumberOfOctaves(0), //set in initialise()
|
c@18
|
35 m_cyclicTempogramOctaveDivider(30) //parameter
|
c@0
|
36
|
c@0
|
37 // Also be sure to set your plugin parameters (presumably stored
|
c@0
|
38 // in member variables) to their default values here -- the host
|
c@0
|
39 // will not do that for you
|
c@0
|
40 {
|
c@0
|
41 }
|
c@0
|
42
|
c@14
|
43 TempogramPlugin::~TempogramPlugin()
|
c@0
|
44 {
|
c@0
|
45 //delete stuff
|
c@0
|
46 }
|
c@0
|
47
|
c@0
|
48 string
|
c@14
|
49 TempogramPlugin::getIdentifier() const
|
c@0
|
50 {
|
c@0
|
51 return "tempogram";
|
c@0
|
52 }
|
c@0
|
53
|
c@0
|
54 string
|
c@14
|
55 TempogramPlugin::getName() const
|
c@0
|
56 {
|
c@0
|
57 return "Tempogram";
|
c@0
|
58 }
|
c@0
|
59
|
c@0
|
60 string
|
c@14
|
61 TempogramPlugin::getDescription() const
|
c@0
|
62 {
|
c@0
|
63 // Return something helpful here!
|
c@0
|
64 return "Cyclic Tempogram as described by Peter Grosche and Meinard Muller";
|
c@0
|
65 }
|
c@0
|
66
|
c@0
|
67 string
|
c@14
|
68 TempogramPlugin::getMaker() const
|
c@0
|
69 {
|
c@0
|
70 //Your name here
|
c@0
|
71 return "Carl Bussey";
|
c@0
|
72 }
|
c@0
|
73
|
c@0
|
74 int
|
c@14
|
75 TempogramPlugin::getPluginVersion() const
|
c@0
|
76 {
|
c@0
|
77 // Increment this each time you release a version that behaves
|
c@0
|
78 // differently from the previous one
|
c@0
|
79 return 1;
|
c@0
|
80 }
|
c@0
|
81
|
c@0
|
82 string
|
c@14
|
83 TempogramPlugin::getCopyright() const
|
c@0
|
84 {
|
c@0
|
85 // This function is not ideally named. It does not necessarily
|
c@0
|
86 // need to say who made the plugin -- getMaker does that -- but it
|
c@0
|
87 // should indicate the terms under which it is distributed. For
|
c@0
|
88 // example, "Copyright (year). All Rights Reserved", or "GPL"
|
c@0
|
89 return "";
|
c@0
|
90 }
|
c@0
|
91
|
c@14
|
92 TempogramPlugin::InputDomain
|
c@14
|
93 TempogramPlugin::getInputDomain() const
|
c@0
|
94 {
|
c@0
|
95 return FrequencyDomain;
|
c@0
|
96 }
|
c@0
|
97
|
c@0
|
98 size_t
|
c@14
|
99 TempogramPlugin::getPreferredBlockSize() const
|
c@0
|
100 {
|
c@9
|
101 return 2048; // 0 means "I can handle any block size"
|
c@0
|
102 }
|
c@0
|
103
|
c@0
|
104 size_t
|
c@14
|
105 TempogramPlugin::getPreferredStepSize() const
|
c@0
|
106 {
|
c@9
|
107 return 1024; // 0 means "anything sensible"; in practice this
|
c@0
|
108 // means the same as the block size for TimeDomain
|
c@0
|
109 // plugins, or half of it for FrequencyDomain plugins
|
c@0
|
110 }
|
c@0
|
111
|
c@0
|
112 size_t
|
c@14
|
113 TempogramPlugin::getMinChannelCount() const
|
c@0
|
114 {
|
c@0
|
115 return 1;
|
c@0
|
116 }
|
c@0
|
117
|
c@0
|
118 size_t
|
c@14
|
119 TempogramPlugin::getMaxChannelCount() const
|
c@0
|
120 {
|
c@0
|
121 return 1;
|
c@0
|
122 }
|
c@0
|
123
|
c@14
|
124 TempogramPlugin::ParameterList
|
c@14
|
125 TempogramPlugin::getParameterDescriptors() const
|
c@0
|
126 {
|
c@0
|
127 ParameterList list;
|
c@0
|
128
|
c@0
|
129 // If the plugin has no adjustable parameters, return an empty
|
c@0
|
130 // list here (and there's no need to provide implementations of
|
c@0
|
131 // getParameter and setParameter in that case either).
|
c@0
|
132
|
c@0
|
133 // Note that it is your responsibility to make sure the parameters
|
c@0
|
134 // start off having their default values (e.g. in the constructor
|
c@0
|
135 // above). The host needs to know the default value so it can do
|
c@0
|
136 // things like provide a "reset to default" function, but it will
|
c@0
|
137 // not explicitly set your parameters to their defaults for you if
|
c@0
|
138 // they have not changed in the mean time.
|
c@0
|
139
|
c@14
|
140 ParameterDescriptor d1;
|
c@14
|
141 d1.identifier = "C";
|
c@15
|
142 d1.name = "Novelty Curve Spectrogram Compression Constant";
|
c@14
|
143 d1.description = "Spectrogram compression constant, C, used when retrieving the novelty curve from the audio.";
|
c@14
|
144 d1.unit = "";
|
c@14
|
145 d1.minValue = 2;
|
c@14
|
146 d1.maxValue = 10000;
|
c@14
|
147 d1.defaultValue = 1000;
|
c@14
|
148 d1.isQuantized = false;
|
c@14
|
149 list.push_back(d1);
|
c@29
|
150
|
c@29
|
151 ParameterDescriptor d2;
|
c@29
|
152 d2.identifier = "minDB";
|
c@29
|
153 d2.name = "Novelty Curve Minimum DB";
|
c@29
|
154 d2.description = "Spectrogram minimum DB used when removing unwanted peaks in the Spectrogram when retrieving the novelty curve from the audio.";
|
c@29
|
155 d2.unit = "";
|
c@29
|
156 d2.minValue = -100;
|
c@29
|
157 d2.maxValue = -50;
|
c@29
|
158 d2.defaultValue = -74;
|
c@29
|
159 d2.isQuantized = false;
|
c@29
|
160 list.push_back(d2);
|
c@9
|
161
|
c@14
|
162 ParameterDescriptor d3;
|
c@29
|
163 d3.identifier = "log2TN";
|
c@29
|
164 d3.name = "Tempogram Window Length";
|
c@29
|
165 d3.description = "FFT window length when analysing the novelty curve and extracting the tempogram time-frequency function.";
|
c@14
|
166 d3.unit = "";
|
c@29
|
167 d3.minValue = 7;
|
c@14
|
168 d3.maxValue = 12;
|
c@29
|
169 d3.defaultValue = 10;
|
c@14
|
170 d3.isQuantized = true;
|
c@14
|
171 d3.quantizeStep = 1;
|
c@14
|
172 for (int i = d3.minValue; i <= d3.maxValue; i++){
|
c@14
|
173 d3.valueNames.push_back(floatToString(pow((float)2,(float)i)));
|
c@14
|
174 }
|
c@14
|
175 list.push_back(d3);
|
c@9
|
176
|
c@14
|
177 ParameterDescriptor d4;
|
c@29
|
178 d4.identifier = "log2HopSize";
|
c@29
|
179 d4.name = "Tempogram Hopsize";
|
c@29
|
180 d4.description = "FFT hopsize when analysing the novelty curve and extracting the tempogram time-frequency function.";
|
c@14
|
181 d4.unit = "";
|
c@14
|
182 d4.minValue = 6;
|
c@14
|
183 d4.maxValue = 12;
|
c@29
|
184 d4.defaultValue = 6;
|
c@14
|
185 d4.isQuantized = true;
|
c@14
|
186 d4.quantizeStep = 1;
|
c@14
|
187 for (int i = d4.minValue; i <= d4.maxValue; i++){
|
c@14
|
188 d4.valueNames.push_back(floatToString(pow((float)2,(float)i)));
|
c@14
|
189 }
|
c@14
|
190 list.push_back(d4);
|
c@14
|
191
|
c@14
|
192 ParameterDescriptor d5;
|
c@29
|
193 d5.identifier = "log2FftLength";
|
c@29
|
194 d5.name = "Tempogram FFT Length";
|
c@29
|
195 d5.description = "FFT length when analysing the novelty curve and extracting the tempogram time-frequency function. This parameter determines the amount of zero padding.";
|
c@14
|
196 d5.unit = "";
|
c@29
|
197 d5.minValue = 6;
|
c@29
|
198 d5.maxValue = 12;
|
c@29
|
199 d5.defaultValue = d2.defaultValue;
|
c@14
|
200 d5.isQuantized = true;
|
c@29
|
201 d5.quantizeStep = 1;
|
c@29
|
202 for (int i = d5.minValue; i <= d5.maxValue; i++){
|
c@29
|
203 d4.valueNames.push_back(floatToString(pow((float)2,(float)i)));
|
c@29
|
204 }
|
c@14
|
205 list.push_back(d5);
|
c@14
|
206
|
c@14
|
207 ParameterDescriptor d6;
|
c@29
|
208 d6.identifier = "minBPM";
|
c@29
|
209 d6.name = "(Cyclic) Tempogram Minimum BPM";
|
c@29
|
210 d6.description = "The minimum BPM of the tempogram output bins.";
|
c@14
|
211 d6.unit = "";
|
c@29
|
212 d6.minValue = 0;
|
c@14
|
213 d6.maxValue = 2000;
|
c@29
|
214 d6.defaultValue = 30;
|
c@14
|
215 d6.isQuantized = true;
|
c@14
|
216 d6.quantizeStep = 5;
|
c@14
|
217 list.push_back(d6);
|
c@18
|
218
|
c@18
|
219 ParameterDescriptor d7;
|
c@29
|
220 d7.identifier = "maxBPM";
|
c@29
|
221 d7.name = "(Cyclic) Tempogram Maximum BPM";
|
c@29
|
222 d7.description = "The maximum BPM of the tempogram output bins.";
|
c@18
|
223 d7.unit = "";
|
c@29
|
224 d7.minValue = 30;
|
c@29
|
225 d7.maxValue = 2000;
|
c@29
|
226 d7.defaultValue = 480;
|
c@18
|
227 d7.isQuantized = true;
|
c@29
|
228 d7.quantizeStep = 5;
|
c@18
|
229 list.push_back(d7);
|
c@29
|
230
|
c@29
|
231 ParameterDescriptor d8;
|
c@29
|
232 d8.identifier = "octDiv";
|
c@29
|
233 d8.name = "Cyclic Tempogram Octave Divider";
|
c@29
|
234 d8.description = "The number bins within each octave.";
|
c@29
|
235 d8.unit = "";
|
c@29
|
236 d8.minValue = 5;
|
c@29
|
237 d8.maxValue = 60;
|
c@29
|
238 d8.defaultValue = 30;
|
c@29
|
239 d8.isQuantized = true;
|
c@29
|
240 d8.quantizeStep = 1;
|
c@29
|
241 list.push_back(d8);
|
c@0
|
242
|
c@0
|
243 return list;
|
c@0
|
244 }
|
c@0
|
245
|
c@0
|
246 float
|
c@14
|
247 TempogramPlugin::getParameter(string identifier) const
|
c@0
|
248 {
|
c@0
|
249 if (identifier == "C") {
|
c@18
|
250 return m_noveltyCurveCompressionConstant; // return the ACTUAL current value of your parameter here!
|
c@0
|
251 }
|
c@29
|
252 else if (identifier == "minDB"){
|
c@29
|
253 return m_noveltyCurveMinDB;
|
c@29
|
254 }
|
c@14
|
255 else if (identifier == "log2TN"){
|
c@18
|
256 return m_tempogramLog2WindowLength;
|
c@9
|
257 }
|
c@14
|
258 else if (identifier == "log2HopSize"){
|
c@18
|
259 return m_tempogramLog2HopSize;
|
c@14
|
260 }
|
c@14
|
261 else if (identifier == "log2FftLength"){
|
c@18
|
262 return m_tempogramLog2FftLength;
|
c@14
|
263 }
|
c@14
|
264 else if (identifier == "minBPM") {
|
c@18
|
265 return m_tempogramMinBPM;
|
c@9
|
266 }
|
c@14
|
267 else if (identifier == "maxBPM"){
|
c@18
|
268 return m_tempogramMaxBPM;
|
c@18
|
269 }
|
c@18
|
270 else if (identifier == "octDiv"){
|
c@18
|
271 return m_cyclicTempogramOctaveDivider;
|
c@0
|
272 }
|
c@0
|
273
|
c@0
|
274 return 0;
|
c@0
|
275 }
|
c@0
|
276
|
c@0
|
277 void
|
c@14
|
278 TempogramPlugin::setParameter(string identifier, float value)
|
c@0
|
279 {
|
c@9
|
280
|
c@0
|
281 if (identifier == "C") {
|
c@18
|
282 m_noveltyCurveCompressionConstant = value; // set the actual value of your parameter
|
c@0
|
283 }
|
c@29
|
284 else if (identifier == "minDB"){
|
c@29
|
285 m_noveltyCurveMinDB = value;
|
c@29
|
286 }
|
c@14
|
287 else if (identifier == "log2TN") {
|
c@18
|
288 m_tempogramLog2WindowLength = value;
|
c@0
|
289 }
|
c@14
|
290 else if (identifier == "log2HopSize"){
|
c@30
|
291 m_tempogramLog2HopSize = value;
|
c@14
|
292 }
|
c@18
|
293 else if (identifier == "log2FftLength"){
|
c@30
|
294 m_tempogramLog2FftLength = value;
|
c@14
|
295 }
|
c@14
|
296 else if (identifier == "minBPM") {
|
c@18
|
297 m_tempogramMinBPM = value;
|
c@9
|
298 }
|
c@14
|
299 else if (identifier == "maxBPM"){
|
c@18
|
300 m_tempogramMaxBPM = value;
|
c@18
|
301 }
|
c@18
|
302 else if (identifier == "octDiv"){
|
c@18
|
303 m_cyclicTempogramOctaveDivider = value;
|
c@9
|
304 }
|
c@9
|
305
|
c@9
|
306 }
|
c@9
|
307
|
c@14
|
308 TempogramPlugin::ProgramList
|
c@14
|
309 TempogramPlugin::getPrograms() const
|
c@0
|
310 {
|
c@0
|
311 ProgramList list;
|
c@0
|
312
|
c@0
|
313 // If you have no programs, return an empty list (or simply don't
|
c@0
|
314 // implement this function or getCurrentProgram/selectProgram)
|
c@0
|
315
|
c@0
|
316 return list;
|
c@0
|
317 }
|
c@0
|
318
|
c@0
|
319 string
|
c@14
|
320 TempogramPlugin::getCurrentProgram() const
|
c@0
|
321 {
|
c@0
|
322 return ""; // no programs
|
c@0
|
323 }
|
c@0
|
324
|
c@0
|
325 void
|
c@14
|
326 TempogramPlugin::selectProgram(string name)
|
c@0
|
327 {
|
c@0
|
328 }
|
c@0
|
329
|
c@14
|
330 TempogramPlugin::OutputList
|
c@14
|
331 TempogramPlugin::getOutputDescriptors() const
|
c@0
|
332 {
|
c@0
|
333 OutputList list;
|
c@0
|
334
|
c@0
|
335 // See OutputDescriptor documentation for the possibilities here.
|
c@0
|
336 // Every plugin must have at least one output.
|
c@1
|
337
|
c@7
|
338 float d_sampleRate;
|
c@18
|
339 float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
|
c@7
|
340
|
c@25
|
341 OutputDescriptor d1;
|
c@25
|
342 d1.identifier = "cyclicTempogram";
|
c@25
|
343 d1.name = "Cyclic Tempogram";
|
c@25
|
344 d1.description = "Cyclic Tempogram";
|
c@25
|
345 d1.unit = "";
|
c@25
|
346 d1.hasFixedBinCount = true;
|
c@25
|
347 d1.binCount = m_cyclicTempogramOctaveDivider > 0 && !isnan(m_cyclicTempogramOctaveDivider) ? m_cyclicTempogramOctaveDivider : 0;
|
c@25
|
348 d1.hasKnownExtents = false;
|
c@25
|
349 d1.isQuantized = false;
|
c@25
|
350 d1.sampleType = OutputDescriptor::FixedSampleRate;
|
c@25
|
351 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
|
c@25
|
352 d1.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
|
c@25
|
353 d1.hasDuration = false;
|
c@25
|
354 list.push_back(d1);
|
c@25
|
355
|
c@25
|
356 OutputDescriptor d2;
|
c@25
|
357 d2.identifier = "tempogramDFT";
|
c@25
|
358 d2.name = "Tempogram via DFT";
|
c@25
|
359 d2.description = "Tempogram via DFT";
|
c@25
|
360 d2.unit = "BPM";
|
c@25
|
361 d2.hasFixedBinCount = true;
|
c@25
|
362 d2.binCount = m_tempogramMaxBin - m_tempogramMinBin + 1;
|
c@25
|
363 d2.hasKnownExtents = false;
|
c@25
|
364 d2.isQuantized = false;
|
c@25
|
365 d2.sampleType = OutputDescriptor::FixedSampleRate;
|
c@25
|
366 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
|
c@25
|
367 d2.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0.0;
|
c@25
|
368 for(int i = m_tempogramMinBin; i <= (int)m_tempogramMaxBin; i++){
|
c@25
|
369 float w = ((float)i/m_tempogramFftLength)*(tempogramInputSampleRate);
|
c@25
|
370 d2.binNames.push_back(floatToString(w*60));
|
c@25
|
371 }
|
c@25
|
372 d2.hasDuration = false;
|
c@25
|
373 list.push_back(d2);
|
c@25
|
374
|
c@21
|
375 OutputDescriptor d3;
|
c@25
|
376 d3.identifier = "tempogramACT";
|
c@25
|
377 d3.name = "Tempogram via ACT";
|
c@25
|
378 d3.description = "Tempogram via ACT";
|
c@25
|
379 d3.unit = "BPM";
|
c@21
|
380 d3.hasFixedBinCount = true;
|
c@28
|
381 d3.binCount = m_tempogramMaxLag - m_tempogramMinLag + 1;
|
c@21
|
382 d3.hasKnownExtents = false;
|
c@21
|
383 d3.isQuantized = false;
|
c@21
|
384 d3.sampleType = OutputDescriptor::FixedSampleRate;
|
c@21
|
385 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
|
c@25
|
386 d3.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0.0;
|
c@28
|
387 for(int lag = m_tempogramMaxLag; lag >= (int)m_tempogramMinLag; lag--){
|
c@28
|
388 d3.binNames.push_back(floatToString(60/(m_inputStepSize*(lag/m_inputSampleRate))));
|
c@25
|
389 }
|
c@21
|
390 d3.hasDuration = false;
|
c@21
|
391 list.push_back(d3);
|
c@21
|
392
|
c@25
|
393 OutputDescriptor d4;
|
c@25
|
394 d4.identifier = "nc";
|
c@25
|
395 d4.name = "Novelty Curve";
|
c@25
|
396 d4.description = "Novelty Curve";
|
c@25
|
397 d4.unit = "";
|
c@25
|
398 d4.hasFixedBinCount = true;
|
c@25
|
399 d4.binCount = 1;
|
c@25
|
400 d4.hasKnownExtents = false;
|
c@25
|
401 d4.isQuantized = false;
|
c@25
|
402 d4.sampleType = OutputDescriptor::FixedSampleRate;
|
c@9
|
403 d_sampleRate = tempogramInputSampleRate;
|
c@25
|
404 d4.sampleRate = d_sampleRate > 0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
|
c@25
|
405 d4.hasDuration = false;
|
c@25
|
406 list.push_back(d4);
|
c@18
|
407
|
c@0
|
408 return list;
|
c@0
|
409 }
|
c@0
|
410
|
c@20
|
411 bool
|
c@20
|
412 TempogramPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
|
c@20
|
413 {
|
c@20
|
414 if (channels < getMinChannelCount() ||
|
c@20
|
415 channels > getMaxChannelCount()) return false;
|
c@20
|
416
|
c@20
|
417 // Real initialisation work goes here!
|
c@20
|
418 m_inputBlockSize = blockSize;
|
c@20
|
419 m_inputStepSize = stepSize;
|
c@20
|
420
|
c@24
|
421 //m_spectrogram = Spectrogram(m_inputBlockSize/2 + 1);
|
c@21
|
422 if (!handleParameterValues()) return false;
|
c@19
|
423 //cout << m_cyclicTempogramOctaveDivider << endl;
|
c@4
|
424
|
c@0
|
425 return true;
|
c@0
|
426 }
|
c@0
|
427
|
c@0
|
428 void
|
c@14
|
429 TempogramPlugin::reset()
|
c@0
|
430 {
|
c@0
|
431 // Clear buffers, reset stored values, etc
|
c@19
|
432 m_spectrogram.clear();
|
c@21
|
433 handleParameterValues();
|
c@0
|
434 }
|
c@0
|
435
|
c@14
|
436 TempogramPlugin::FeatureSet
|
c@14
|
437 TempogramPlugin::process(const float *const *inputBuffers, Vamp::RealTime timestamp)
|
c@0
|
438 {
|
c@23
|
439 int n = m_inputBlockSize/2 + 1;
|
c@0
|
440 const float *in = inputBuffers[0];
|
c@3
|
441
|
c@9
|
442 //calculate magnitude of FrequencyDomain input
|
c@22
|
443 vector<float> fftCoefficients;
|
c@23
|
444 for (int i = 0; i < n; i++){
|
c@0
|
445 float magnitude = sqrt(in[2*i] * in[2*i] + in[2*i + 1] * in[2*i + 1]);
|
c@29
|
446 magnitude = magnitude > m_noveltyCurveMinV ? magnitude : m_noveltyCurveMinV;
|
c@22
|
447 fftCoefficients.push_back(magnitude);
|
c@0
|
448 }
|
c@22
|
449 m_spectrogram.push_back(fftCoefficients);
|
c@24
|
450 //m_spectrogram.push_back(fftCoefficients);
|
c@21
|
451
|
c@23
|
452 return FeatureSet();
|
c@0
|
453 }
|
c@0
|
454
|
c@14
|
455 TempogramPlugin::FeatureSet
|
c@14
|
456 TempogramPlugin::getRemainingFeatures()
|
c@11
|
457 {
|
c@0
|
458
|
c@18
|
459 float * hannWindow = new float[m_tempogramWindowLength];
|
c@20
|
460 for (int i = 0; i < (int)m_tempogramWindowLength; i++){
|
c@14
|
461 hannWindow[i] = 0.0;
|
c@4
|
462 }
|
c@11
|
463
|
c@1
|
464 FeatureSet featureSet;
|
c@0
|
465
|
c@19
|
466 //initialise novelty curve processor
|
c@23
|
467 int numberOfBlocks = m_spectrogram.size();
|
c@20
|
468 //cerr << numberOfBlocks << endl;
|
c@22
|
469 NoveltyCurveProcessor nc(m_inputSampleRate, m_inputBlockSize, m_noveltyCurveCompressionConstant);
|
c@21
|
470 vector<float> noveltyCurve = nc.spectrogramToNoveltyCurve(m_spectrogram); //calculate novelty curvefrom magnitude data
|
c@4
|
471
|
c@9
|
472 //push novelty curve data to featureset 1 and set timestamps
|
c@23
|
473 for (int i = 0; i < numberOfBlocks; i++){
|
c@19
|
474 Feature noveltyCurveFeature;
|
c@19
|
475 noveltyCurveFeature.values.push_back(noveltyCurve[i]);
|
c@19
|
476 noveltyCurveFeature.hasTimestamp = false;
|
c@25
|
477 featureSet[3].push_back(noveltyCurveFeature);
|
c@21
|
478 assert(!isnan(noveltyCurveFeature.values.back()));
|
c@4
|
479 }
|
c@4
|
480
|
c@9
|
481 //window function for spectrogram
|
c@18
|
482 WindowFunction::hanning(hannWindow, m_tempogramWindowLength);
|
c@9
|
483
|
c@9
|
484 //initialise spectrogram processor
|
c@18
|
485 SpectrogramProcessor spectrogramProcessor(m_tempogramWindowLength, m_tempogramFftLength, m_tempogramHopSize);
|
c@9
|
486 //compute spectrogram from novelty curve data (i.e., tempogram)
|
c@25
|
487 Tempogram tempogramDFT = spectrogramProcessor.process(&noveltyCurve[0], numberOfBlocks, hannWindow);
|
c@18
|
488 delete []hannWindow;
|
c@18
|
489 hannWindow = 0;
|
c@0
|
490
|
c@25
|
491 int tempogramLength = tempogramDFT.size();
|
c@7
|
492
|
c@9
|
493 //push tempogram data to featureset 0 and set timestamps.
|
c@7
|
494 for (int block = 0; block < tempogramLength; block++){
|
c@25
|
495 Feature tempogramDFTFeature;
|
c@28
|
496
|
c@28
|
497 assert(tempogramDFT[block].size() == (m_tempogramFftLength/2 + 1));
|
c@28
|
498 for(int k = m_tempogramMinBin; k <= (int)m_tempogramMaxBin; k++){
|
c@28
|
499 tempogramDFTFeature.values.push_back(tempogramDFT[block][k]);
|
c@28
|
500 }
|
c@28
|
501 tempogramDFTFeature.hasTimestamp = false;
|
c@28
|
502 featureSet[1].push_back(tempogramDFTFeature);
|
c@28
|
503 }
|
c@28
|
504
|
c@28
|
505 AutocorrelationProcessor autocorrelationProcessor(m_tempogramWindowLength, m_tempogramHopSize);
|
c@28
|
506 Tempogram tempogramACT = autocorrelationProcessor.process(&noveltyCurve[0], numberOfBlocks);
|
c@28
|
507
|
c@28
|
508 for (int block = 0; block < tempogramLength; block++){
|
c@25
|
509 Feature tempogramACTFeature;
|
c@0
|
510
|
c@28
|
511 for(int k = m_tempogramMaxLag; k >= (int)m_tempogramMinLag; k--){
|
c@25
|
512 tempogramACTFeature.values.push_back(tempogramACT[block][k]);
|
c@0
|
513 }
|
c@25
|
514 tempogramACTFeature.hasTimestamp = false;
|
c@25
|
515 featureSet[2].push_back(tempogramACTFeature);
|
c@0
|
516 }
|
c@0
|
517
|
c@18
|
518 //Calculate cyclic tempogram
|
c@22
|
519 vector< vector<unsigned int> > logBins = calculateTempogramNearestNeighbourLogBins();
|
c@18
|
520
|
c@22
|
521 //assert((int)logBins.size() == m_cyclicTempogramOctaveDivider*m_cyclicTempogramNumberOfOctaves);
|
c@18
|
522 for (int block = 0; block < tempogramLength; block++){
|
c@19
|
523 Feature cyclicTempogramFeature;
|
c@18
|
524
|
c@23
|
525 for (int i = 0; i < m_cyclicTempogramOctaveDivider; i++){
|
c@18
|
526 float sum = 0;
|
c@21
|
527
|
c@23
|
528 for (int j = 0; j < m_cyclicTempogramNumberOfOctaves; j++){
|
c@25
|
529 sum += tempogramDFT[block][logBins[j][i]];
|
c@18
|
530 }
|
c@19
|
531 cyclicTempogramFeature.values.push_back(sum/m_cyclicTempogramNumberOfOctaves);
|
c@21
|
532 assert(!isnan(cyclicTempogramFeature.values.back()));
|
c@18
|
533 }
|
c@18
|
534
|
c@19
|
535 cyclicTempogramFeature.hasTimestamp = false;
|
c@21
|
536 featureSet[0].push_back(cyclicTempogramFeature);
|
c@18
|
537 }
|
c@0
|
538
|
c@0
|
539 return featureSet;
|
c@0
|
540 }
|
c@22
|
541
|
c@22
|
542 vector< vector<unsigned int> > TempogramPlugin::calculateTempogramNearestNeighbourLogBins() const
|
c@22
|
543 {
|
c@22
|
544 vector< vector<unsigned int> > logBins;
|
c@22
|
545
|
c@22
|
546 for (int octave = 0; octave < (int)m_cyclicTempogramNumberOfOctaves; octave++){
|
c@22
|
547 vector<unsigned int> octaveBins;
|
c@22
|
548
|
c@22
|
549 for (int bin = 0; bin < (int)m_cyclicTempogramOctaveDivider; bin++){
|
c@22
|
550 float bpm = m_cyclicTempogramMinBPM*pow(2.0f, octave+(float)bin/m_cyclicTempogramOctaveDivider);
|
c@22
|
551 octaveBins.push_back(bpmToBin(bpm));
|
c@23
|
552 //cout << octaveBins.back() << endl;
|
c@22
|
553 }
|
c@22
|
554 logBins.push_back(octaveBins);
|
c@22
|
555 }
|
c@22
|
556
|
c@22
|
557 //cerr << logBins.size() << endl;
|
c@22
|
558
|
c@22
|
559 return logBins;
|
c@22
|
560 }
|
c@22
|
561
|
c@22
|
562 unsigned int TempogramPlugin::bpmToBin(const float &bpm) const
|
c@22
|
563 {
|
c@22
|
564 float w = (float)bpm/60;
|
c@22
|
565 float sampleRate = m_inputSampleRate/m_inputStepSize;
|
c@22
|
566 int bin = floor((float)m_tempogramFftLength*w/sampleRate + 0.5);
|
c@22
|
567
|
c@22
|
568 if(bin < 0) bin = 0;
|
c@22
|
569 else if(bin > m_tempogramFftLength/2.0f) bin = m_tempogramFftLength;
|
c@22
|
570
|
c@22
|
571 return bin;
|
c@22
|
572 }
|
c@22
|
573
|
c@22
|
574 float TempogramPlugin::binToBPM(const int &bin) const
|
c@22
|
575 {
|
c@22
|
576 float sampleRate = m_inputSampleRate/m_inputStepSize;
|
c@22
|
577
|
c@22
|
578 return (bin*sampleRate/m_tempogramFftLength)*60;
|
c@22
|
579 }
|
c@22
|
580
|
c@22
|
581 bool TempogramPlugin::handleParameterValues(){
|
c@22
|
582
|
c@30
|
583 if (m_tempogramLog2HopSize <= 0) return false;
|
c@22
|
584 if (m_tempogramLog2FftLength <= 0) return false;
|
c@22
|
585
|
c@22
|
586 if (m_tempogramMinBPM >= m_tempogramMaxBPM){
|
c@22
|
587 m_tempogramMinBPM = 30;
|
c@22
|
588 m_tempogramMaxBPM = 480;
|
c@22
|
589 }
|
c@22
|
590
|
c@29
|
591 m_noveltyCurveMinV = pow(10,(float)m_noveltyCurveMinDB/20);
|
c@29
|
592
|
c@29
|
593 m_tempogramWindowLength = pow(2,m_tempogramLog2WindowLength);
|
c@29
|
594 m_tempogramHopSize = pow(2,m_tempogramLog2HopSize);
|
c@29
|
595 m_tempogramFftLength = pow(2,m_tempogramLog2FftLength);
|
c@29
|
596
|
c@30
|
597 if (m_tempogramFftLength < m_tempogramWindowLength){
|
c@30
|
598 m_tempogramFftLength = m_tempogramWindowLength;
|
c@30
|
599 }
|
c@30
|
600
|
c@22
|
601 float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
|
c@28
|
602 m_tempogramMinBin = (max((int)floor(((m_tempogramMinBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), 0));
|
c@28
|
603 m_tempogramMaxBin = (min((int)ceil(((m_tempogramMaxBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), (int)(m_tempogramFftLength/2)));
|
c@28
|
604
|
c@28
|
605 m_tempogramMinLag = max((int)ceil((60/(m_inputStepSize * m_tempogramMaxBPM))*m_inputSampleRate), 0);
|
c@28
|
606 m_tempogramMaxLag = min((int)floor((60/(m_inputStepSize * m_tempogramMinBPM))*m_inputSampleRate), (int)m_tempogramWindowLength);
|
c@22
|
607
|
c@25
|
608 if (m_tempogramMinBPM > m_cyclicTempogramMinBPM) m_cyclicTempogramMinBPM = m_tempogramMinBPM; //m_cyclicTempogram can't be less than default = 30
|
c@22
|
609 float cyclicTempogramMaxBPM = 480;
|
c@22
|
610 if (m_tempogramMaxBPM < cyclicTempogramMaxBPM) cyclicTempogramMaxBPM = m_tempogramMaxBPM;
|
c@22
|
611
|
c@22
|
612 m_cyclicTempogramNumberOfOctaves = floor(log2(cyclicTempogramMaxBPM/m_cyclicTempogramMinBPM));
|
c@22
|
613
|
c@22
|
614 return true;
|
c@22
|
615 }
|
c@22
|
616
|
c@22
|
617 string TempogramPlugin::floatToString(float value) const
|
c@22
|
618 {
|
c@22
|
619 ostringstream ss;
|
c@22
|
620
|
c@22
|
621 if(!(ss << value)) throw runtime_error("TempogramPlugin::floatToString(): invalid conversion from float to string");
|
c@22
|
622 return ss.str();
|
c@22
|
623 }
|