int main ()
{
uint_t win_s = 512; // fft size
uint_t n_filters = 40; // number of filters
uint_t n_coefs = 13; // number of coefficients
smpl_t samplerate = 16000.; // samplerate
cvec_t *in = new_cvec (win_s); // input buffer
fvec_t *out = new_fvec (n_coefs); // output coefficients
// create mfcc object
aubio_mfcc_t *o = new_aubio_mfcc (win_s, n_filters, n_coefs, samplerate);
cvec_set_all_norm (in, 1.);
aubio_mfcc_do (o, in, out);
fvec_print (out);
cvec_set_all_norm (in, .5);
aubio_mfcc_do (o, in, out);
fvec_print (out);
// clean up
del_aubio_mfcc (o);
del_cvec (in);
del_fvec (out);
aubio_cleanup ();
return 0;
}
int main ()
{
uint_t win_s = 64; // window size
// create biquad filter with `b0`, `b1`, `b2`, `a1`, `a2`
aubio_filter_t * o = new_aubio_filter_biquad(0.3,0.2,0.1,0.2,0.3);
fvec_t * in_vec = new_fvec (win_s); // input buffer
fvec_t * tmp_vec = new_fvec (win_s); // temporary buffer
fvec_t * out_vec = new_fvec (win_s); // output buffer
uint_t times = 100;
while ( times-- ) {
// copy to out, then filter out
aubio_filter_do_outplace(o, in_vec, out_vec);
// in-place filtering
aubio_filter_do(o, in_vec);
// in-place filtering
aubio_filter_do_filtfilt(o, in_vec, out_vec);
fvec_print(in_vec);
}
// memory clean-up, one for each new
del_aubio_filter(o);
del_fvec(in_vec);
del_fvec(tmp_vec);
del_fvec(out_vec);
return 0;
}
int main (void)
{
uint_t n = 6; // compute n times
uint_t win_s = 32; // window size
uint_t hop_s = win_s / 4; // hop size
fvec_t * in = new_fvec (hop_s); // input buffer
cvec_t * fftgrain = new_cvec (win_s); // fft norm and phase
fvec_t * out = new_fvec (hop_s); // output buffer
// allocate fft and other memory space
aubio_pvoc_t * pv = new_aubio_pvoc(win_s,hop_s);
// fill input with some data
fvec_set_all (in, 1.);
fvec_print (in);
while ( n-- ) {
// get some fresh input data
// ..
// execute phase vocoder
aubio_pvoc_do (pv,in,fftgrain);
// do something with fftgrain
// ...
cvec_print (fftgrain);
// optionally rebuild the signal
aubio_pvoc_rdo(pv,fftgrain,out);
// and do something with the result
// ...
fvec_print (out);
}
// clean up
del_fvec(in);
del_cvec(fftgrain);
del_fvec(out);
del_aubio_pvoc(pv);
aubio_cleanup();
return 0;
}
int main (int argc, char **argv)
{
uint_t err = 0;
if (argc < 2) {
err = 2;
PRINT_ERR("not enough arguments\n");
PRINT_MSG("read a wave file as a mono vector\n");
PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]);
PRINT_MSG("examples:\n");
PRINT_MSG(" - read file.wav at original samplerate\n");
PRINT_MSG(" %s file.wav\n", argv[0]);
PRINT_MSG(" - read file.wav at 32000Hz\n");
PRINT_MSG(" %s file.aif 32000\n", argv[0]);
PRINT_MSG(" - read file.wav at original samplerate with 4096 blocks\n");
PRINT_MSG(" %s file.wav 0 4096 \n", argv[0]);
return err;
}
#if __APPLE__
uint_t samplerate = 0;
uint_t hop_size = 256;
uint_t n_frames = 0, read = 0;
if ( argc == 3 ) samplerate = atoi(argv[2]);
if ( argc == 4 ) hop_size = atoi(argv[3]);
char_t *source_path = argv[1];
aubio_source_apple_audio_t * s =
new_aubio_source_apple_audio(source_path, samplerate, hop_size);
if (!s) { err = 1; goto beach; }
fvec_t *vec = new_fvec(hop_size);
if (samplerate == 0 ) samplerate = aubio_source_apple_audio_get_samplerate(s);
do {
aubio_source_apple_audio_do(s, vec, &read);
fvec_print (vec);
n_frames += read;
} while ( read == hop_size );
PRINT_MSG("read %d frames at %dHz (%d blocks) from %s\n", n_frames, samplerate,
n_frames / hop_size, source_path);
del_fvec (vec);
del_aubio_source_apple_audio (s);
beach:
#else
err = 3;
PRINT_ERR("aubio was not compiled with aubio_source_apple_audio\n");
#endif /* __APPLE__ */
return 0;
}
int main (void)
{
uint_t win_s = 16; // window size
uint_t impulse_at = win_s / 2;
fvec_t *in = new_fvec (win_s); // input buffer
fvec_t *out = new_fvec (win_s); // input buffer
aubio_filter_t *o = new_aubio_filter_c_weighting (44100);
in->data[impulse_at] = 0.5;
fvec_print (in);
aubio_filter_do (o, in);
fvec_print (in);
del_aubio_filter (o);
o = new_aubio_filter_a_weighting (32000);
in->data[impulse_at] = 0.5;
fvec_print (in);
aubio_filter_do_outplace (o, in, out);
fvec_print (out);
aubio_filter_set_a_weighting (o, 32000);
in->data[impulse_at] = 0.5;
fvec_print (in);
aubio_filter_do_filtfilt (o, in, out);
fvec_print (out);
del_fvec (in);
del_fvec (out);
del_aubio_filter (o);
aubio_cleanup ();
return 0;
}
int main (void)
{
uint_t height = 3, length = 9, i, j;
// create fmat_t object
fmat_t * mat = new_fmat (height, length);
for ( i = 0; i < mat->height; i++ ) {
for ( j = 0; j < mat->length; j++ ) {
// all elements are already initialized to 0.
assert(mat->data[i][j] == 0);
// setting element of row i, column j
mat->data[i][j] = i * 1. + j *.1;
}
}
fvec_t channel_onstack;
fvec_t *channel = &channel_onstack;
fmat_get_channel(mat, 1, channel);
fvec_print (channel);
// print out matrix
fmat_print(mat);
// destroy it
del_fmat(mat);
return 0;
}
int main (void)
{
uint_t length = 10;
uint_t i;
fvec_t * vec = new_fvec (length);
fvec_t * other_vec = new_fvec (length);
assert (vec);
assert (other_vec);
// vec->length matches requested size
assert(vec->length == length);
// all elements are initialized to `0.`
for ( i = 0; i < vec->length; i++ ) {
assert(vec->data[i] == 0.);
}
// all elements can be set to `1.`
fvec_ones(vec);
assert_fvec_all_equal(vec, 1.);
// all elements can be set to `0.`
fvec_zeros(vec);
assert_fvec_all_equal(vec, 0.);
// each element can be accessed directly
for ( i = 0; i < vec->length; i++ ) {
vec->data[i] = i;
assert(vec->data[i] == i);
}
fvec_print(vec);
fvec_set_sample(vec, 3, 2);
assert(fvec_get_sample(vec, 2) == 3);
assert(fvec_get_data(vec) == vec->data);
// wrong parameters
assert(new_fvec(-1) == NULL);
// copy to an identical size works
fvec_copy(vec, other_vec);
del_fvec(other_vec);
// copy to a different size fail
other_vec = new_fvec(length + 1);
fvec_copy(vec, other_vec);
del_fvec(other_vec);
// copy to a different size fail
other_vec = new_fvec(length - 1);
fvec_copy(vec, other_vec);
// now destroys the vector
if (vec)
del_fvec(vec);
if (other_vec)
del_fvec(other_vec);
return 0;
}
/* estimate the GMM parameters */
static void gmm_compute_params (int n, const float * v, const float * p,
gmm_t * g,
int flags,
int n_thread)
{
long i, j;
long d=g->d, k=g->k;
float * vtmp = fvec_new (d);
float * mu_old = fvec_new_cpy (g->mu, k * d);
float * w_old = fvec_new_cpy (g->w, k);
fvec_0 (g->w, k);
fvec_0 (g->mu, k * d);
fvec_0 (g->sigma, k * d);
if(0) {
/* slow and simple */
for (j = 0 ; j < k ; j++) {
double dtmp = 0;
for (i = 0 ; i < n ; i++) {
/* contribution to the gaussian weight */
dtmp += p[i * k + j];
/* contribution to mu */
fvec_cpy (vtmp, v + i * d, d);
fvec_mul_by (vtmp, d, p[i * k + j]);
fvec_add (g->mu + j * d, vtmp, d);
/* contribution to the variance */
fvec_cpy (vtmp, v + i * d, d);
fvec_sub (vtmp, mu_old + j * d, d);
fvec_sqr (vtmp, d);
fvec_mul_by (vtmp, d, p[i * k + j]);
fvec_add (g->sigma + j * d, vtmp, d);
}
g->w[j] = dtmp;
}
} else {
/* fast and complicated */
if(n_thread<=1)
compute_sum_dcov(n,k,d,v,mu_old,p,g->mu,g->sigma,g->w);
else
compute_sum_dcov_thread(n,k,d,v,mu_old,p,g->mu,g->sigma,g->w,n_thread);
}
if(flags & GMM_FLAGS_1SIGMA) {
for (j = 0 ; j < k ; j++) {
float *sigma_j=g->sigma+j*d;
double var=fvec_sum(sigma_j,d)/d;
fvec_set(sigma_j,d,var);
}
}
long nz=0;
for(i=0; i<k*d; i++)
if(g->sigma[i]<min_sigma) {
g->sigma[i]=min_sigma;
nz++;
}
if(nz) printf("WARN %ld sigma diagonals are too small (set to %g)\n",nz,min_sigma);
for (j = 0 ; j < k ; j++) {
fvec_div_by (g->mu + j * d, d, g->w[j]);
fvec_div_by (g->sigma + j * d, d, g->w[j]);
}
assert(finite(fvec_sum(g->mu, k*d)));
fvec_normalize (g->w, k, 1);
printf ("w = ");
fvec_print (g->w, k);
double imfac = k * fvec_sum_sqr (g->w, k);
printf (" imfac = %.3f\n", imfac);
free (vtmp);
free (w_old);
free (mu_old);
}
int main (int argc, char** argv)
{
sint_t err = 0;
if (argc < 2) {
err = 2;
PRINT_WRN("no arguments, running tests\n");
err = test_wrong_params();
PRINT_MSG("usage: %s <input_path> [samplerate] [hop_size]\n", argv[0]);
return err;
}
uint_t win_s; // fft size
uint_t hop_s = 256; // block size
uint_t samplerate = 0; // samplerate
uint_t n_filters = 40; // number of filters
uint_t n_coeffs = 13; // number of coefficients
uint_t read = 0;
char_t *source_path = argv[1];
if ( argc >= 3 ) samplerate = atoi(argv[2]);
if ( argc >= 4 ) hop_s = atoi(argv[3]);
win_s = 2 * hop_s;
aubio_source_t *source = 0;
aubio_pvoc_t *pv = 0;
aubio_mfcc_t *mfcc = 0;
fvec_t *in = new_fvec (hop_s); // phase vocoder input
cvec_t *fftgrain = new_cvec (win_s); // pvoc output / mfcc input
fvec_t *out = new_fvec (n_coeffs); // mfcc output
if (!in || !fftgrain || !out) { err = 1; goto failure; }
// source
source = new_aubio_source(source_path, samplerate, hop_s);
if (!source) { err = 1; goto failure; }
if (samplerate == 0) samplerate = aubio_source_get_samplerate(source);
// phase vocoder
pv = new_aubio_pvoc(win_s, hop_s);
if (!pv) { err = 1; goto failure; }
// mfcc object
mfcc = new_aubio_mfcc (win_s, n_filters, n_coeffs, samplerate);
if (!mfcc) { err = 1; goto failure; }
// processing loop
do {
aubio_source_do(source, in, &read);
aubio_pvoc_do(pv, in, fftgrain);
aubio_mfcc_do(mfcc, fftgrain, out);
fvec_print(out);
} while (read == hop_s);
failure:
if (mfcc)
del_aubio_mfcc(mfcc);
if (pv)
del_aubio_pvoc(pv);
if (source)
del_aubio_source(source);
if (in)
del_fvec(in);
if (fftgrain)
del_cvec(fftgrain);
if (out)
del_fvec(out);
aubio_cleanup();
return err;
}
void process_print (void)
{
/* output times in seconds and extracted mfccs */
outmsg("%f\t",blocks*hop_size/(float)samplerate);
fvec_print(mfcc_out);
}
int main()
{
int i, j, k, d = 10,d2=5;
float * a = fvec_new (d * d);
float * b = fvec_new (d * d);
float * b0 = fvec_new (d * d);
#define B0(i,j) b0[(i)+(j)*d]
#define A(i,j) a[(i)+(j)*d]
#define B(i,j) b[(i)+(j)*d]
float * lambda = fvec_new (d);
float * v = fvec_new (d * d);
float *v_part=fvec_new (d * d2);
for (i = 0 ; i < d ; i++)
for (j = 0 ; j <= i ; j++) {
A(i,j) = A(j,i) = drand48();
B0(i,j)=drand48();
B0(j,i)=drand48();
/* B(i,j) = B(j,i) = drand48(); */
}
/* make a positive definite b (with b=b0*b0') */
for (i = 0 ; i < d ; i++)
for (j = 0 ; j < d ; j++) {
double accu=0;
for(k=0;k<d;k++)
accu+=B0(i,k)*B0(j,k);
B(i,j)=accu;
}
printf ("a = ");
fmat_print(a,d,d);
printf ("\nb = ");
fmat_print(b,d,d);
printf ("Solution of the eigenproblem Av=lambda v\n");
printf ("\n");
int ret=eigs_sym (d, a, lambda, v);
assert(ret==0);
printf ("\n");
printf("Eigenvectors:\n");
fmat_print(v,d,d);
fprintf(stdout, "lambda = ");
fvec_print (lambda, d);
printf ("\n");
printf("Partial eigenvalues/vectors:\n");
printf ("\n");
ret=eigs_sym_part (d, a, d2, lambda, v_part);
assert(ret>0);
if(ret<d2)
printf("!!! only %d / %d eigenvalues converged\n",ret,d2);
printf ("\n");
printf("Eigenvectors:\n");
fmat_print(v_part,d,d2);
fprintf(stdout, "lambda = ");
fvec_print (lambda, d2);
printf ("\n");
printf ("Solution of the generalized eigenproblem Av=lambda B v\n");
printf ("\n");
ret=geigs_sym (d, a, b, lambda, v);
assert(ret==0);
printf ("\n");
fmat_print(v,d,d);
fprintf(stdout, "lambda = ");
fvec_print (lambda, d);
printf ("\n");
free (a);
free (lambda);
free (v);
return 0;
}
