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@19
|
18 m_noveltyCurveMinDB(pow(10,(float)-74/20)), //set in initialise()
|
c@18
|
19 m_noveltyCurveCompressionConstant(1000), //parameter
|
c@18
|
20 m_tempogramLog2WindowLength(10), //parameter
|
c@18
|
21 m_tempogramWindowLength(pow((float)2,m_tempogramLog2WindowLength)),
|
c@18
|
22 m_tempogramLog2FftLength(m_tempogramLog2WindowLength), //parameter
|
c@18
|
23 m_tempogramFftLength(m_tempogramWindowLength),
|
c@18
|
24 m_tempogramLog2HopSize(6), //parameter
|
c@18
|
25 m_tempogramHopSize(pow((float)2,m_tempogramLog2HopSize)),
|
c@18
|
26 m_tempogramMinBPM(30), //parameter
|
c@18
|
27 m_tempogramMaxBPM(480), //parameter
|
c@18
|
28 m_tempogramMinBin(0), //set in initialise()
|
c@18
|
29 m_tempogramMaxBin(0), //set in initialise()
|
c@28
|
30 m_tempogramMinLag(0),
|
c@28
|
31 m_tempogramMaxLag(0),
|
c@18
|
32 m_cyclicTempogramMinBPM(30), //reset in initialise()
|
c@18
|
33 m_cyclicTempogramNumberOfOctaves(0), //set in initialise()
|
c@18
|
34 m_cyclicTempogramOctaveDivider(30) //parameter
|
c@0
|
35
|
c@0
|
36 // Also be sure to set your plugin parameters (presumably stored
|
c@0
|
37 // in member variables) to their default values here -- the host
|
c@0
|
38 // will not do that for you
|
c@0
|
39 {
|
c@0
|
40 }
|
c@0
|
41
|
c@14
|
42 TempogramPlugin::~TempogramPlugin()
|
c@0
|
43 {
|
c@0
|
44 //delete stuff
|
c@19
|
45
|
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@9
|
150
|
c@14
|
151 ParameterDescriptor d2;
|
c@14
|
152 d2.identifier = "log2TN";
|
c@14
|
153 d2.name = "Tempogram Window Length";
|
c@14
|
154 d2.description = "FFT window length when analysing the novelty curve and extracting the tempogram time-frequency function.";
|
c@14
|
155 d2.unit = "";
|
c@14
|
156 d2.minValue = 7;
|
c@14
|
157 d2.maxValue = 12;
|
c@14
|
158 d2.defaultValue = 10;
|
c@14
|
159 d2.isQuantized = true;
|
c@14
|
160 d2.quantizeStep = 1;
|
c@14
|
161 for (int i = d2.minValue; i <= d2.maxValue; i++){
|
c@14
|
162 d2.valueNames.push_back(floatToString(pow((float)2,(float)i)));
|
c@13
|
163 }
|
c@14
|
164 list.push_back(d2);
|
c@0
|
165
|
c@14
|
166 ParameterDescriptor d3;
|
c@14
|
167 d3.identifier = "log2HopSize";
|
c@14
|
168 d3.name = "Tempogram Hopsize";
|
c@14
|
169 d3.description = "FFT hopsize when analysing the novelty curve and extracting the tempogram time-frequency function.";
|
c@14
|
170 d3.unit = "";
|
c@14
|
171 d3.minValue = 6;
|
c@14
|
172 d3.maxValue = 12;
|
c@14
|
173 d3.defaultValue = 6;
|
c@14
|
174 d3.isQuantized = true;
|
c@14
|
175 d3.quantizeStep = 1;
|
c@14
|
176 for (int i = d3.minValue; i <= d3.maxValue; i++){
|
c@14
|
177 d3.valueNames.push_back(floatToString(pow((float)2,(float)i)));
|
c@14
|
178 }
|
c@14
|
179 list.push_back(d3);
|
c@9
|
180
|
c@14
|
181 ParameterDescriptor d4;
|
c@14
|
182 d4.identifier = "log2FftLength";
|
c@14
|
183 d4.name = "Tempogram FFT Length";
|
c@14
|
184 d4.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
|
185 d4.unit = "";
|
c@14
|
186 d4.minValue = 6;
|
c@14
|
187 d4.maxValue = 12;
|
c@14
|
188 d4.defaultValue = d2.defaultValue;
|
c@14
|
189 d4.isQuantized = true;
|
c@14
|
190 d4.quantizeStep = 1;
|
c@14
|
191 for (int i = d4.minValue; i <= d4.maxValue; i++){
|
c@14
|
192 d4.valueNames.push_back(floatToString(pow((float)2,(float)i)));
|
c@14
|
193 }
|
c@14
|
194 list.push_back(d4);
|
c@14
|
195
|
c@14
|
196 ParameterDescriptor d5;
|
c@14
|
197 d5.identifier = "minBPM";
|
c@18
|
198 d5.name = "(Cyclic) Tempogram Minimum BPM";
|
c@14
|
199 d5.description = "The minimum BPM of the tempogram output bins.";
|
c@14
|
200 d5.unit = "";
|
c@14
|
201 d5.minValue = 0;
|
c@14
|
202 d5.maxValue = 2000;
|
c@14
|
203 d5.defaultValue = 30;
|
c@14
|
204 d5.isQuantized = true;
|
c@14
|
205 d5.quantizeStep = 5;
|
c@14
|
206 list.push_back(d5);
|
c@14
|
207
|
c@14
|
208 ParameterDescriptor d6;
|
c@14
|
209 d6.identifier = "maxBPM";
|
c@18
|
210 d6.name = "(Cyclic) Tempogram Maximum BPM";
|
c@18
|
211 d6.description = "The maximum BPM of the tempogram output bins.";
|
c@14
|
212 d6.unit = "";
|
c@14
|
213 d6.minValue = 30;
|
c@14
|
214 d6.maxValue = 2000;
|
c@14
|
215 d6.defaultValue = 480;
|
c@14
|
216 d6.isQuantized = true;
|
c@14
|
217 d6.quantizeStep = 5;
|
c@14
|
218 list.push_back(d6);
|
c@18
|
219
|
c@18
|
220 ParameterDescriptor d7;
|
c@18
|
221 d7.identifier = "octDiv";
|
c@18
|
222 d7.name = "Cyclic Tempogram Octave Divider";
|
c@18
|
223 d7.description = "The number bins within each octave.";
|
c@18
|
224 d7.unit = "";
|
c@18
|
225 d7.minValue = 5;
|
c@18
|
226 d7.maxValue = 60;
|
c@18
|
227 d7.defaultValue = 30;
|
c@18
|
228 d7.isQuantized = true;
|
c@18
|
229 d7.quantizeStep = 1;
|
c@18
|
230 list.push_back(d7);
|
c@0
|
231
|
c@0
|
232 return list;
|
c@0
|
233 }
|
c@0
|
234
|
c@0
|
235 float
|
c@14
|
236 TempogramPlugin::getParameter(string identifier) const
|
c@0
|
237 {
|
c@0
|
238 if (identifier == "C") {
|
c@18
|
239 return m_noveltyCurveCompressionConstant; // return the ACTUAL current value of your parameter here!
|
c@0
|
240 }
|
c@14
|
241 else if (identifier == "log2TN"){
|
c@18
|
242 return m_tempogramLog2WindowLength;
|
c@9
|
243 }
|
c@14
|
244 else if (identifier == "log2HopSize"){
|
c@18
|
245 return m_tempogramLog2HopSize;
|
c@14
|
246 }
|
c@14
|
247 else if (identifier == "log2FftLength"){
|
c@18
|
248 return m_tempogramLog2FftLength;
|
c@14
|
249 }
|
c@14
|
250 else if (identifier == "minBPM") {
|
c@18
|
251 return m_tempogramMinBPM;
|
c@9
|
252 }
|
c@14
|
253 else if (identifier == "maxBPM"){
|
c@18
|
254 return m_tempogramMaxBPM;
|
c@18
|
255 }
|
c@18
|
256 else if (identifier == "octDiv"){
|
c@18
|
257 return m_cyclicTempogramOctaveDivider;
|
c@0
|
258 }
|
c@0
|
259
|
c@0
|
260 return 0;
|
c@0
|
261 }
|
c@0
|
262
|
c@0
|
263 void
|
c@14
|
264 TempogramPlugin::setParameter(string identifier, float value)
|
c@0
|
265 {
|
c@9
|
266
|
c@0
|
267 if (identifier == "C") {
|
c@18
|
268 m_noveltyCurveCompressionConstant = value; // set the actual value of your parameter
|
c@0
|
269 }
|
c@14
|
270 else if (identifier == "log2TN") {
|
c@18
|
271 m_tempogramWindowLength = pow(2,value);
|
c@18
|
272 m_tempogramLog2WindowLength = value;
|
c@0
|
273 }
|
c@14
|
274 else if (identifier == "log2HopSize"){
|
c@18
|
275 m_tempogramHopSize = pow(2,value);
|
c@18
|
276 m_tempogramLog2HopSize = value;
|
c@14
|
277 }
|
c@18
|
278 else if (identifier == "log2FftLength"){
|
c@18
|
279 m_tempogramFftLength = pow(2,value);
|
c@18
|
280 m_tempogramLog2FftLength = value;
|
c@14
|
281 }
|
c@14
|
282 else if (identifier == "minBPM") {
|
c@18
|
283 m_tempogramMinBPM = value;
|
c@9
|
284 }
|
c@14
|
285 else if (identifier == "maxBPM"){
|
c@18
|
286 m_tempogramMaxBPM = value;
|
c@18
|
287 }
|
c@18
|
288 else if (identifier == "octDiv"){
|
c@18
|
289 m_cyclicTempogramOctaveDivider = value;
|
c@9
|
290 }
|
c@9
|
291
|
c@9
|
292 }
|
c@9
|
293
|
c@14
|
294 TempogramPlugin::ProgramList
|
c@14
|
295 TempogramPlugin::getPrograms() const
|
c@0
|
296 {
|
c@0
|
297 ProgramList list;
|
c@0
|
298
|
c@0
|
299 // If you have no programs, return an empty list (or simply don't
|
c@0
|
300 // implement this function or getCurrentProgram/selectProgram)
|
c@0
|
301
|
c@0
|
302 return list;
|
c@0
|
303 }
|
c@0
|
304
|
c@0
|
305 string
|
c@14
|
306 TempogramPlugin::getCurrentProgram() const
|
c@0
|
307 {
|
c@0
|
308 return ""; // no programs
|
c@0
|
309 }
|
c@0
|
310
|
c@0
|
311 void
|
c@14
|
312 TempogramPlugin::selectProgram(string name)
|
c@0
|
313 {
|
c@0
|
314 }
|
c@0
|
315
|
c@14
|
316 TempogramPlugin::OutputList
|
c@14
|
317 TempogramPlugin::getOutputDescriptors() const
|
c@0
|
318 {
|
c@0
|
319 OutputList list;
|
c@0
|
320
|
c@0
|
321 // See OutputDescriptor documentation for the possibilities here.
|
c@0
|
322 // Every plugin must have at least one output.
|
c@1
|
323
|
c@7
|
324 float d_sampleRate;
|
c@18
|
325 float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
|
c@7
|
326
|
c@25
|
327 OutputDescriptor d1;
|
c@25
|
328 d1.identifier = "cyclicTempogram";
|
c@25
|
329 d1.name = "Cyclic Tempogram";
|
c@25
|
330 d1.description = "Cyclic Tempogram";
|
c@25
|
331 d1.unit = "";
|
c@25
|
332 d1.hasFixedBinCount = true;
|
c@25
|
333 d1.binCount = m_cyclicTempogramOctaveDivider > 0 && !isnan(m_cyclicTempogramOctaveDivider) ? m_cyclicTempogramOctaveDivider : 0;
|
c@25
|
334 d1.hasKnownExtents = false;
|
c@25
|
335 d1.isQuantized = false;
|
c@25
|
336 d1.sampleType = OutputDescriptor::FixedSampleRate;
|
c@25
|
337 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
|
c@25
|
338 d1.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
|
c@25
|
339 d1.hasDuration = false;
|
c@25
|
340 list.push_back(d1);
|
c@25
|
341
|
c@25
|
342 OutputDescriptor d2;
|
c@25
|
343 d2.identifier = "tempogramDFT";
|
c@25
|
344 d2.name = "Tempogram via DFT";
|
c@25
|
345 d2.description = "Tempogram via DFT";
|
c@25
|
346 d2.unit = "BPM";
|
c@25
|
347 d2.hasFixedBinCount = true;
|
c@25
|
348 d2.binCount = m_tempogramMaxBin - m_tempogramMinBin + 1;
|
c@25
|
349 d2.hasKnownExtents = false;
|
c@25
|
350 d2.isQuantized = false;
|
c@25
|
351 d2.sampleType = OutputDescriptor::FixedSampleRate;
|
c@25
|
352 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
|
c@25
|
353 d2.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0.0;
|
c@25
|
354 for(int i = m_tempogramMinBin; i <= (int)m_tempogramMaxBin; i++){
|
c@25
|
355 float w = ((float)i/m_tempogramFftLength)*(tempogramInputSampleRate);
|
c@25
|
356 d2.binNames.push_back(floatToString(w*60));
|
c@25
|
357 }
|
c@25
|
358 d2.hasDuration = false;
|
c@25
|
359 list.push_back(d2);
|
c@25
|
360
|
c@21
|
361 OutputDescriptor d3;
|
c@25
|
362 d3.identifier = "tempogramACT";
|
c@25
|
363 d3.name = "Tempogram via ACT";
|
c@25
|
364 d3.description = "Tempogram via ACT";
|
c@25
|
365 d3.unit = "BPM";
|
c@21
|
366 d3.hasFixedBinCount = true;
|
c@28
|
367 d3.binCount = m_tempogramMaxLag - m_tempogramMinLag + 1;
|
c@21
|
368 d3.hasKnownExtents = false;
|
c@21
|
369 d3.isQuantized = false;
|
c@21
|
370 d3.sampleType = OutputDescriptor::FixedSampleRate;
|
c@21
|
371 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
|
c@25
|
372 d3.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0.0;
|
c@28
|
373 for(int lag = m_tempogramMaxLag; lag >= (int)m_tempogramMinLag; lag--){
|
c@28
|
374 d3.binNames.push_back(floatToString(60/(m_inputStepSize*(lag/m_inputSampleRate))));
|
c@25
|
375 }
|
c@21
|
376 d3.hasDuration = false;
|
c@21
|
377 list.push_back(d3);
|
c@21
|
378
|
c@25
|
379 OutputDescriptor d4;
|
c@25
|
380 d4.identifier = "nc";
|
c@25
|
381 d4.name = "Novelty Curve";
|
c@25
|
382 d4.description = "Novelty Curve";
|
c@25
|
383 d4.unit = "";
|
c@25
|
384 d4.hasFixedBinCount = true;
|
c@25
|
385 d4.binCount = 1;
|
c@25
|
386 d4.hasKnownExtents = false;
|
c@25
|
387 d4.isQuantized = false;
|
c@25
|
388 d4.sampleType = OutputDescriptor::FixedSampleRate;
|
c@9
|
389 d_sampleRate = tempogramInputSampleRate;
|
c@25
|
390 d4.sampleRate = d_sampleRate > 0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
|
c@25
|
391 d4.hasDuration = false;
|
c@25
|
392 list.push_back(d4);
|
c@18
|
393
|
c@0
|
394 return list;
|
c@0
|
395 }
|
c@0
|
396
|
c@20
|
397 bool
|
c@20
|
398 TempogramPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
|
c@20
|
399 {
|
c@20
|
400 if (channels < getMinChannelCount() ||
|
c@20
|
401 channels > getMaxChannelCount()) return false;
|
c@20
|
402
|
c@20
|
403 // Real initialisation work goes here!
|
c@20
|
404 m_inputBlockSize = blockSize;
|
c@20
|
405 m_inputStepSize = stepSize;
|
c@20
|
406
|
c@24
|
407 //m_spectrogram = Spectrogram(m_inputBlockSize/2 + 1);
|
c@21
|
408 if (!handleParameterValues()) return false;
|
c@19
|
409 //cout << m_cyclicTempogramOctaveDivider << endl;
|
c@4
|
410
|
c@0
|
411 return true;
|
c@0
|
412 }
|
c@0
|
413
|
c@0
|
414 void
|
c@14
|
415 TempogramPlugin::reset()
|
c@0
|
416 {
|
c@0
|
417 // Clear buffers, reset stored values, etc
|
c@19
|
418 m_spectrogram.clear();
|
c@21
|
419 handleParameterValues();
|
c@0
|
420 }
|
c@0
|
421
|
c@14
|
422 TempogramPlugin::FeatureSet
|
c@14
|
423 TempogramPlugin::process(const float *const *inputBuffers, Vamp::RealTime timestamp)
|
c@0
|
424 {
|
c@0
|
425
|
c@23
|
426 int n = m_inputBlockSize/2 + 1;
|
c@0
|
427 const float *in = inputBuffers[0];
|
c@3
|
428
|
c@9
|
429 //calculate magnitude of FrequencyDomain input
|
c@22
|
430 vector<float> fftCoefficients;
|
c@23
|
431 for (int i = 0; i < n; i++){
|
c@0
|
432 float magnitude = sqrt(in[2*i] * in[2*i] + in[2*i + 1] * in[2*i + 1]);
|
c@18
|
433 magnitude = magnitude > m_noveltyCurveMinDB ? magnitude : m_noveltyCurveMinDB;
|
c@22
|
434 fftCoefficients.push_back(magnitude);
|
c@0
|
435 }
|
c@22
|
436 m_spectrogram.push_back(fftCoefficients);
|
c@24
|
437 //m_spectrogram.push_back(fftCoefficients);
|
c@21
|
438
|
c@23
|
439 return FeatureSet();
|
c@0
|
440 }
|
c@0
|
441
|
c@14
|
442 TempogramPlugin::FeatureSet
|
c@14
|
443 TempogramPlugin::getRemainingFeatures()
|
c@11
|
444 {
|
c@0
|
445
|
c@18
|
446 float * hannWindow = new float[m_tempogramWindowLength];
|
c@20
|
447 for (int i = 0; i < (int)m_tempogramWindowLength; i++){
|
c@14
|
448 hannWindow[i] = 0.0;
|
c@4
|
449 }
|
c@11
|
450
|
c@1
|
451 FeatureSet featureSet;
|
c@0
|
452
|
c@19
|
453 //initialise novelty curve processor
|
c@23
|
454 int numberOfBlocks = m_spectrogram.size();
|
c@20
|
455 //cerr << numberOfBlocks << endl;
|
c@22
|
456 NoveltyCurveProcessor nc(m_inputSampleRate, m_inputBlockSize, m_noveltyCurveCompressionConstant);
|
c@21
|
457 vector<float> noveltyCurve = nc.spectrogramToNoveltyCurve(m_spectrogram); //calculate novelty curvefrom magnitude data
|
c@4
|
458
|
c@9
|
459 //push novelty curve data to featureset 1 and set timestamps
|
c@23
|
460 for (int i = 0; i < numberOfBlocks; i++){
|
c@19
|
461 Feature noveltyCurveFeature;
|
c@19
|
462 noveltyCurveFeature.values.push_back(noveltyCurve[i]);
|
c@19
|
463 noveltyCurveFeature.hasTimestamp = false;
|
c@25
|
464 featureSet[3].push_back(noveltyCurveFeature);
|
c@21
|
465 assert(!isnan(noveltyCurveFeature.values.back()));
|
c@4
|
466 }
|
c@4
|
467
|
c@9
|
468 //window function for spectrogram
|
c@18
|
469 WindowFunction::hanning(hannWindow, m_tempogramWindowLength);
|
c@9
|
470
|
c@9
|
471 //initialise spectrogram processor
|
c@18
|
472 SpectrogramProcessor spectrogramProcessor(m_tempogramWindowLength, m_tempogramFftLength, m_tempogramHopSize);
|
c@9
|
473 //compute spectrogram from novelty curve data (i.e., tempogram)
|
c@25
|
474 Tempogram tempogramDFT = spectrogramProcessor.process(&noveltyCurve[0], numberOfBlocks, hannWindow);
|
c@18
|
475 delete []hannWindow;
|
c@18
|
476 hannWindow = 0;
|
c@0
|
477
|
c@25
|
478 int tempogramLength = tempogramDFT.size();
|
c@7
|
479
|
c@9
|
480 //push tempogram data to featureset 0 and set timestamps.
|
c@7
|
481 for (int block = 0; block < tempogramLength; block++){
|
c@25
|
482 Feature tempogramDFTFeature;
|
c@28
|
483
|
c@28
|
484 assert(tempogramDFT[block].size() == (m_tempogramFftLength/2 + 1));
|
c@28
|
485 for(int k = m_tempogramMinBin; k <= (int)m_tempogramMaxBin; k++){
|
c@28
|
486 tempogramDFTFeature.values.push_back(tempogramDFT[block][k]);
|
c@28
|
487 }
|
c@28
|
488 tempogramDFTFeature.hasTimestamp = false;
|
c@28
|
489 featureSet[1].push_back(tempogramDFTFeature);
|
c@28
|
490 }
|
c@28
|
491
|
c@28
|
492 AutocorrelationProcessor autocorrelationProcessor(m_tempogramWindowLength, m_tempogramHopSize);
|
c@28
|
493 Tempogram tempogramACT = autocorrelationProcessor.process(&noveltyCurve[0], numberOfBlocks);
|
c@28
|
494
|
c@28
|
495 for (int block = 0; block < tempogramLength; block++){
|
c@25
|
496 Feature tempogramACTFeature;
|
c@0
|
497
|
c@28
|
498 for(int k = m_tempogramMaxLag; k >= (int)m_tempogramMinLag; k--){
|
c@25
|
499 tempogramACTFeature.values.push_back(tempogramACT[block][k]);
|
c@0
|
500 }
|
c@25
|
501 tempogramACTFeature.hasTimestamp = false;
|
c@25
|
502 featureSet[2].push_back(tempogramACTFeature);
|
c@0
|
503 }
|
c@0
|
504
|
c@18
|
505 //Calculate cyclic tempogram
|
c@22
|
506 vector< vector<unsigned int> > logBins = calculateTempogramNearestNeighbourLogBins();
|
c@18
|
507
|
c@22
|
508 //assert((int)logBins.size() == m_cyclicTempogramOctaveDivider*m_cyclicTempogramNumberOfOctaves);
|
c@18
|
509 for (int block = 0; block < tempogramLength; block++){
|
c@19
|
510 Feature cyclicTempogramFeature;
|
c@18
|
511
|
c@23
|
512 for (int i = 0; i < m_cyclicTempogramOctaveDivider; i++){
|
c@18
|
513 float sum = 0;
|
c@21
|
514
|
c@23
|
515 for (int j = 0; j < m_cyclicTempogramNumberOfOctaves; j++){
|
c@25
|
516 sum += tempogramDFT[block][logBins[j][i]];
|
c@18
|
517 }
|
c@19
|
518 cyclicTempogramFeature.values.push_back(sum/m_cyclicTempogramNumberOfOctaves);
|
c@21
|
519 assert(!isnan(cyclicTempogramFeature.values.back()));
|
c@18
|
520 }
|
c@18
|
521
|
c@19
|
522 cyclicTempogramFeature.hasTimestamp = false;
|
c@21
|
523 featureSet[0].push_back(cyclicTempogramFeature);
|
c@18
|
524 }
|
c@0
|
525
|
c@0
|
526 return featureSet;
|
c@0
|
527 }
|
c@22
|
528
|
c@22
|
529 vector< vector<unsigned int> > TempogramPlugin::calculateTempogramNearestNeighbourLogBins() const
|
c@22
|
530 {
|
c@22
|
531 vector< vector<unsigned int> > logBins;
|
c@22
|
532
|
c@22
|
533 for (int octave = 0; octave < (int)m_cyclicTempogramNumberOfOctaves; octave++){
|
c@22
|
534 vector<unsigned int> octaveBins;
|
c@22
|
535
|
c@22
|
536 for (int bin = 0; bin < (int)m_cyclicTempogramOctaveDivider; bin++){
|
c@22
|
537 float bpm = m_cyclicTempogramMinBPM*pow(2.0f, octave+(float)bin/m_cyclicTempogramOctaveDivider);
|
c@22
|
538 octaveBins.push_back(bpmToBin(bpm));
|
c@23
|
539 //cout << octaveBins.back() << endl;
|
c@22
|
540 }
|
c@22
|
541 logBins.push_back(octaveBins);
|
c@22
|
542 }
|
c@22
|
543
|
c@22
|
544 //cerr << logBins.size() << endl;
|
c@22
|
545
|
c@22
|
546 return logBins;
|
c@22
|
547 }
|
c@22
|
548
|
c@22
|
549 unsigned int TempogramPlugin::bpmToBin(const float &bpm) const
|
c@22
|
550 {
|
c@22
|
551 float w = (float)bpm/60;
|
c@22
|
552 float sampleRate = m_inputSampleRate/m_inputStepSize;
|
c@22
|
553 int bin = floor((float)m_tempogramFftLength*w/sampleRate + 0.5);
|
c@22
|
554
|
c@22
|
555 if(bin < 0) bin = 0;
|
c@22
|
556 else if(bin > m_tempogramFftLength/2.0f) bin = m_tempogramFftLength;
|
c@22
|
557
|
c@22
|
558 return bin;
|
c@22
|
559 }
|
c@22
|
560
|
c@22
|
561 float TempogramPlugin::binToBPM(const int &bin) const
|
c@22
|
562 {
|
c@22
|
563 float sampleRate = m_inputSampleRate/m_inputStepSize;
|
c@22
|
564
|
c@22
|
565 return (bin*sampleRate/m_tempogramFftLength)*60;
|
c@22
|
566 }
|
c@22
|
567
|
c@22
|
568 bool TempogramPlugin::handleParameterValues(){
|
c@22
|
569
|
c@22
|
570 if (m_tempogramHopSize <= 0) return false;
|
c@22
|
571 if (m_tempogramLog2FftLength <= 0) return false;
|
c@22
|
572
|
c@22
|
573 if (m_tempogramFftLength < m_tempogramWindowLength){
|
c@22
|
574 m_tempogramFftLength = m_tempogramWindowLength;
|
c@22
|
575 }
|
c@22
|
576 if (m_tempogramMinBPM >= m_tempogramMaxBPM){
|
c@22
|
577 m_tempogramMinBPM = 30;
|
c@22
|
578 m_tempogramMaxBPM = 480;
|
c@22
|
579 }
|
c@22
|
580
|
c@22
|
581 float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
|
c@28
|
582 m_tempogramMinBin = (max((int)floor(((m_tempogramMinBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), 0));
|
c@28
|
583 m_tempogramMaxBin = (min((int)ceil(((m_tempogramMaxBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), (int)(m_tempogramFftLength/2)));
|
c@28
|
584
|
c@28
|
585 m_tempogramMinLag = max((int)ceil((60/(m_inputStepSize * m_tempogramMaxBPM))*m_inputSampleRate), 0);
|
c@28
|
586 m_tempogramMaxLag = min((int)floor((60/(m_inputStepSize * m_tempogramMinBPM))*m_inputSampleRate), (int)m_tempogramWindowLength);
|
c@22
|
587
|
c@25
|
588 if (m_tempogramMinBPM > m_cyclicTempogramMinBPM) m_cyclicTempogramMinBPM = m_tempogramMinBPM; //m_cyclicTempogram can't be less than default = 30
|
c@22
|
589 float cyclicTempogramMaxBPM = 480;
|
c@22
|
590 if (m_tempogramMaxBPM < cyclicTempogramMaxBPM) cyclicTempogramMaxBPM = m_tempogramMaxBPM;
|
c@22
|
591
|
c@22
|
592 m_cyclicTempogramNumberOfOctaves = floor(log2(cyclicTempogramMaxBPM/m_cyclicTempogramMinBPM));
|
c@22
|
593
|
c@22
|
594 return true;
|
c@22
|
595 }
|
c@22
|
596
|
c@22
|
597 string TempogramPlugin::floatToString(float value) const
|
c@22
|
598 {
|
c@22
|
599 ostringstream ss;
|
c@22
|
600
|
c@22
|
601 if(!(ss << value)) throw runtime_error("TempogramPlugin::floatToString(): invalid conversion from float to string");
|
c@22
|
602 return ss.str();
|
c@22
|
603 }
|