1 /*
2 MPEG Maaate: An Australian MPEG audio analysis toolkit
3 Copyright (C) 2000 Commonwealth Scientific and Industrial Research Organisation
4 (CSIRO), Australia.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include "maaateM_brief.H"
26
27
28 using namespace std;
29
30 CSAPI_PLUGINS_BRIEF SegmentData *
variance(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,double dur=1.0)31 variance(Plugins * plugins, SegmentData *sd,
32 double from=0.0, double to=FLT_MAX,
33 double dur = 1.0) {
34
35 // calculate low Nrj
36 Module * m = plugins->GetModule(string("variance"));
37 if (m==NULL) {
38 return NULL;
39 }
40
41 // get default values
42 list<ModuleParam> * paramsIn = m->defaultValues();
43 if (paramsIn->size() == 0) {
44 return NULL;
45 }
46
47 // set parameters
48 list<ModuleParam>::iterator iter;
49 iter=paramsIn->begin();
50 (*iter).set(sd); // set the Segment Data ptr.
51 ++iter; (*iter).set(from);
52 ++iter; (*iter).set(to);
53 ++iter; (*iter).set(dur);
54
55 // suggest and check parameters
56 m->suggestValues(paramsIn);
57
58 // execute module
59 list<ModuleParam> * paramsOut = m->apply(paramsIn);
60 if (paramsOut->size() == 0) {
61 return NULL;
62 }
63
64 return paramsOut->front().get_sd();
65 }
66
67 CSAPI_PLUGINS_BRIEF SegmentData *
sumScalefactors(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)68 sumScalefactors(Plugins * plugins, SOUNDfile *sfile,
69 double from=0.0, double to=FLT_MAX,
70 int fromSb=0, int toSb=575) {
71
72 // calculate sum of scalefactors (loudness approx)
73 Module * m = plugins->GetModule(string("sumscf"));
74 if (m==NULL) {
75 return NULL;
76 }
77
78 // get default values
79 list<ModuleParam> * paramsIn = m->defaultValues();
80 if (paramsIn->size() == 0) {
81 return NULL;
82 }
83
84 // set parameters
85 list<ModuleParam>::iterator iter;
86 iter=paramsIn->begin();
87 (*iter).set(sfile); // set the Soundfile ptr.
88 ++iter; (*iter).set(from);
89 ++iter; (*iter).set(to);
90 ++iter; (*iter).set(fromSb);
91 ++iter; (*iter).set(toSb);
92
93 // suggest and check parameters
94 m->suggestValues(paramsIn);
95
96 // execute module
97 list<ModuleParam> * paramsOut = m->apply(paramsIn);
98 if (paramsOut->size() == 0) {
99 return NULL;
100 }
101
102 return paramsOut->front().get_sd();
103 }
104
105 CSAPI_PLUGINS_BRIEF SegmentData *
lowNrj(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,double dur=1.0)106 lowNrj(Plugins * plugins, SegmentData *sd,
107 double from=0.0, double to=FLT_MAX,
108 double dur = 1.0) {
109
110 // calculate low Nrj
111 Module * m = plugins->GetModule(string("lowNrj"));
112 if (m==NULL) {
113 return NULL;
114 }
115
116 // get default values
117 list<ModuleParam> * paramsIn = m->defaultValues();
118 if (paramsIn->size() == 0) {
119 return NULL;
120 }
121
122 // set parameters
123 list<ModuleParam>::iterator iter;
124 iter=paramsIn->begin();
125 (*iter).set(sd); // set the Segment Data ptr.
126 ++iter; (*iter).set(from);
127 ++iter; (*iter).set(to);
128 ++iter; (*iter).set(dur);
129
130 // suggest and check parameters
131 m->suggestValues(paramsIn);
132
133 // execute module
134 list<ModuleParam> * paramsOut = m->apply(paramsIn);
135 if (paramsOut->size() == 0) {
136 return NULL;
137 }
138
139 return paramsOut->front().get_sd();
140 }
141
142 CSAPI_PLUGINS_BRIEF SegmentData *
spectralCentroid(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)143 spectralCentroid(Plugins * plugins, SOUNDfile *sfile,
144 double from=0.0, double to=FLT_MAX,
145 int fromSb=0, int toSb=575) {
146 // calculate spectral centroid (brightness approx)
147 Module * m = plugins->GetModule(string("centroid"));
148 if (m==NULL) {
149 return NULL;
150 }
151
152 // get default values
153 list<ModuleParam> * paramsIn = m->defaultValues();
154 if (paramsIn->size() == 0) {
155 return NULL;
156 }
157
158 // set parameters
159 list<ModuleParam>::iterator iter;
160 iter=paramsIn->begin();
161 (*iter).set(sfile); // set the Soundfile ptr.
162 ++iter; (*iter).set(from);
163 ++iter; (*iter).set(to);
164 ++iter; (*iter).set(fromSb);
165 ++iter; (*iter).set(toSb);
166
167 // suggest and check parameters
168 m->suggestValues(paramsIn);
169
170 // execute module
171 list<ModuleParam> * paramsOut = m->apply(paramsIn);
172 if (paramsOut->size() == 0) {
173 return NULL;
174 }
175
176 return paramsOut->front().get_sd();
177 }
178
179
180 CSAPI_PLUGINS_BRIEF double
backgroundNoiseLevel(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,double minDur=0.1,double maxInterrupt=0.0,double onsetTime=0.01,double releaseTime=0.01)181 backgroundNoiseLevel(Plugins * plugins, SegmentData *sd,
182 double from=0.0, double to=FLT_MAX,
183 double minDur=0.1, double maxInterrupt=0.0,
184 double onsetTime=0.01, double releaseTime=0.01) {
185
186 // calculate background noise level
187 Module * m = plugins->GetModule(string("bgnoiselevel"));
188 if (m==NULL) {
189 return -1.0;
190 }
191
192 // get default values
193 list<ModuleParam> * paramsIn = m->defaultValues();
194 if (paramsIn->size() == 0) {
195 return -1.0;
196 }
197
198 // set parameters
199 list<ModuleParam>::iterator iter;
200 iter=paramsIn->begin();
201 (*iter).set(sd); // set the sumscf loudness approximation function
202 ++iter; (*iter).set(from);
203 ++iter; (*iter).set(to);
204 ++iter; (*iter).set(minDur);
205 ++iter; (*iter).set(maxInterrupt);
206 ++iter; (*iter).set(onsetTime);
207 ++iter; (*iter).set(releaseTime);
208
209 // suggest and check parameters
210 m->suggestValues(paramsIn);
211
212 // execute module
213 list<ModuleParam> * paramsOut = m->apply(paramsIn);
214 if (paramsOut->size() == 0) {
215 return -1.0;
216 }
217
218 return paramsOut->front().get_r();
219 }
220
221
222 CSAPI_PLUGINS_BRIEF SegmentTable *
silenceSegmentation(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,double thresh=0.01,double minDur=0.1,double maxInterrupt=0.0,double onsetTime=0.01,double releaseTime=0.01)223 silenceSegmentation(Plugins * plugins, SegmentData *sd,
224 double from=0.0, double to=FLT_MAX,
225 double thresh=0.01, double minDur=0.1, double maxInterrupt=0.0,
226 double onsetTime=0.01, double releaseTime=0.01) {
227
228 // calculate silence segments
229 Module * m = plugins->GetModule(string("silence"));
230 if (m==NULL) {
231 return NULL;
232 }
233
234 // get default values
235 list<ModuleParam> * paramsIn = m->defaultValues();
236 if (paramsIn->size() == 0) {
237 return NULL;
238 }
239
240 // set parameters
241 list<ModuleParam>::iterator iter;
242 iter=paramsIn->begin();
243 (*iter).set(sd); // set the sumscf loudness approximation function
244 ++iter; (*iter).set(from);
245 ++iter; (*iter).set(to);
246 ++iter; (*iter).set(thresh);
247 ++iter; (*iter).set(minDur);
248 ++iter; (*iter).set(maxInterrupt);
249 ++iter; (*iter).set(onsetTime);
250 ++iter; (*iter).set(releaseTime);
251
252 // suggest and check parameters
253 m->suggestValues(paramsIn);
254 if (paramsIn->size() == 0) {
255 return NULL;
256 }
257
258 // execute module
259 list<ModuleParam> * paramsOut = m->apply(paramsIn);
260 if (paramsOut->size() == 0) {
261 return NULL;
262 }
263
264 return paramsOut->front().get_st();
265 }
266
267
268 CSAPI_PLUGINS_BRIEF SegmentTable *
noiseSegmentation(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,double thresh=0.01,double minDur=0.1,double maxInterrupt=0.0,double onsetTime=0.01,double releaseTime=0.01)269 noiseSegmentation(Plugins * plugins, SegmentData *sd,
270 double from=0.0, double to=FLT_MAX,
271 double thresh=0.01, double minDur=0.1, double maxInterrupt=0.0,
272 double onsetTime=0.01, double releaseTime=0.01) {
273
274 // calculate noise segmentation
275 Module * m = plugins->GetModule(string("noise"));
276 if (m==NULL) {
277 return NULL;
278 }
279
280 // get default values
281 list<ModuleParam> * paramsIn = m->defaultValues();
282 if (paramsIn->size()==0) {
283 return NULL;
284 }
285
286 // set parameters
287 list<ModuleParam>::iterator iter;
288 iter=paramsIn->begin();
289 (*iter).set(sd); // set the sumscf loudness approximation function
290 ++iter; (*iter).set(from);
291 ++iter; (*iter).set(to);
292 ++iter; (*iter).set(thresh);
293 ++iter; (*iter).set(minDur);
294 ++iter; (*iter).set(maxInterrupt);
295 ++iter; (*iter).set(onsetTime);
296 ++iter; (*iter).set(releaseTime);
297
298 // suggest and check parameters
299 m->suggestValues(paramsIn);
300 if (paramsIn->size() == 0) {
301 return NULL;
302 }
303
304 // execute module
305 list<ModuleParam> * paramsOut = m->apply(paramsIn);
306 if (paramsOut->size() == 0) {
307 return NULL;
308 }
309
310 return paramsOut->front().get_st();
311 }
312
313
314 CSAPI_PLUGINS_BRIEF SegmentTable *
segmentation(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,bool below=true,double thresh=0.01,double minDur=0.1,double maxInterrupt=0.0,double onsetTime=0.01,double releaseTime=0.01)315 segmentation(Plugins * plugins, SegmentData *sd,
316 double from=0.0, double to=FLT_MAX,
317 bool below=true, double thresh=0.01,
318 double minDur=0.1, double maxInterrupt=0.0,
319 double onsetTime=0.01, double releaseTime=0.01) {
320
321 // calculate noise segmentation
322 Module * m = plugins->GetModule(string("segmentation"));
323 if (m==NULL) {
324 return NULL;
325 }
326
327 // get default values
328 list<ModuleParam> * paramsIn = m->defaultValues();
329 if (paramsIn->size()==0) {
330 return NULL;
331 }
332
333 // set parameters
334 list<ModuleParam>::iterator iter;
335 iter=paramsIn->begin();
336 (*iter).set(sd);
337 ++iter; (*iter).set(from);
338 ++iter; (*iter).set(to);
339 ++iter; (*iter).set(below);
340 ++iter; (*iter).set(thresh);
341 ++iter; (*iter).set(minDur);
342 ++iter; (*iter).set(maxInterrupt);
343 ++iter; (*iter).set(onsetTime);
344 ++iter; (*iter).set(releaseTime);
345
346 // suggest and check parameters
347 m->suggestValues(paramsIn);
348 if (paramsIn->size() == 0) {
349 return NULL;
350 }
351
352 // execute module
353 list<ModuleParam> * paramsOut = m->apply(paramsIn);
354 if (paramsOut->size() == 0) {
355 return NULL;
356 }
357
358 return paramsOut->front().get_st();
359 }
360
361
362 CSAPI_PLUGINS_BRIEF ModuleParamList *
histo1D(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,int bins=10,double starthisto=DBL_MAX,double endhisto=DBL_MIN)363 histo1D(Plugins * plugins, SegmentData *sd,
364 double from=0.0, double to=FLT_MAX,
365 int bins=10, double starthisto=DBL_MAX, double endhisto=DBL_MIN) {
366
367 // calculate histogram
368 Module * m = plugins->GetModule(string("histogram1D"));
369 if (m==NULL) {
370 return NULL;
371 }
372
373 // get default values
374 list<ModuleParam> * paramsIn = m->defaultValues();
375 if (paramsIn->size()==0) {
376 return NULL;
377 }
378
379 // set parameters
380 list<ModuleParam>::iterator iter;
381 iter=paramsIn->begin();
382 (*iter).set(sd);
383 ++iter; (*iter).set(from);
384 ++iter; (*iter).set(to);
385 ++iter; (*iter).set(bins);
386 ++iter; (*iter).set(starthisto);
387 ++iter; (*iter).set(endhisto);
388
389 // suggest and check parameters
390 m->suggestValues(paramsIn);
391 if (paramsIn->size() == 0) {
392 return NULL;
393 }
394
395 // execute module
396 return m->apply(paramsIn);
397 }
398
399
400 /*-------------- SBnrj -----------------------------*/
401 CSAPI_PLUGINS_BRIEF SegmentData *
SBnrj(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)402 SBnrj(Plugins * plugins, SOUNDfile *sfile,
403 double from=0.0, double to=FLT_MAX,
404 int fromSb=0, int toSb=575) {
405
406 // calculate normalised subband energies
407 Module * m = plugins->GetModule(string("SBnrj"));
408 if (m==NULL) {
409 return NULL;
410 }
411
412 // get default values
413 list<ModuleParam> * paramsIn = m->defaultValues();
414 if (paramsIn->size() == 0) {
415 return NULL;
416 }
417
418 // set parameters
419 list<ModuleParam>::iterator iter;
420 iter=paramsIn->begin();
421 (*iter).set(sfile); // set the Soundfile ptr.
422 ++iter; (*iter).set(from);
423 ++iter; (*iter).set(to);
424 ++iter; (*iter).set(fromSb);
425 ++iter; (*iter).set(toSb);
426
427 // suggest and check parameters
428 m->suggestValues(paramsIn);
429
430 // execute module
431 list<ModuleParam> * paramsOut = m->apply(paramsIn);
432 if (paramsOut->size() == 0) {
433 return NULL;
434 }
435
436 return paramsOut->front().get_sd();
437 }
438
439 /*-------------- SBmean -----------------------------*/
440 CSAPI_PLUGINS_BRIEF SegmentData *
SBmean(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)441 SBmean(Plugins * plugins, SOUNDfile *sfile,
442 double from=0.0, double to=FLT_MAX,
443 int fromSb=0, int toSb=575) {
444
445 // calculate normalised subband energies
446 Module * m = plugins->GetModule(string("SBmean"));
447 if (m==NULL) {
448 return NULL;
449 }
450
451 // get default values
452 list<ModuleParam> * paramsIn = m->defaultValues();
453 if (paramsIn->size() == 0) {
454 return NULL;
455 }
456
457 // set parameters
458 list<ModuleParam>::iterator iter;
459 iter=paramsIn->begin();
460 (*iter).set(sfile); // set the Soundfile ptr.
461 ++iter; (*iter).set(from);
462 ++iter; (*iter).set(to);
463 ++iter; (*iter).set(fromSb);
464 ++iter; (*iter).set(toSb);
465
466 // suggest and check parameters
467 m->suggestValues(paramsIn);
468
469 // execute module
470 list<ModuleParam> * paramsOut = m->apply(paramsIn);
471 if (paramsOut->size() == 0) {
472 return NULL;
473 }
474
475 return paramsOut->front().get_sd();
476 }
477
478
479 /*-------------- SBrms -----------------------------*/
480 CSAPI_PLUGINS_BRIEF SegmentData *
SBrms(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)481 SBrms(Plugins * plugins, SOUNDfile *sfile,
482 double from=0.0, double to=FLT_MAX,
483 int fromSb=0, int toSb=575) {
484
485 // calculate normalised subband energies
486 Module * m = plugins->GetModule(string("SBrms"));
487 if (m==NULL) {
488 return NULL;
489 }
490
491 // get default values
492 list<ModuleParam> * paramsIn = m->defaultValues();
493 if (paramsIn->size() == 0) {
494 return NULL;
495 }
496
497 // set parameters
498 list<ModuleParam>::iterator iter;
499 iter=paramsIn->begin();
500 (*iter).set(sfile); // set the Soundfile ptr.
501 ++iter; (*iter).set(from);
502 ++iter; (*iter).set(to);
503 ++iter; (*iter).set(fromSb);
504 ++iter; (*iter).set(toSb);
505
506 // suggest and check parameters
507 m->suggestValues(paramsIn);
508
509 // execute module
510 list<ModuleParam> * paramsOut = m->apply(paramsIn);
511 if (paramsOut->size() == 0) {
512 return NULL;
513 }
514
515 return paramsOut->front().get_sd();
516 }
517
518 /*-------------- SBscf -----------------------------*/
519 CSAPI_PLUGINS_BRIEF SegmentData *
SBscf(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)520 SBscf(Plugins * plugins, SOUNDfile *sfile,
521 double from=0.0, double to=FLT_MAX,
522 int fromSb=0, int toSb=575) {
523
524 // calculate normalised subband energies
525 Module * m = plugins->GetModule(string("SBscf"));
526 if (m==NULL) {
527 return NULL;
528 }
529
530 // get default values
531 list<ModuleParam> * paramsIn = m->defaultValues();
532 if (paramsIn->size() == 0) {
533 return NULL;
534 }
535
536 // set parameters
537 list<ModuleParam>::iterator iter;
538 iter=paramsIn->begin();
539 (*iter).set(sfile); // set the Soundfile ptr.
540 ++iter; (*iter).set(from);
541 ++iter; (*iter).set(to);
542 ++iter; (*iter).set(fromSb);
543 ++iter; (*iter).set(toSb);
544
545 // suggest and check parameters
546 m->suggestValues(paramsIn);
547
548 // execute module
549 list<ModuleParam> * paramsOut = m->apply(paramsIn);
550 if (paramsOut->size() == 0) {
551 return NULL;
552 }
553
554 return paramsOut->front().get_sd();
555 }
556
557 /*-------------- SBvalue -----------------------------*/
558 CSAPI_PLUGINS_BRIEF SegmentData *
SBvalue(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)559 SBvalue(Plugins * plugins, SOUNDfile *sfile,
560 double from=0.0, double to=FLT_MAX,
561 int fromSb=0, int toSb=575) {
562
563 // calculate normalised subband energies
564 Module * m = plugins->GetModule(string("SBvalue"));
565 if (m==NULL) {
566 return NULL;
567 }
568
569 // get default values
570 list<ModuleParam> * paramsIn = m->defaultValues();
571 if (paramsIn->size() == 0) {
572 return NULL;
573 }
574
575 // set parameters
576 list<ModuleParam>::iterator iter;
577 iter=paramsIn->begin();
578 (*iter).set(sfile); // set the Soundfile ptr.
579 ++iter; (*iter).set(from);
580 ++iter; (*iter).set(to);
581 ++iter; (*iter).set(fromSb);
582 ++iter; (*iter).set(toSb);
583
584 // suggest and check parameters
585 m->suggestValues(paramsIn);
586
587 // execute module
588 list<ModuleParam> * paramsOut = m->apply(paramsIn);
589 if (paramsOut->size() == 0) {
590 return NULL;
591 }
592
593 return paramsOut->front().get_sd();
594 }
595
596 /*-------------- SBvaluemean -----------------------------*/
597 CSAPI_PLUGINS_BRIEF SegmentData *
SBvaluemean(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)598 SBvaluemean(Plugins * plugins, SOUNDfile *sfile,
599 double from=0.0, double to=FLT_MAX,
600 int fromSb=0, int toSb=575) {
601
602 // calculate normalised subband energies
603 Module * m = plugins->GetModule(string("SBvaluemean"));
604 if (m==NULL) {
605 return NULL;
606 }
607
608 // get default values
609 list<ModuleParam> * paramsIn = m->defaultValues();
610 if (paramsIn->size() == 0) {
611 return NULL;
612 }
613
614 // set parameters
615 list<ModuleParam>::iterator iter;
616 iter=paramsIn->begin();
617 (*iter).set(sfile); // set the Soundfile ptr.
618 ++iter; (*iter).set(from);
619 ++iter; (*iter).set(to);
620 ++iter; (*iter).set(fromSb);
621 ++iter; (*iter).set(toSb);
622
623 // suggest and check parameters
624 m->suggestValues(paramsIn);
625
626 // execute module
627 list<ModuleParam> * paramsOut = m->apply(paramsIn);
628 if (paramsOut->size() == 0) {
629 return NULL;
630 }
631
632 return paramsOut->front().get_sd();
633 }
634
635 /*-------------- SBvaluerms -----------------------------*/
636 CSAPI_PLUGINS_BRIEF SegmentData *
SBvaluerms(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)637 SBvaluerms(Plugins * plugins, SOUNDfile *sfile,
638 double from=0.0, double to=FLT_MAX,
639 int fromSb=0, int toSb=575) {
640
641 // calculate normalised subband energies
642 Module * m = plugins->GetModule(string("SBvaluerms"));
643 if (m==NULL) {
644 return NULL;
645 }
646
647 // get default values
648 list<ModuleParam> * paramsIn = m->defaultValues();
649 if (paramsIn->size() == 0) {
650 return NULL;
651 }
652
653 // set parameters
654 list<ModuleParam>::iterator iter;
655 iter=paramsIn->begin();
656 (*iter).set(sfile); // set the Soundfile ptr.
657 ++iter; (*iter).set(from);
658 ++iter; (*iter).set(to);
659 ++iter; (*iter).set(fromSb);
660 ++iter; (*iter).set(toSb);
661
662 // suggest and check parameters
663 m->suggestValues(paramsIn);
664
665 // execute module
666 list<ModuleParam> * paramsOut = m->apply(paramsIn);
667 if (paramsOut->size() == 0) {
668 return NULL;
669 }
670
671 return paramsOut->front().get_sd();
672 }
673
674 /*-------------- SBvaluenrj -----------------------------*/
675 CSAPI_PLUGINS_BRIEF SegmentData *
SBvaluenrj(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575)676 SBvaluenrj(Plugins * plugins, SOUNDfile *sfile,
677 double from=0.0, double to=FLT_MAX,
678 int fromSb=0, int toSb=575) {
679
680 // calculate normalised subband energies
681 Module * m = plugins->GetModule(string("SBvaluenrj"));
682 if (m==NULL) {
683 return NULL;
684 }
685
686 // get default values
687 list<ModuleParam> * paramsIn = m->defaultValues();
688 if (paramsIn->size() == 0) {
689 return NULL;
690 }
691
692 // set parameters
693 list<ModuleParam>::iterator iter;
694 iter=paramsIn->begin();
695 (*iter).set(sfile); // set the Soundfile ptr.
696 ++iter; (*iter).set(from);
697 ++iter; (*iter).set(to);
698 ++iter; (*iter).set(fromSb);
699 ++iter; (*iter).set(toSb);
700
701 // suggest and check parameters
702 m->suggestValues(paramsIn);
703
704 // execute module
705 list<ModuleParam> * paramsOut = m->apply(paramsIn);
706 if (paramsOut->size() == 0) {
707 return NULL;
708 }
709
710 return paramsOut->front().get_sd();
711 }
712
713 CSAPI_PLUGINS_BRIEF SegmentData *
BandNrjRatio(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int I=3,int w_nb=0)714 BandNrjRatio(Plugins * plugins, SOUNDfile *sfile,
715 double from = 0.0, double to = FLT_MAX,
716 int I = 3, int w_nb = 0) {
717
718 // calculate normalised subband energies
719 Module * m = plugins->GetModule(string("BandNrjRatio"));
720 if (m==NULL) {
721 return NULL;
722 }
723
724 // get default values
725 list<ModuleParam> * paramsIn = m->defaultValues();
726 if (paramsIn->size() == 0) {
727 return NULL;
728 }
729
730 // set parameters
731 list<ModuleParam>::iterator iter;
732 iter=paramsIn->begin();
733 (*iter).set(sfile); // set the Soundfile ptr.
734 ++iter; (*iter).set(from);
735 ++iter; (*iter).set(to);
736 ++iter; (*iter).set(I);
737 ++iter; (*iter).set(w_nb);
738
739 // suggest and check parameters
740 m->suggestValues(paramsIn);
741
742 // execute module
743 list<ModuleParam> * paramsOut = m->apply(paramsIn);
744 if (paramsOut->size() == 0) {
745 return NULL;
746 }
747
748 return paramsOut->front().get_sd();
749 }
750
751
752 CSAPI_PLUGINS_BRIEF Trio
bandwidth(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,double Ts=0.001)753 bandwidth(Plugins * plugins, SOUNDfile *sfile,
754 double from = 0.0 , double to = FLT_MAX,
755 double Ts = 0.001) {
756
757 Trio ret;
758 ret.uno =0;
759 ret.dos =0;
760 ret.tres = 0;
761 // calculate normalised subband energies
762 Module * m = plugins->GetModule(string("bandwidth"));
763 if (m==NULL) {
764 return ret;
765 }
766
767 // get default values
768 list<ModuleParam> * paramsIn = m->defaultValues();
769 if (paramsIn->size() == 0) {
770 return ret;
771 }
772
773 // set parameters
774 list<ModuleParam>::iterator iter;
775 iter=paramsIn->begin();
776 (*iter).set(sfile); // set the Soundfile ptr.
777 ++iter; (*iter).set(from);
778 ++iter; (*iter).set(to);
779 ++iter; (*iter).set(Ts);
780
781 // suggest and check parameters
782 m->suggestValues(paramsIn);
783
784 // execute module
785 list<ModuleParam> * paramsOut = m->apply(paramsIn);
786 if (paramsOut->size() == 0) {
787 return ret;
788 }
789
790 iter=paramsOut->begin();
791 ret.uno = (*iter).get_sd();
792 ++iter; ret.dos = (*iter).get_sd();
793 ++iter; ret.tres = (*iter).get_sd();
794 return ret;
795 }
796
797 CSAPI_PLUGINS_BRIEF SegmentData *
sigSb(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,double Ts=0.001)798 sigSb(Plugins * plugins, SOUNDfile *sfile,
799 double from = 0.0 , double to = FLT_MAX,
800 double Ts = 0.001) {
801
802 // calculate normalised subband energies
803 Module * m = plugins->GetModule(string("sigsb"));
804 if (m==NULL) {
805 return NULL;
806 }
807
808 // get default values
809 list<ModuleParam> * paramsIn = m->defaultValues();
810 if (paramsIn->size() == 0) {
811 return NULL;
812 }
813
814 // set parameters
815 list<ModuleParam>::iterator iter;
816 iter=paramsIn->begin();
817 (*iter).set(sfile); // set the Soundfile ptr.
818 ++iter; (*iter).set(from);
819 ++iter; (*iter).set(to);
820 ++iter; (*iter).set(Ts);
821
822 // suggest and check parameters
823 m->suggestValues(paramsIn);
824
825 // execute module
826 list<ModuleParam> * paramsOut = m->apply(paramsIn);
827 if (paramsOut->size() == 0) {
828 return NULL;
829 }
830
831 return paramsOut->front().get_sd();
832 }
833
834 CSAPI_PLUGINS_BRIEF SegmentData *
centralMoment(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=31,double duration=1.0,int k=2)835 centralMoment(Plugins * plugins, SOUNDfile *sfile,
836 double from = 0.0, double to = FLT_MAX,
837 int fromSb = 0, int toSb = 31,
838 double duration = 1.0, int k = 2) {
839
840 // calculate normalised subband energies
841 Module * m = plugins->GetModule(string("centralMoment"));
842 if (m==NULL) {
843 return NULL;
844 }
845
846 // get default values
847 list<ModuleParam> * paramsIn = m->defaultValues();
848 if (paramsIn->size() == 0) {
849 return NULL;
850 }
851
852 // set parameters
853 list<ModuleParam>::iterator iter;
854 iter=paramsIn->begin();
855 (*iter).set(sfile); // set the Soundfile ptr.
856 ++iter; (*iter).set(from);
857 ++iter; (*iter).set(to);
858 ++iter; (*iter).set(fromSb);
859 ++iter; (*iter).set(toSb);
860 ++iter; (*iter).set(duration);
861 ++iter; (*iter).set(k);
862
863 // suggest and check parameters
864 m->suggestValues(paramsIn);
865
866 // execute module
867 list<ModuleParam> * paramsOut = m->apply(paramsIn);
868 if (paramsOut->size() == 0) {
869 return NULL;
870 }
871
872 return paramsOut->front().get_sd();
873 }
874
875 CSAPI_PLUGINS_BRIEF SegmentData *
signalnrj(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int w_nb=0)876 signalnrj(Plugins * plugins, SOUNDfile *sfile,
877 double from = 0.0, double to = FLT_MAX,
878 int w_nb = 0) {
879
880 // calculate normalised subband energies
881 Module * m = plugins->GetModule(string("signalnrj"));
882 if (m==NULL) {
883 return NULL;
884 }
885
886 // get default values
887 list<ModuleParam> * paramsIn = m->defaultValues();
888 if (paramsIn->size() == 0) {
889 return NULL;
890 }
891
892 // set parameters
893 list<ModuleParam>::iterator iter;
894 iter=paramsIn->begin();
895 (*iter).set(sfile); // set the Soundfile ptr.
896 ++iter; (*iter).set(from);
897 ++iter; (*iter).set(to);
898 ++iter; (*iter).set(w_nb);
899
900 // suggest and check parameters
901 m->suggestValues(paramsIn);
902
903 // execute module
904 list<ModuleParam> * paramsOut = m->apply(paramsIn);
905 if (paramsOut->size() == 0) {
906 return NULL;
907 }
908
909 return paramsOut->front().get_sd();
910 }
911
912 CSAPI_PLUGINS_BRIEF SegmentData *
bandNrj(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int fromSb=0,int toSb=575,int w_nb=0)913 bandNrj(Plugins * plugins, SOUNDfile *sfile,
914 double from = 0.0, double to = FLT_MAX,
915 int fromSb=0, int toSb=575,
916 int w_nb = 0) {
917
918 // calculate normalised subband energies
919 Module * m = plugins->GetModule(string("bandnrj"));
920 if (m==NULL) {
921 return NULL;
922 }
923
924 // get default values
925 list<ModuleParam> * paramsIn = m->defaultValues();
926 if (paramsIn->size() == 0) {
927 return NULL;
928 }
929
930 // set parameters
931 list<ModuleParam>::iterator iter;
932 iter=paramsIn->begin();
933 (*iter).set(sfile); // set the Soundfile ptr.
934 ++iter; (*iter).set(from);
935 ++iter; (*iter).set(to);
936 ++iter; (*iter).set(fromSb);
937 ++iter; (*iter).set(toSb);
938 ++iter; (*iter).set(w_nb);
939
940 // suggest and check parameters
941 m->suggestValues(paramsIn);
942
943 // execute module
944 list<ModuleParam> * paramsOut = m->apply(paramsIn);
945 if (paramsOut->size() == 0) {
946 return NULL;
947 }
948
949 return paramsOut->front().get_sd();
950 }
951
952 CSAPI_PLUGINS_BRIEF SegmentData *
spectralFlux(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX)953 spectralFlux(Plugins * plugins, SOUNDfile *sfile,
954 double from = 0.0, double to = FLT_MAX) {
955
956 // calculate normalised subband energies
957 Module * m = plugins->GetModule(string("spectralFlux"));
958 if (m==NULL) {
959 return NULL;
960 }
961
962 // get default values
963 list<ModuleParam> * paramsIn = m->defaultValues();
964 if (paramsIn->size() == 0) {
965 return NULL;
966 }
967
968 // set parameters
969 list<ModuleParam>::iterator iter;
970 iter=paramsIn->begin();
971 (*iter).set(sfile); // set the Soundfile ptr.
972 ++iter; (*iter).set(from);
973 ++iter; (*iter).set(to);
974
975 // suggest and check parameters
976 m->suggestValues(paramsIn);
977
978 // execute module
979 list<ModuleParam> * paramsOut = m->apply(paramsIn);
980 if (paramsOut->size() == 0) {
981 return NULL;
982 }
983
984 return paramsOut->front().get_sd();
985 }
986
987 CSAPI_PLUGINS_BRIEF SegmentData *
pauseRate(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,double Ts=0.001,double duration=1.0)988 pauseRate(Plugins * plugins, SegmentData *sd,
989 double from = 0.0, double to = FLT_MAX,
990 double Ts = 0.001, double duration = 1.0) {
991
992 // calculate normalised subband energies
993 Module * m = plugins->GetModule(string("pauseRate"));
994 if (m==NULL) {
995 return NULL;
996 }
997
998 // get default values
999 list<ModuleParam> * paramsIn = m->defaultValues();
1000 if (paramsIn->size() == 0) {
1001 return NULL;
1002 }
1003
1004 // set parameters
1005 list<ModuleParam>::iterator iter;
1006 iter=paramsIn->begin();
1007 (*iter).set(sd); // set the SegmentData
1008 ++iter; (*iter).set(from);
1009 ++iter; (*iter).set(to);
1010 ++iter; (*iter).set(Ts);
1011 ++iter; (*iter).set(duration);
1012
1013 // suggest and check parameters
1014 m->suggestValues(paramsIn);
1015
1016 // execute module
1017 list<ModuleParam> * paramsOut = m->apply(paramsIn);
1018 if (paramsOut->size() == 0) {
1019 return NULL;
1020 }
1021
1022 return paramsOut->front().get_sd();
1023 }
1024
1025 CSAPI_PLUGINS_BRIEF SegmentData *
rollOff(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX)1026 rollOff(Plugins * plugins, SOUNDfile *sfile,
1027 double from = 0.0, double to = FLT_MAX) {
1028
1029 // calculate normalised subband energies
1030 Module * m = plugins->GetModule(string("rollOff"));
1031 if (m==NULL) {
1032 return NULL;
1033 }
1034
1035 // get default values
1036 list<ModuleParam> * paramsIn = m->defaultValues();
1037 if (paramsIn->size() == 0) {
1038 return NULL;
1039 }
1040
1041 // set parameters
1042 list<ModuleParam>::iterator iter;
1043 iter=paramsIn->begin();
1044 (*iter).set(sfile); // set the Soundfile ptr.
1045 ++iter; (*iter).set(from);
1046 ++iter; (*iter).set(to);
1047
1048 // suggest and check parameters
1049 m->suggestValues(paramsIn);
1050
1051 // execute module
1052 list<ModuleParam> * paramsOut = m->apply(paramsIn);
1053 if (paramsOut->size() == 0) {
1054 return NULL;
1055 }
1056
1057 return paramsOut->front().get_sd();
1058 }
1059
1060 CSAPI_PLUGINS_BRIEF Trio
sigBdwidth(Plugins * plugins,SegmentData * sd,double from=0.0,double to=FLT_MAX,double Ts=0.001)1061 sigBdwidth(Plugins * plugins, SegmentData *sd,
1062 double from = 0.0, double to = FLT_MAX,
1063 double Ts = 0.001) {
1064 Trio ret;
1065 ret.uno = 0;
1066 ret.dos = 0;
1067 ret.tres = 0;
1068 // calculate normalised subband energies
1069 Module * m = plugins->GetModule(string("sigBdwidth"));
1070 if (m==NULL) {
1071 return ret;
1072 }
1073
1074 // get default values
1075 list<ModuleParam> * paramsIn = m->defaultValues();
1076 if (paramsIn->size() == 0) {
1077 return ret;
1078 }
1079
1080 // set parameters
1081 list<ModuleParam>::iterator iter;
1082 iter=paramsIn->begin();
1083 (*iter).set(sd); // set the Segment data
1084 ++iter; (*iter).set(from);
1085 ++iter; (*iter).set(to);
1086 ++iter; (*iter).set(Ts);
1087
1088 // suggest and check parameters
1089 m->suggestValues(paramsIn);
1090
1091 // execute module
1092 list<ModuleParam> * paramsOut = m->apply(paramsIn);
1093 if (paramsOut->size() == 0) {
1094 return ret;
1095 }
1096
1097
1098 iter=paramsOut->begin();
1099 ret.uno = (*iter).get_sd();
1100 ++iter; ret.dos = (*iter).get_sd();
1101 ++iter; ret.tres = (*iter).get_sd();
1102 return ret;
1103 }
1104
1105 CSAPI_PLUGINS_BRIEF SegmentData *
signalMagnitude(Plugins * plugins,SOUNDfile * sfile,double from=0.0,double to=FLT_MAX,int w_nb=0)1106 signalMagnitude(Plugins * plugins, SOUNDfile *sfile,
1107 double from = 0.0, double to = FLT_MAX,
1108 int w_nb = 0) {
1109
1110 // calculate normalised subband energies
1111 Module * m = plugins->GetModule(string("signalMagnitude"));
1112 if (m==NULL) {
1113 return NULL;
1114 }
1115
1116 // get default values
1117 list<ModuleParam> * paramsIn = m->defaultValues();
1118 if (paramsIn->size() == 0) {
1119 return NULL;
1120 }
1121
1122 // set parameters
1123 list<ModuleParam>::iterator iter;
1124 iter=paramsIn->begin();
1125 (*iter).set(sfile); // set the Soundfile ptr.
1126 ++iter; (*iter).set(from);
1127 ++iter; (*iter).set(to);
1128 ++iter; (*iter).set(w_nb);
1129
1130 // suggest and check parameters
1131 m->suggestValues(paramsIn);
1132
1133 // execute module
1134 list<ModuleParam> * paramsOut = m->apply(paramsIn);
1135 if (paramsOut->size() == 0) {
1136 return NULL;
1137 }
1138
1139 return paramsOut->front().get_sd();
1140 }
1141
1142