Changeset eb7f743
 Timestamp:
 Oct 2, 2009, 6:11:07 AM (12 years ago)
 Branches:
 feature/autosink, feature/constantq, feature/pitchshift, feature/pydocstrings, feature/timestretch, master, pitchshift, sampler, timestretch, yinfft+
 Children:
 352fd5f
 Parents:
 1498ced
 Location:
 src
 Files:

 2 edited
Legend:
 Unmodified
 Added
 Removed

src/mathutils.c
r1498ced reb7f743 26 26 #include "config.h" 27 27 28 fvec_t * new_aubio_window(uint_t size, aubio_window_type wintype) { 28 fvec_t * 29 new_aubio_window (uint_t size, aubio_window_type wintype) 30 { 29 31 // create fvec of size x 1 channel 30 32 fvec_t * win = new_fvec( size, 1); … … 79 81 } 80 82 81 smpl_t aubio_unwrap2pi(smpl_t phase) { 83 smpl_t 84 aubio_unwrap2pi (smpl_t phase) 85 { 82 86 /* mod(phase+pi,2pi)+pi */ 83 return phase + TWO_PI * (1. + FLOOR((phase+PI)/TWO_PI)); 84 } 85 86 smpl_t fvec_mean(fvec_t *s) { 87 uint_t i,j; 87 return phase + TWO_PI * (1. + FLOOR ((phase + PI) / TWO_PI)); 88 } 89 90 smpl_t 91 fvec_mean (fvec_t * s) 92 { 93 uint_t i, j; 88 94 smpl_t tmp = 0.0; 89 for (i =0; i < s>channels; i++)90 for (j =0; j < s>length; j++)95 for (i = 0; i < s>channels; i++) 96 for (j = 0; j < s>length; j++) 91 97 tmp += s>data[i][j]; 92 return tmp/(smpl_t)(s>length); 93 } 94 95 smpl_t fvec_sum(fvec_t *s) { 96 uint_t i,j; 98 return tmp / (smpl_t) (s>length); 99 } 100 101 smpl_t 102 fvec_sum (fvec_t * s) 103 { 104 uint_t i, j; 97 105 smpl_t tmp = 0.0; 98 for (i =0; i < s>channels; i++)99 for (j =0; j < s>length; j++)106 for (i = 0; i < s>channels; i++) { 107 for (j = 0; j < s>length; j++) { 100 108 tmp += s>data[i][j]; 109 } 110 } 101 111 return tmp; 102 112 } 103 113 104 smpl_t fvec_max(fvec_t *s) { 105 uint_t i,j; 114 smpl_t 115 fvec_max (fvec_t * s) 116 { 117 uint_t i, j; 106 118 smpl_t tmp = 0.0; 107 for (i=0; i < s>channels; i++) 108 for (j=0; j < s>length; j++) 109 tmp = (tmp > s>data[i][j])? tmp : s>data[i][j]; 119 for (i = 0; i < s>channels; i++) { 120 for (j = 0; j < s>length; j++) { 121 tmp = (tmp > s>data[i][j]) ? tmp : s>data[i][j]; 122 } 123 } 110 124 return tmp; 111 125 } 112 126 113 smpl_t fvec_min(fvec_t *s) { 114 uint_t i,j; 127 smpl_t 128 fvec_min (fvec_t * s) 129 { 130 uint_t i, j; 115 131 smpl_t tmp = s>data[0][0]; 116 for (i=0; i < s>channels; i++) 117 for (j=0; j < s>length; j++) 118 tmp = (tmp < s>data[i][j])? tmp : s>data[i][j] ; 132 for (i = 0; i < s>channels; i++) { 133 for (j = 0; j < s>length; j++) { 134 tmp = (tmp < s>data[i][j]) ? tmp : s>data[i][j]; 135 } 136 } 119 137 return tmp; 120 138 } 121 139 122 uint_t fvec_min_elem(fvec_t *s) { 123 uint_t i,j=0, pos=0.; 140 uint_t 141 fvec_min_elem (fvec_t * s) 142 { 143 uint_t i, j = 0, pos = 0.; 124 144 smpl_t tmp = s>data[0][0]; 125 for (i=0; i < s>channels; i++) 126 for (j=0; j < s>length; j++) { 127 pos = (tmp < s>data[i][j])? pos : j; 128 tmp = (tmp < s>data[i][j])? tmp : s>data[i][j] ; 129 } 145 for (i = 0; i < s>channels; i++) { 146 for (j = 0; j < s>length; j++) { 147 pos = (tmp < s>data[i][j]) ? pos : j; 148 tmp = (tmp < s>data[i][j]) ? tmp : s>data[i][j]; 149 } 150 } 130 151 return pos; 131 152 } 132 153 133 uint_t fvec_max_elem(fvec_t *s) { 134 uint_t i,j=0, pos=0.; 154 uint_t 155 fvec_max_elem (fvec_t * s) 156 { 157 uint_t i, j, pos; 135 158 smpl_t tmp = 0.0; 136 for (i=0; i < s>channels; i++) 137 for (j=0; j < s>length; j++) { 138 pos = (tmp > s>data[i][j])? pos : j; 139 tmp = (tmp > s>data[i][j])? tmp : s>data[i][j] ; 140 } 159 for (i = 0; i < s>channels; i++) { 160 for (j = 0; j < s>length; j++) { 161 pos = (tmp > s>data[i][j]) ? pos : j; 162 tmp = (tmp > s>data[i][j]) ? tmp : s>data[i][j]; 163 } 164 } 141 165 return pos; 142 166 } 143 167 144 void fvec_shift(fvec_t *s) { 145 uint_t i,j; 146 //smpl_t tmp = 0.0; 147 for (i=0; i < s>channels; i++) 148 for (j=0; j < s>length / 2 ; j++) { 149 //tmp = s>data[i][j]; 150 //s>data[i][j] = s>data[i][j+s>length/2]; 151 //s>data[i][j+s>length/2] = tmp; 152 ELEM_SWAP(s>data[i][j],s>data[i][j+s>length/2]); 153 } 154 } 155 156 smpl_t fvec_local_energy(fvec_t * f) { 157 smpl_t locE = 0.; 158 uint_t i,j; 159 for (i=0;i<f>channels;i++) 160 for (j=0;j<f>length;j++) 161 locE+=SQR(f>data[i][j]); 162 return locE; 163 } 164 165 smpl_t fvec_local_hfc(fvec_t * f) { 166 smpl_t locE = 0.; 167 uint_t i,j; 168 for (i=0;i<f>channels;i++) 169 for (j=0;j<f>length;j++) 170 locE+=(i+1)*f>data[i][j]; 171 return locE; 172 } 173 174 smpl_t fvec_alpha_norm(fvec_t * DF, smpl_t alpha) { 168 void 169 fvec_shift (fvec_t * s) 170 { 171 uint_t i, j; 172 for (i = 0; i < s>channels; i++) { 173 for (j = 0; j < s>length / 2; j++) { 174 ELEM_SWAP (s>data[i][j], s>data[i][j + s>length / 2]); 175 } 176 } 177 } 178 179 smpl_t 180 fvec_local_energy (fvec_t * f) 181 { 182 smpl_t energy = 0.; 183 uint_t i, j; 184 for (i = 0; i < f>channels; i++) { 185 for (j = 0; j < f>length; j++) { 186 energy += SQR (f>data[i][j]); 187 } 188 } 189 return energy; 190 } 191 192 smpl_t 193 fvec_local_hfc (fvec_t * v) 194 { 195 smpl_t hfc = 0.; 196 uint_t i, j; 197 for (i = 0; i < v>channels; i++) { 198 for (j = 0; j < v>length; j++) { 199 hfc += (i + 1) * v>data[i][j]; 200 } 201 } 202 return hfc; 203 } 204 205 void 206 fvec_min_removal (fvec_t * v) 207 { 208 smpl_t v_min = fvec_min (v); 209 fvec_add (v,  v_min ); 210 } 211 212 smpl_t 213 fvec_alpha_norm (fvec_t * o, smpl_t alpha) 214 { 215 uint_t i, j; 175 216 smpl_t tmp = 0.; 176 uint_t i,j;177 for (i=0;i<DF>channels;i++)178 for (j=0;j<DF>length;j++)179 tmp += POW(ABS(DF>data[i][j]),alpha);180 return POW(tmp/DF>length,1./alpha);181 }182 183 void184 fvec_min_removal (fvec_t * o)185 {186 uint_t i, j;187 smpl_t mini = fvec_min (o);188 217 for (i = 0; i < o>channels; i++) { 189 218 for (j = 0; j < o>length; j++) { 190 o>data[i][j] = mini; 191 } 192 } 193 } 194 195 void fvec_alpha_normalise(fvec_t * mag, uint_t alpha) { 196 smpl_t alphan = 1.; 197 uint_t length = mag>length, i=0, j; 198 alphan = fvec_alpha_norm(mag,alpha); 199 for (j=0;j<length;j++){ 200 mag>data[i][j] /= alphan; 201 } 202 } 203 204 void fvec_add(fvec_t * mag, smpl_t threshold) { 205 uint_t length = mag>length, i=0, j; 206 for (j=0;j<length;j++) { 207 mag>data[i][j] += threshold; 219 tmp += POW (ABS (o>data[i][j]), alpha); 220 } 221 } 222 return POW (tmp / o>length, 1. / alpha); 223 } 224 225 void 226 fvec_alpha_normalise (fvec_t * o, smpl_t alpha) 227 { 228 uint_t i, j; 229 smpl_t norm = fvec_alpha_norm (o, alpha); 230 for (i = 0; i < o>channels; i++) { 231 for (j = 0; j < o>length; j++) { 232 o>data[i][j] /= norm; 233 } 234 } 235 } 236 237 void 238 fvec_add (fvec_t * o, smpl_t val) 239 { 240 uint_t i, j; 241 for (i = 0; i < o>channels; i++) { 242 for (j = 0; j < o>length; j++) { 243 o>data[i][j] += val; 244 } 208 245 } 209 246 } … … 217 254 } 218 255 219 smpl_t fvec_moving_thres(fvec_t * vec, fvec_t * tmpvec, 220 uint_t post, uint_t pre, uint_t pos) { 221 smpl_t * medar = (smpl_t *)tmpvec>data[0]; 256 smpl_t 257 fvec_moving_thres (fvec_t * vec, fvec_t * tmpvec, 258 uint_t post, uint_t pre, uint_t pos) 259 { 260 smpl_t *medar = (smpl_t *) tmpvec>data[0]; 222 261 uint_t k; 223 uint_t win_length = post+pre+1;224 uint_t length = 262 uint_t win_length = post + pre + 1; 263 uint_t length = vec>length; 225 264 /* post part of the buffer does not exist */ 226 if (pos <post+1) {227 for (k =0;k<post+1pos;k++)228 medar[k] = 0.; /* 0padding at the beginning */229 for (k =post+1pos;k<win_length;k++)230 medar[k] = vec>data[0][k +pospost];231 /* the buffer is fully defined */232 } else if (pos +pre<length) {233 for (k =0;k<win_length;k++)234 medar[k] = vec>data[0][k +pospost];235 /* pre part of the buffer does not exist */265 if (pos < post + 1) { 266 for (k = 0; k < post + 1  pos; k++) 267 medar[k] = 0.; /* 0padding at the beginning */ 268 for (k = post + 1  pos; k < win_length; k++) 269 medar[k] = vec>data[0][k + pos  post]; 270 /* the buffer is fully defined */ 271 } else if (pos + pre < length) { 272 for (k = 0; k < win_length; k++) 273 medar[k] = vec>data[0][k + pos  post]; 274 /* pre part of the buffer does not exist */ 236 275 } else { 237 for (k =0;k<lengthpos+post;k++)238 medar[k] = vec>data[0][k +pospost];239 for (k =lengthpos+post;k<win_length;k++)240 medar[k] = 0.; /* 0padding at the end */241 } 242 return fvec_median (tmpvec);276 for (k = 0; k < length  pos + post; k++) 277 medar[k] = vec>data[0][k + pos  post]; 278 for (k = length  pos + post; k < win_length; k++) 279 medar[k] = 0.; /* 0padding at the end */ 280 } 281 return fvec_median (tmpvec); 243 282 } 244 283 … … 301 340 if (x2 == pos) return (x>data[0][pos] <= x>data[0][x0]) ? pos : x0; 302 341 s0 = x>data[0][x0]; 303 s1 = x>data[0][pos] 342 s1 = x>data[0][pos]; 304 343 s2 = x>data[0][x2]; 305 344 return pos + 0.5 * (s2  s0 ) / (s2  2.* s1 + s0); 306 }307 308 smpl_t aubio_quadfrac(smpl_t s0, smpl_t s1, smpl_t s2, smpl_t pf) {309 smpl_t tmp = s0 + (pf/2.) * (pf * ( s0  2.*s1 + s2 )  3.*s0 + 4.*s1  s2);310 return tmp;311 345 } 312 346 … … 320 354 } 321 355 322 smpl_t aubio_freqtomidi(smpl_t freq) { 356 smpl_t 357 aubio_quadfrac (smpl_t s0, smpl_t s1, smpl_t s2, smpl_t pf) 358 { 359 smpl_t tmp = 360 s0 + (pf / 2.) * (pf * (s0  2. * s1 + s2)  3. * s0 + 4. * s1  s2); 361 return tmp; 362 } 363 364 smpl_t 365 aubio_freqtomidi (smpl_t freq) 366 { 323 367 /* log(freq/A2)/log(2) */ 324 smpl_t midi = freq /6.875;325 midi = LOG (midi)/0.69314718055995;368 smpl_t midi = freq / 6.875; 369 midi = LOG (midi) / 0.69314718055995; 326 370 midi *= 12; 327 371 midi = 3; … … 329 373 } 330 374 331 smpl_t aubio_miditofreq(smpl_t midi) { 332 smpl_t freq = (midi+3.)/12.; 333 freq = EXP(freq*0.69314718055995); 375 smpl_t 376 aubio_miditofreq (smpl_t midi) 377 { 378 smpl_t freq = (midi + 3.) / 12.; 379 freq = EXP (freq * 0.69314718055995); 334 380 freq *= 6.875; 335 381 return freq; 336 382 } 337 383 338 smpl_t aubio_bintofreq(smpl_t bin, smpl_t samplerate, smpl_t fftsize) { 339 smpl_t freq = samplerate/fftsize; 340 return freq*bin; 341 } 342 343 smpl_t aubio_bintomidi(smpl_t bin, smpl_t samplerate, smpl_t fftsize) { 344 smpl_t midi = aubio_bintofreq(bin,samplerate,fftsize); 345 return aubio_freqtomidi(midi); 346 } 347 348 smpl_t aubio_freqtobin(smpl_t freq, smpl_t samplerate, smpl_t fftsize) { 349 smpl_t bin = fftsize/samplerate; 350 return freq*bin; 351 } 352 353 smpl_t aubio_miditobin(smpl_t midi, smpl_t samplerate, smpl_t fftsize) { 354 smpl_t freq = aubio_miditofreq(midi); 355 return aubio_freqtobin(freq,samplerate,fftsize); 356 } 357 358 /** returns 1 if wassilence is 0 and RMS(ibuf)<threshold 359 * \bug mono 360 */ 361 uint_t aubio_silence_detection(fvec_t * ibuf, smpl_t threshold) { 362 smpl_t loudness = 0; 363 uint_t i=0,j; 364 for (j=0;j<ibuf>length;j++) { 365 loudness += SQR(ibuf>data[i][j]); 366 } 367 loudness = SQRT(loudness); 368 loudness /= (smpl_t)ibuf>length; 369 loudness = LIN2DB(loudness); 370 371 return (loudness < threshold); 372 } 373 374 /** returns level log(RMS(ibuf)) if < threshold, 1 otherwise 375 * \bug mono 376 */ 377 smpl_t aubio_level_detection(fvec_t * ibuf, smpl_t threshold) { 378 smpl_t loudness = 0; 379 uint_t i=0,j; 380 for (j=0;j<ibuf>length;j++) { 381 loudness += SQR(ibuf>data[i][j]); 382 } 383 loudness = SQRT(loudness); 384 loudness /= (smpl_t)ibuf>length; 385 loudness = LIN2DB(loudness); 386 387 if (loudness < threshold) 384 smpl_t 385 aubio_bintofreq (smpl_t bin, smpl_t samplerate, smpl_t fftsize) 386 { 387 smpl_t freq = samplerate / fftsize; 388 return freq * bin; 389 } 390 391 smpl_t 392 aubio_bintomidi (smpl_t bin, smpl_t samplerate, smpl_t fftsize) 393 { 394 smpl_t midi = aubio_bintofreq (bin, samplerate, fftsize); 395 return aubio_freqtomidi (midi); 396 } 397 398 smpl_t 399 aubio_freqtobin (smpl_t freq, smpl_t samplerate, smpl_t fftsize) 400 { 401 smpl_t bin = fftsize / samplerate; 402 return freq * bin; 403 } 404 405 smpl_t 406 aubio_miditobin (smpl_t midi, smpl_t samplerate, smpl_t fftsize) 407 { 408 smpl_t freq = aubio_miditofreq (midi); 409 return aubio_freqtobin (freq, samplerate, fftsize); 410 } 411 412 smpl_t 413 aubio_db_spl (fvec_t * o) 414 { 415 smpl_t val = SQRT (fvec_local_energy (o)); 416 val /= (smpl_t) o>length; 417 return LIN2DB (val); 418 } 419 420 uint_t 421 aubio_silence_detection (fvec_t * o, smpl_t threshold) 422 { 423 return (aubio_db_spl (o) < threshold); 424 } 425 426 smpl_t 427 aubio_level_detection (fvec_t * o, smpl_t threshold) 428 { 429 smpl_t db_spl = aubio_db_spl (o); 430 if (db_spl < threshold) { 388 431 return 1.; 389 else 390 return loudness; 391 } 392 393 smpl_t aubio_zero_crossing_rate(fvec_t * input) { 394 uint_t i=0,j; 432 } else { 433 return db_spl; 434 } 435 } 436 437 smpl_t 438 aubio_zero_crossing_rate (fvec_t * input) 439 { 440 uint_t i = 0, j; 395 441 uint_t zcr = 0; 396 for ( j = 1; j < input>length; j++) {442 for (j = 1; j < input>length; j++) { 397 443 // previous was strictly negative 398 if ( input>data[i][j1] < 0.) {444 if (input>data[i][j  1] < 0.) { 399 445 // current is positive or null 400 if ( input>data[i][j] >= 0.) {446 if (input>data[i][j] >= 0.) { 401 447 zcr += 1; 402 448 } 403 // previous was positive or null449 // previous was positive or null 404 450 } else { 405 451 // current is strictly negative 406 if ( input>data[i][j] < 0.) {452 if (input>data[i][j] < 0.) { 407 453 zcr += 1; 408 454 } 409 455 } 410 456 } 411 return zcr/(smpl_t)input>length; 412 } 413 414 void aubio_autocorr(fvec_t * input, fvec_t * output) { 415 uint_t i = 0, j = 0, length = input>length; 416 smpl_t * data = input>data[0]; 417 smpl_t * acf = output>data[0]; 418 smpl_t tmp =0.; 419 for(i=0;i<length;i++){ 420 for(j=i;j<length;j++){ 421 tmp += data[ji]*data[j]; 422 } 423 acf[i] = tmp /(smpl_t)(lengthi); 424 tmp = 0.0; 425 } 426 } 427 428 void aubio_cleanup(void) { 457 return zcr / (smpl_t) input>length; 458 } 459 460 void 461 aubio_autocorr (fvec_t * input, fvec_t * output) 462 { 463 uint_t i, j, k, length = input>length; 464 smpl_t *data, *acf; 465 smpl_t tmp = 0; 466 for (k = 0; k < input>channels; k++) { 467 data = input>data[k]; 468 acf = output>data[k]; 469 for (i = 0; i < length; i++) { 470 tmp = 0.; 471 for (j = i; j < length; j++) { 472 tmp += data[j  i] * data[j]; 473 } 474 acf[i] = tmp / (smpl_t) (length  i); 475 } 476 } 477 } 478 479 void 480 aubio_cleanup (void) 481 { 429 482 #if HAVE_FFTW3 430 fftw_cleanup ();483 fftw_cleanup (); 431 484 #else 432 485 #if HAVE_FFTW3F 433 fftwf_cleanup ();486 fftwf_cleanup (); 434 487 #endif 435 488 #endif 
src/mathutils.h
r1498ced reb7f743 21 21 /** @file 22 22 * various math functions 23 *24 * \todo multichannel (each function should return or set an array sized to25 * the number of channel in the input vector)26 *27 * \todo appropriate switches depending on types.h content28 23 */ 29 24 … … 36 31 37 32 /** Window types 38 * 39 * inspired from 40 * 41 *  dafx : http://profs.sci.univr.it/%7Edafx/FinalPapers/ps/Bernardini.ps.gz 42 *  freqtweak : http://freqtweak.sf.net/ 43 *  extace : http://extace.sf.net/ 44 */ 45 typedef enum { 46 aubio_win_rectangle, 47 aubio_win_hamming, 48 aubio_win_hanning, 49 aubio_win_hanningz, 50 aubio_win_blackman, 51 aubio_win_blackman_harris, 52 aubio_win_gaussian, 53 aubio_win_welch, 54 aubio_win_parzen 33 34 References: 35 36  <a href="http://en.wikipedia.org/wiki/Window_function">Window 37 function</a> on Wikipedia 38  Amalia de Götzen, Nicolas Bernardini, and Daniel Arfib. Traditional (?) 39 implementations of a phase vocoder: the tricks of the trade. In Proceedings of 40 the International Conference on Digital Audio Effects (DAFx00), pages 37–44, 41 Uni versity of Verona, Italy, 2000. 42 (<a href="http://profs.sci.univr.it/%7Edafx/FinalPapers/ps/Bernardini.ps.gz"> 43 ps.gz</a>) 44 45 */ 46 typedef enum 47 { 48 aubio_win_rectangle, 49 aubio_win_hamming, 50 aubio_win_hanning, 51 aubio_win_hanningz, 52 aubio_win_blackman, 53 aubio_win_blackman_harris, 54 aubio_win_gaussian, 55 aubio_win_welch, 56 aubio_win_parzen 55 57 } aubio_window_type; 56 58 57 59 /** create window */ 58 fvec_t * new_aubio_window(uint_t size, aubio_window_type wintype); 59 60 /** principal argument 61 * 62 * mod(phase+PI,TWO_PI)+PI 63 */ 60 fvec_t *new_aubio_window (uint_t size, aubio_window_type wintype); 61 62 /** compute the principal argument 63 64 This function maps the input phase to its corresponding value wrapped in the 65 range \f$ [\pi, \pi] \f$. 66 67 \param phase unwrapped phase to map to the unit circle 68 69 \return equivalent phase wrapped to the unit circle 70 71 */ 64 72 smpl_t aubio_unwrap2pi (smpl_t phase); 65 73 66 /** calculates the mean of a vector 67 * 68 * \bug mono 69 */ 70 smpl_t fvec_mean(fvec_t *s); 71 /** returns the max of a vector 72 * 73 * \bug mono 74 */ 75 smpl_t fvec_max(fvec_t *s); 76 /** returns the min of a vector 77 * 78 * \bug mono 79 */ 80 smpl_t fvec_min(fvec_t *s); 81 /** returns the index of the min of a vector 82 * 83 * \bug mono 84 */ 85 uint_t fvec_min_elem(fvec_t *s); 86 /** returns the index of the max of a vector 87 * 88 * \bug mono 89 */ 90 uint_t fvec_max_elem(fvec_t *s); 91 /** implement 'fftshift' like function 92 * 93 * a[0]...,a[n/2],a[n/2+1],...a[n] 94 * 95 * becomes 96 * 97 * a[n/2+1],...a[n],a[0]...,a[n/2] 98 */ 99 void fvec_shift(fvec_t *s); 100 /** returns sum */ 101 smpl_t fvec_sum(fvec_t *s); 102 103 /** returns energy 104 * 105 * \bug mono 106 */ 107 smpl_t fvec_local_energy(fvec_t * f); 108 /** returns High Frequency Energy Content 109 * 110 * \bug mono */ 111 smpl_t fvec_local_hfc(fvec_t * f); 112 /** return alpha norm. 113 * 114 * alpha=2 means normalise variance. 115 * alpha=1 means normalise abs value. 116 * as alpha goes large, tends to normalisation 117 * by max value. 118 * 119 * \bug should not use POW :( 120 */ 121 smpl_t fvec_alpha_norm(fvec_t * DF, smpl_t alpha); 122 /** min removal */ 123 void fvec_min_removal(fvec_t * mag); 124 /** alpha normalisation */ 125 void fvec_alpha_normalise(fvec_t * mag, uint_t alpha); 126 /** add a constant to all members of a vector */ 127 void fvec_add(fvec_t * mag, smpl_t threshold); 128 129 /** compute adaptive threshold of input vector */ 130 void fvec_adapt_thres(fvec_t * vec, fvec_t * tmp, 131 uint_t win_post, uint_t win_pre); 132 /** adaptative thresholding 133 * 134 * y=fn_thresh(fn,x,post,pre) 135 * compute adaptive threshold at each time 136 * fn : a function name or pointer, eg 'median' 137 * x: signal vector 138 * post: window length, causal part 139 * pre: window length, anticausal part 140 * Returns: 141 * y: signal the same length as x 142 * 143 * Formerly median_thresh, used compute median over a 144 * window of post+pre+1 samples, but now works with any 145 * function that takes a vector or matrix and returns a 146 * 'representative' value for each column, eg 147 * medians=fn_thresh(median,x,8,8) 148 * minima=fn_thresh(min,x,8,8) 149 * see SPARMS for explanation of post and pre 150 */ 151 smpl_t fvec_moving_thres(fvec_t * vec, fvec_t * tmp, 152 uint_t win_post, uint_t win_pre, uint_t win_pos); 153 154 /** returns the median of the vector 155 * 156 * This Quickselect routine is based on the algorithm described in 157 * "Numerical recipes in C", Second Edition, 158 * Cambridge University Press, 1992, Section 8.5, ISBN 0521431085 159 * 160 * This code by Nicolas Devillard  1998. Public domain, 161 * available at http://ndevilla.free.fr/median/median/ 162 */ 163 smpl_t fvec_median(fvec_t * input); 74 /** compute the mean of a vector 75 76 \param s vector to compute norm from 77 78 \return the mean of v 79 80 */ 81 smpl_t fvec_mean (fvec_t * s); 82 83 /** find the max of a vector 84 85 \param s vector to get the max from 86 87 \return the value of the minimum of v 88 89 */ 90 smpl_t fvec_max (fvec_t * s); 91 92 /** find the min of a vector 93 94 \param s vector to get the min from 95 96 \return the value of the maximum of v 97 98 */ 99 smpl_t fvec_min (fvec_t * s); 100 101 /** find the index of the min of a vector 102 103 \param s vector to get the index from 104 105 \return the index of the minimum element of v 106 107 */ 108 uint_t fvec_min_elem (fvec_t * s); 109 110 /** find the index of the max of a vector 111 112 \param s vector to get the index from 113 114 \return the index of the maximum element of v 115 116 */ 117 uint_t fvec_max_elem (fvec_t * s); 118 119 /** swap the left and right halves of a vector 120 121 This function swaps the left part of the signal with the right part of the 122 signal. Therefore 123 124 \f$ a[0], a[1], ..., a[\frac{N}{2}], a[\frac{N}{2}+1], ..., a[N1], a[N] \f$ 125 126 becomes 127 128 \f$ a[\frac{N}{2}+1], ..., a[N1], a[N], a[0], a[1], ..., a[\frac{N}{2}] \f$ 129 130 This operation, known as 'fftshift' in the Matlab Signal Processing Toolbox, 131 can be used before computing the FFT to simplify the phase relationship of the 132 resulting spectrum. See Amalia de Götzen's paper referred to above. 133 134 */ 135 void fvec_shift (fvec_t * v); 136 137 /** compute the sum of all elements of a vector 138 139 \param v vector to compute the sum of 140 141 \return the sum of v 142 143 */ 144 smpl_t fvec_sum (fvec_t * v); 145 146 /** compute the energy of a vector 147 148 This function compute the sum of the squared elements of a vector. 149 150 \param v vector to get the energy from 151 152 \return the energy of v 153 154 */ 155 smpl_t fvec_local_energy (fvec_t * v); 156 157 /** compute the High Frequency Content of a vector 158 159 The High Frequency Content is defined as \f$ \sum_0^{N1} (k+1) v[k] \f$. 160 161 \param v vector to get the energy from 162 163 \return the HFC of v 164 165 */ 166 smpl_t fvec_local_hfc (fvec_t * v); 167 168 /** computes the pnorm of a vector 169 170 Computes the pnorm of a vector for \f$ p = \alpha \f$ 171 172 \f$ L^p = x_p = (x_1^p + x_2^p + ... + x_n^p ) ^ \frac{1}{p} \f$ 173 174 If p = 1, the result is the Manhattan distance. 175 176 If p = 2, the result is the Euclidean distance. 177 178 As p tends towards large values, \f$ L^p \f$ tends towards the maximum of the 179 input vector. 180 181 References: 182 183  <a href="http://en.wikipedia.org/wiki/Lp_space">\f$L^p\f$ space</a> on 184 Wikipedia 185 186 \param v vector to compute norm from 187 \param p order of the computed norm 188 189 \return the pnorm of v 190 191 */ 192 smpl_t fvec_alpha_norm (fvec_t * v, smpl_t p); 193 194 /** alpha normalisation 195 196 This function divides all elements of a vector by the pnorm as computed by 197 fvec_alpha_norm(). 198 199 \param v vector to compute norm from 200 \param p order of the computed norm 201 202 */ 203 void fvec_alpha_normalise (fvec_t * v, smpl_t p); 204 205 /** add a constant to each elements of a vector 206 207 \param v vector to add constant to 208 \param c constant to add to v 209 210 */ 211 void fvec_add (fvec_t * v, smpl_t c); 212 213 /** remove the minimum value of the vector to each elements 214 215 \param v vector to remove minimum from 216 217 */ 218 void fvec_min_removal (fvec_t * v); 219 220 /** compute moving median theshold of a vector 221 222 This function computes the moving median threshold value of at the given 223 position of a vector, taking the median amongs post elements before and up to 224 pre elements after pos. 225 226 \param v input vector 227 \param tmp temporary vector of length post+1+pre 228 \param post length of causal part to take before pos 229 \param pre length of anticausal part to take after pos 230 \param pos index to compute threshold for 231 232 \return moving median threshold value 233 234 */ 235 smpl_t fvec_moving_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre, 236 uint_t pos); 237 238 /** apply adaptive threshold to a vector 239 240 For each points at position p of an input vector, this function remove the 241 moving median threshold computed at p. 242 243 \param v input vector 244 \param tmp temporary vector of length post+1+pre 245 \param post length of causal part to take before pos 246 \param pre length of anticausal part to take after pos 247 248 */ 249 void fvec_adapt_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre); 250 251 /** returns the median of a vector 252 253 The QuickSelect routine is based on the algorithm described in "Numerical 254 recipes in C", Second Edition, Cambridge University Press, 1992, Section 8.5, 255 ISBN 0521431085 256 257 This implementation of the QuickSelect routine is based on Nicolas 258 Devillard's implementation, available at http://ndevilla.free.fr/median/median/ 259 and in the Public Domain. 260 261 \param v vector to get median from 262 263 \return the median of v 264 265 */ 266 smpl_t fvec_median (fvec_t * v); 164 267 165 268 /** finds exact peak index by quadratic interpolation*/ 166 smpl_t fvec_quadint (fvec_t * x, uint_t pos, uint_t span);269 smpl_t fvec_quadint (fvec_t * x, uint_t pos, uint_t span); 167 270 168 271 /** Quadratic interpolation using Lagrange polynomial. 169 * 170 * inspired from ``Comparison of interpolation algorithms in realtime sound 171 * processing'', Vladimir Arnost, 172 * 173 * estimate = s0 + (pf/2.)*((pf3.)*s02.*(pf2.)*s1+(pf1.)*s2); 174 * where 175 * \param s0,s1,s2 are 3 known points on the curve, 176 * \param pf is the floating point index [0;2] 177 */ 178 smpl_t aubio_quadfrac(smpl_t s0, smpl_t s1, smpl_t s2, smpl_t pf); 179 180 /** returns 1 if X1 is a peak and positive */ 181 uint_t fvec_peakpick(fvec_t * input, uint_t pos); 272 273 Inspired from ``Comparison of interpolation algorithms in realtime sound 274 processing'', Vladimir Arnost, 275 276 \param s0,s1,s2 are 3 consecutive samples of a curve 277 \param pf is the floating point index [0;2] 278 279 \return s0 + (pf/2.)*((pf3.)*s02.*(pf2.)*s1+(pf1.)*s2); 280 281 */ 282 smpl_t aubio_quadfrac (smpl_t s0, smpl_t s1, smpl_t s2, smpl_t pf); 283 284 /** return 1 if v[p] is a peak and positive, 0 otherwise 285 286 This function returns 1 if a peak is found at index p in the vector v. The 287 peak is defined as follows: 288 289  v[p] is positive 290  v[p1] < v[p] 291  v[p] > v[p+1] 292 293 \param v input vector 294 \param p position of supposed for peak 295 296 \return 1 if a peak is found, 0 otherwise 297 298 */ 299 uint_t fvec_peakpick (fvec_t * v, uint_t p); 182 300 183 301 /** convert frequency bin to midi value */ 184 smpl_t aubio_bintomidi(smpl_t bin, smpl_t samplerate, smpl_t fftsize); 302 smpl_t aubio_bintomidi (smpl_t bin, smpl_t samplerate, smpl_t fftsize); 303 185 304 /** convert midi value to frequency bin */ 186 smpl_t aubio_miditobin(smpl_t midi, smpl_t samplerate, smpl_t fftsize); 305 smpl_t aubio_miditobin (smpl_t midi, smpl_t samplerate, smpl_t fftsize); 306 187 307 /** convert frequency bin to frequency (Hz) */ 188 smpl_t aubio_bintofreq(smpl_t bin, smpl_t samplerate, smpl_t fftsize); 308 smpl_t aubio_bintofreq (smpl_t bin, smpl_t samplerate, smpl_t fftsize); 309 189 310 /** convert frequency (Hz) to frequency bin */ 190 smpl_t aubio_freqtobin(smpl_t freq, smpl_t samplerate, smpl_t fftsize); 311 smpl_t aubio_freqtobin (smpl_t freq, smpl_t samplerate, smpl_t fftsize); 312 191 313 /** convert frequency (Hz) to midi value (0128) */ 192 smpl_t aubio_freqtomidi(smpl_t freq); 314 smpl_t aubio_freqtomidi (smpl_t freq); 315 193 316 /** convert midi value (0128) to frequency (Hz) */ 194 smpl_t aubio_miditofreq(smpl_t midi); 195 196 /** check if current buffer level is under a given threshold */ 197 uint_t aubio_silence_detection(fvec_t * ibuf, smpl_t threshold); 198 /** get the current buffer level */ 199 smpl_t aubio_level_detection(fvec_t * ibuf, smpl_t threshold); 200 /** 201 * calculate normalised autocorrelation function 202 */ 203 void aubio_autocorr(fvec_t * input, fvec_t * output); 204 /** 205 * zerocrossing rate (number of zero cross per sample) 206 */ 207 smpl_t aubio_zero_crossing_rate(fvec_t * input); 208 /** 209 * clean up cached memory at the end of program 210 * 211 * use this function at the end of programs to purge all 212 * cached memory. so far this function is only used to clean 213 * fftw cache. 214 */ 215 void aubio_cleanup(void); 317 smpl_t aubio_miditofreq (smpl_t midi); 318 319 /** compute sound pressure level (SPL) in dB 320 321 This quantity is often wrongly called 'loudness'. 322 323 \param v vector to compute dB SPL from 324 325 \return level of v in dB SPL 326 327 */ 328 smpl_t aubio_db_spl (fvec_t * v); 329 330 /** check if buffer level in dB SPL is under a given threshold 331 332 \param v vector to get level from 333 \param threshold threshold in dB SPL 334 335 \return 0 if level is under the given threshold, 1 otherwise 336 337 */ 338 uint_t aubio_silence_detection (fvec_t * v, smpl_t threshold); 339 340 /** get buffer level if level >= threshold, 1. otherwise 341 342 \param v vector to get level from 343 \param threshold threshold in dB SPL 344 345 \return level in dB SPL if level >= threshold, 1. otherwise 346 347 */ 348 smpl_t aubio_level_detection (fvec_t * v, smpl_t threshold); 349 350 /** compute normalised autocorrelation function 351 352 \param input vector to compute autocorrelation from 353 \param output vector to store autocorrelation function to 354 355 */ 356 void aubio_autocorr (fvec_t * input, fvec_t * output); 357 358 /** zerocrossing rate (ZCR) 359 360 The zerocrossing rate is the number of times a signal changes sign, 361 divided by the length of this signal. 362 363 \param v vector to compute ZCR from 364 365 \return zerocrossing rate of v 366 367 */ 368 smpl_t aubio_zero_crossing_rate (fvec_t * v); 369 370 /** clean up cached memory at the end of program 371 372 This function should be used at the end of programs to purge all cached 373 memory. So far it is only useful to clean FFTW's cache. 374 375 */ 376 void aubio_cleanup (void); 216 377 217 378 #ifdef __cplusplus
Note: See TracChangeset
for help on using the changeset viewer.