int main(){
/* allocate some memory */
uint_t win_s = 1024; /* window size */
fvec_t * in = new_fvec (win_s); /* input buffer */
fvec_t * out = new_fvec (win_s/4); /* input buffer */
/* allocate fft and other memory space */
aubio_beattracking_t * tempo = new_aubio_beattracking(win_s);
uint_t i = 0;
smpl_t curtempo, curtempoconf;
while (i < 10) {
aubio_beattracking_do(tempo,in,out);
curtempo = aubio_beattracking_get_bpm(tempo);
if (curtempo != 0.) {
fprintf(stdout,"%f\n",curtempo);
return 1;
}
curtempoconf = aubio_beattracking_get_confidence(tempo);
if (curtempoconf != 0.) {
fprintf(stdout,"%f\n",curtempo);
return 1;
}
i++;
};
del_aubio_beattracking(tempo);
del_fvec(in);
del_fvec(out);
aubio_cleanup();
return 0;
}
//--------------------------------------------------------------
aubioAnalyzer::~aubioAnalyzer(){
del_aubio_pitchdetection(pitch_output);
del_fvec(in);
del_fvec(beats);
del_aubio_beattracking(tracker);
aubio_cleanup();
}
int
main (void)
{
/* allocate some memory */
uint_t win_s = 512; /* fft size */
uint_t n_filters = 40; /* number of filters */
cvec_t *in = new_cvec (win_s); /* input buffer */
fvec_t *out = new_fvec (win_s); /* input buffer */
fmat_t *coeffs = NULL;
smpl_t samplerate = 16000.;
/* allocate fft and other memory space */
aubio_filterbank_t *o = new_aubio_filterbank (n_filters, win_s);
/* assign Mel-frequency coefficients */
aubio_filterbank_set_mel_coeffs_slaney (o, samplerate);
coeffs = aubio_filterbank_get_coeffs (o);
if (coeffs == NULL) {
return -1;
}
//fmat_print (coeffs);
//fprintf(stderr, "%f\n", fvec_sum(coeffs));
aubio_filterbank_do (o, in, out);
del_aubio_filterbank (o);
del_cvec (in);
del_fvec (out);
aubio_cleanup ();
return 0;
}
int main(){
/* allocate some memory */
uint_t win_s = 1024; /* window size */
fvec_t * in = new_fvec (win_s); /* input buffer */
fvec_t * out = new_fvec (2); /* input buffer */
aubio_tempo_t * o = new_aubio_tempo("complex", win_s, win_s/4, 44100.);
uint_t i = 0;
smpl_t curtempo, curtempoconf;
while (i < 1000) {
aubio_tempo_do(o,in,out);
curtempo = aubio_tempo_get_bpm(o);
if (curtempo != 0.) {
fprintf(stdout,"%f\n",curtempo);
return 1;
}
curtempoconf = aubio_tempo_get_confidence(o);
if (curtempoconf != 0.) {
fprintf(stdout,"%f\n",curtempo);
return 1;
}
i++;
};
del_aubio_tempo(o);
del_fvec(in);
del_fvec(out);
aubio_cleanup();
return 0;
}
int main(){
/* allocate some memory */
uint_t win_s = 4096; /* window size */
uint_t channels = 100; /* number of channels */
fvec_t * in = new_fvec (win_s, channels); /* input buffer */
cvec_t * fftgrain = new_cvec (win_s, channels); /* fft norm and phase */
fvec_t * out = new_fvec (win_s, channels); /* output buffer */
/* allocate fft and other memory space */
aubio_mfft_t * fft = new_aubio_mfft(win_s,channels);
/* fill input with some data */
//printf("initialised\n");
/* execute stft */
aubio_mfft_do (fft,in,fftgrain);
//printf("computed forward\n");
/* execute inverse fourier transform */
aubio_mfft_rdo(fft,fftgrain,out);
//printf("computed backard\n");
del_aubio_mfft(fft);
del_fvec(in);
del_cvec(fftgrain);
del_fvec(out);
//printf("memory freed\n");
aubio_cleanup();
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 ()
{
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 (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] [win_size] [hop_size]\n", argv[0]);
return err;
}
uint_t samplerate = 0;
if ( argc >= 3 ) samplerate = atoi(argv[2]);
uint_t win_size = 1024; // window size
if ( argc >= 4 ) win_size = atoi(argv[3]);
uint_t hop_size = win_size / 4;
if ( argc >= 5 ) hop_size = atoi(argv[4]);
uint_t n_frames = 0, read = 0;
char_t *source_path = argv[1];
aubio_source_t * source = new_aubio_source(source_path, samplerate, hop_size);
if (!source) { err = 1; goto beach; }
if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(source);
// create some vectors
fvec_t * in = new_fvec (hop_size); // input audio buffer
fvec_t * out = new_fvec (1); // output position
// create tempo object
aubio_tempo_t * o = new_aubio_tempo("default", win_size, hop_size, samplerate);
do {
// put some fresh data in input vector
aubio_source_do(source, in, &read);
// execute tempo
aubio_tempo_do(o,in,out);
// do something with the beats
if (out->data[0] != 0) {
PRINT_MSG("beat at %.3fms, %.3fs, frame %d, %.2fbpm with confidence %.2f\n",
aubio_tempo_get_last_ms(o), aubio_tempo_get_last_s(o),
aubio_tempo_get_last(o), aubio_tempo_get_bpm(o), aubio_tempo_get_confidence(o));
}
n_frames += read;
} while ( read == hop_size );
PRINT_MSG("read %.2fs, %d frames at %dHz (%d blocks) from %s\n",
n_frames * 1. / samplerate,
n_frames, samplerate,
n_frames / hop_size, source_path);
// clean up memory
del_aubio_tempo(o);
del_fvec(in);
del_fvec(out);
del_aubio_source(source);
beach:
aubio_cleanup();
return err;
}
AubioPitch::~AubioPitch(){
del_aubio_pitchdetection(pitchDetect);
del_fvec(vec);
aubio_cleanup();
//delk fvec
}
AubioOnsetDetector :: ~AubioOnsetDetector(){
aubio_onsetdetection_free (o);
del_aubio_pvoc(pv);
del_aubio_peakpicker(parms);
del_fvec(vec);
aubio_cleanup();
}
int main (int argc, char **argv)
{
sint_t err = 0;
if (argc < 4) {
err = 2;
PRINT_ERR("not enough arguments\n");
PRINT_MSG("usage: %s <input_path> <output_path> <sample_path> [samplerate]\n", argv[0]);
return err;
}
uint_t samplerate = 0; // default is the samplerate of input_path
uint_t hop_size = 256;
uint_t n_frames = 0, read = 0;
char_t *source_path = argv[1];
char_t *sink_path = argv[2];
char_t *sample_path = argv[3];
if ( argc == 5 ) samplerate = atoi(argv[4]);
fvec_t *vec = new_fvec(hop_size);
aubio_source_t *source = new_aubio_source(source_path, samplerate, hop_size);
if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(source);
aubio_sink_t *sink = new_aubio_sink(sink_path, samplerate);
aubio_sampler_t * sampler = new_aubio_sampler (samplerate, hop_size);
aubio_sampler_load (sampler, sample_path);
do {
aubio_source_do(source, vec, &read);
if (n_frames / hop_size == 10) {
aubio_sampler_play ( sampler );
}
if (n_frames / hop_size == 40) {
aubio_sampler_play ( sampler );
}
if (n_frames / hop_size == 70) {
aubio_sampler_play ( sampler );
}
if (n_frames > 10.0 * samplerate) {
aubio_sampler_stop ( sampler );
}
aubio_sampler_do (sampler, vec, vec);
aubio_sink_do(sink, vec, read);
n_frames += read;
} while ( read == hop_size );
del_aubio_sampler(sampler);
del_aubio_source(source);
del_aubio_sink(sink);
del_fvec(vec);
aubio_cleanup();
return 0;
}
void examples_common_del (void)
{
#ifdef HAVE_JACK
if (ev.buffer) free(ev.buffer);
#endif
del_fvec (ibuf);
del_fvec (obuf);
aubio_cleanup ();
fflush(stderr);
fflush(stdout);
}
int main (void)
{
uint_t n = 10; // compute n times
uint_t win_s = 1024; // window size
uint_t hop_s = 256; // hop size
// create some vectors
fvec_t * in = new_fvec (hop_s); // input buffer
cvec_t * fftgrain = new_cvec (win_s); // fft norm and phase
cvec_t * cstead = new_cvec (win_s); // fft norm and phase
cvec_t * ctrans = new_cvec (win_s); // fft norm and phase
fvec_t * stead = new_fvec (hop_s); // output buffer
fvec_t * trans = new_fvec (hop_s); // output buffer
// create phase vocoder for analysis of input signal
aubio_pvoc_t * pv = new_aubio_pvoc (win_s,hop_s);
// create transient/steady-state separation object
aubio_tss_t * tss = new_aubio_tss(win_s,hop_s);
// create phase vocoder objects for synthesis of output signals
aubio_pvoc_t * pvt = new_aubio_pvoc(win_s,hop_s);
aubio_pvoc_t * pvs = new_aubio_pvoc(win_s,hop_s);
/* execute stft */
while ( n-- ) {
// fftgrain = pv(in)
aubio_pvoc_do (pv, in, fftgrain);
// ctrans, cstead = tss (fftgrain)
aubio_tss_do (tss, fftgrain, ctrans, cstead);
// stead = pvt_inverse (cstead)
// trans = pvt_inverse (ctrans)
aubio_pvoc_rdo (pvt, cstead, stead);
aubio_pvoc_rdo (pvs, ctrans, trans);
}
aubio_tss_set_alpha(tss, 4.);
aubio_tss_set_beta(tss, 3.);
aubio_tss_set_threshold(tss, 3.);
del_aubio_pvoc(pv);
del_aubio_pvoc(pvt);
del_aubio_pvoc(pvs);
del_aubio_tss(tss);
del_fvec(in);
del_cvec(fftgrain);
del_cvec(cstead);
del_cvec(ctrans);
del_fvec(stead);
del_fvec(trans);
aubio_cleanup();
return 0;
}
void testApp::exit(){
// stop the audio thread first, this was causing the crashes:
ss.stop();
// for (int i = 0; i < numAPDs; i++) {
// aubioPitchDetector * APD = static_cast<aubioPitchDetector*>(pitchDetectors[i]);
// APD->cleanup();
// }
aubio_cleanup();
}
int main (void)
{
int return_code = 0;
uint_t i, n_iters = 100; // number of iterations
uint_t win_s = 500; // window size
fvec_t * in = new_fvec (win_s); // input buffer
cvec_t * fftgrain = new_cvec (win_s); // fft norm and phase
fvec_t * out = new_fvec (win_s); // output buffer
// create fft object
aubio_fft_t * fft = new_aubio_fft(win_s);
if (!fft) {
return_code = 1;
goto beach;
}
// fill input with some data
in->data[0] = 1;
in->data[1] = 2;
in->data[2] = 3;
in->data[3] = 4;
in->data[4] = 5;
in->data[5] = 6;
in->data[6] = 5;
in->data[7] = 6;
//fvec_print(in);
for (i = 0; i < n_iters; i++) {
// execute stft
aubio_fft_do (fft,in,fftgrain);
cvec_print(fftgrain);
// execute inverse fourier transform
aubio_fft_rdo(fft,fftgrain,out);
}
// cleam up
//fvec_print(out);
del_aubio_fft(fft);
beach:
del_fvec(in);
del_cvec(fftgrain);
del_fvec(out);
aubio_cleanup();
return return_code;
}
static void cleanupTss(LV2_Handle instance)
{
tss_t* t=(tss_t*)instance;
del_fvec(t->inbuff);
del_fvec(t->transbuff);
del_fvec(t->steadybuff);
del_cvec (t->ci);
del_cvec (t->ct);
del_cvec (t->cs);
del_aubio_tss(t->tss);
del_aubio_pvoc(t->pv);
del_aubio_pvoc(t->pvs);
del_aubio_pvoc(t->pvt);
free(instance);
aubio_cleanup(); //Not sure if I should do this.
}
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(){
/* allocate some memory */
uint_t win_s = 1024; /* window size */
fvec_t * in = new_fvec (win_s/4); /* input buffer */
fvec_t * out = new_fvec (2); /* input buffer */
aubio_onset_t * onset = new_aubio_onset("complex", win_s, win_s/4, 44100.);
uint_t i = 0;
while (i < 10) {
aubio_onset_do (onset,in,out);
i++;
};
del_aubio_onset(onset);
del_fvec(in);
del_fvec(out);
aubio_cleanup();
return 0;
}
int main(){
/* allocate some memory */
uint_t win_s = 1024; /* window size */
uint_t hop_s = win_s/4; /* hop size */
fvec_t * in = new_fvec (hop_s); /* input buffer */
fvec_t * out = new_fvec (1);
aubio_pitchfcomb_t * o = new_aubio_pitchfcomb (
win_s, hop_s);
uint_t i = 0;
while (i < 2) {
aubio_pitchfcomb_do (o,in, out);
i++;
};
del_aubio_pitchfcomb(o);
del_fvec(in);
aubio_cleanup();
return 0;
}
int main(){
/* allocate some memory */
uint_t win_s = 1024; /* window size */
fvec_t * in = new_fvec (win_s); /* input buffer */
fvec_t * out = new_fvec (1); /* output pitch periods */
aubio_pitchyinfft_t * o = new_aubio_pitchyinfft(win_s);
aubio_pitchyinfft_set_tolerance (o, 0.2);
uint_t i = 0;
while (i < 10) {
aubio_pitchyinfft_do (o,in,out);
i++;
};
del_aubio_pitchyinfft(o);
del_fvec(in);
del_fvec(out);
aubio_cleanup();
return 0;
}
int
main (void)
{
/* allocate some memory */
uint_t win_s = 1024; /* window size */
uint_t n_filters = 13; /* number of filters */
cvec_t *in = new_cvec (win_s); /* input buffer */
fvec_t *out = new_fvec (win_s); /* input buffer */
fmat_t *coeffs = NULL;
/* allocate fft and other memory space */
aubio_filterbank_t *o = new_aubio_filterbank (n_filters, win_s);
coeffs = aubio_filterbank_get_coeffs (o);
if (coeffs == NULL) {
return -1;
}
/*
if (fvec_max (coeffs) != 0.) {
return -1;
}
if (fvec_min (coeffs) != 0.) {
return -1;
}
*/
fmat_print (coeffs);
aubio_filterbank_do (o, in, out);
del_aubio_filterbank (o);
del_cvec (in);
del_fvec (out);
aubio_cleanup ();
return 0;
}
int main (void)
{
uint_t i = 0;
uint_t win_s = 1024; // window size
uint_t hop_s = win_s/4; // hop size
// create some vectors
fvec_t * in = new_fvec (hop_s); // input buffer
fvec_t * out = new_fvec (1); // output candidates
// create pitch object
aubio_pitchfcomb_t * o = new_aubio_pitchfcomb ( win_s, hop_s);
while (i < 10) {
aubio_pitchfcomb_do (o,in, out);
i++;
};
del_aubio_pitchfcomb(o);
del_fvec(out);
del_fvec(in);
aubio_cleanup();
return 0;
}
int main(){
int i;
uint_t win_s = 1024; /* window size */
uint_t hop_s = 256; /* hop size */
uint_t channels = 4; /* number of channels */
/* allocate some memory */
fvec_t * in = new_fvec (hop_s, channels); /* input buffer */
cvec_t * fftgrain = new_cvec (win_s, channels); /* fft norm and phase */
cvec_t * cstead = new_cvec (win_s, channels); /* fft norm and phase */
cvec_t * ctrans = new_cvec (win_s, channels); /* fft norm and phase */
fvec_t * stead = new_fvec (hop_s, channels); /* output buffer */
fvec_t * trans = new_fvec (hop_s, channels); /* output buffer */
/* allocate fft and other memory space */
aubio_pvoc_t * pv = new_aubio_pvoc (win_s,hop_s,channels);
aubio_pvoc_t * pvt = new_aubio_pvoc(win_s,hop_s,channels);
aubio_pvoc_t * pvs = new_aubio_pvoc(win_s,hop_s,channels);
aubio_tss_t * tss = new_aubio_tss(0.01,3.,4.,win_s,hop_s,channels);
/* fill input with some data */
printf("initialised\n");
/* execute stft */
for (i = 0; i < 10; i++) {
aubio_pvoc_do (pv,in,fftgrain);
aubio_tss_do (tss,fftgrain,ctrans,cstead);
aubio_pvoc_rdo(pvt,cstead,stead);
aubio_pvoc_rdo(pvs,ctrans,trans);
}
del_aubio_pvoc(pv);
del_fvec(in);
del_cvec(fftgrain);
del_cvec(cstead);
del_cvec(ctrans);
del_fvec(stead);
del_fvec(trans);
aubio_cleanup();
printf("memory freed\n");
return 0;
}
int main ()
{
uint_t win_s = 1024; // window size
uint_t n_filters = 13; // number of filters
cvec_t *in_spec = new_cvec (win_s); // input vector of samples
fvec_t *out_filters = new_fvec (n_filters); // per-band outputs
// create filterbank object
aubio_filterbank_t *o = new_aubio_filterbank (n_filters, win_s);
// apply filterbank ten times
uint_t n = 10;
while (n) {
aubio_filterbank_do (o, in_spec, out_filters);
n--;
}
// print out filterbank coeffs
fmat_t *coeffs; // pointer to the coefficients
coeffs = aubio_filterbank_get_coeffs (o);
fmat_print (coeffs);
aubio_filterbank_set_coeffs (o, coeffs);
coeffs = aubio_filterbank_get_coeffs (o);
fmat_print (coeffs);
//fvec_print (out_filters);
// clean up
del_aubio_filterbank (o);
del_cvec (in_spec);
del_fvec (out_filters);
aubio_cleanup ();
return 0;
}
int main (void)
{
uint_t samplerate = 16000; // samplerate of signal to filter
uint_t win_s = 512; // fft size
uint_t n_filters = 40; // number of filters
cvec_t *in_spec = new_cvec (win_s); // input vector of samples
fvec_t *out_filters = new_fvec (n_filters); // per-band outputs
// create filterbank object
aubio_filterbank_t *o = new_aubio_filterbank (n_filters, win_s);
// assign Mel-frequency coefficients
aubio_filterbank_set_mel_coeffs_slaney (o, samplerate);
// apply filterbank ten times
uint_t n = 10;
while (n) {
aubio_filterbank_do (o, in_spec, out_filters);
n--;
}
// print out filter coefficients
fmat_t *coeffs; // pointer to the coefficients
coeffs = aubio_filterbank_get_coeffs (o);
fmat_print (coeffs);
//fvec_print (out_filters);
del_aubio_filterbank (o);
del_cvec (in_spec);
del_fvec (out_filters);
aubio_cleanup ();
return 0;
}
int main(){
/* allocate some memory */
uint_t win_s = 1024; /* window size */
uint_t channels = 1; /* number of channel */
fvec_t * in = new_fvec (win_s, channels); /* input buffer */
fvec_t * out = new_fvec (win_s/4, channels); /* input buffer */
/* allocate fft and other memory space */
aubio_beattracking_t * tempo = new_aubio_beattracking(win_s, channels);
uint_t i = 0;
while (i < 10) {
aubio_beattracking_do(tempo,in,out);
i++;
};
del_aubio_beattracking(tempo);
del_fvec(in);
del_fvec(out);
aubio_cleanup();
return 0;
}
int
main ()
{
/* allocate some memory */
uint_t win_s = 1024; /* window size */
uint_t hop_s = win_s / 4; /* hop size */
uint_t samplerate = 44100; /* samplerate */
fvec_t *in = new_fvec (hop_s); /* input buffer */
fvec_t *out = new_fvec (1); /* input buffer */
aubio_pitch_t *o =
new_aubio_pitch ("default", win_s, hop_s, samplerate);
uint_t i = 0;
while (i < 100) {
aubio_pitch_do (o, in, out);
i++;
};
del_aubio_pitch (o);
del_fvec (in);
aubio_cleanup ();
return 0;
}
//--------------------------------------------------------------
aubioAnalyzer::~aubioAnalyzer(){
del_aubio_pitchdetection(pitch_output);
del_fvec(in);
aubio_cleanup();
}
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;
}
//Creates a list of times which the aubio onset detector thinks are note onset times for the audio Denemo->si->recording
//Result is placed in Denemo->si->note_onsets
void
generate_note_onsets (void)
{
DenemoRecording *audio = Denemo.project->movement->recording;
gint channels = audio->channels;
smpl_t threshold = 0.3;
smpl_t silence = -90.;
uint_t buffer_size = 1024;
uint_t overlap_size = 512;
uint_t samplerate = 44100;
aubio_onset_t *o = new_aubio_onset("default",
buffer_size, overlap_size, samplerate);
fvec_t *ibuf = new_fvec (overlap_size);
fvec_t *onset = new_fvec (2);
unsigned int pos = 0; /*frames%dspblocksize */
unsigned int i; /*channels */
unsigned int j; /*frames */
busy_cursor (Denemo.notebook);
gtk_window_set_modal (progressbar (_("Analysing Audio"), NULL), TRUE);
rewind_audio ();
if (audio->notes)
{
g_list_free_full (audio->notes, g_free);
audio->notes = NULL;
}
for (j = 0; j < (unsigned) audio->nframes; j++)
{
sf_read_float (audio->sndfile, ibuf->data + pos, 2); //g_debug("\t%f", ibuf->data[0][pos]);
if (pos == overlap_size - 1)
{
/* block loop */
gtk_main_iteration_do (FALSE);
aubio_onset_do (o, ibuf, onset);
while (gtk_events_pending ())
gtk_main_iteration ();
if(onset->data[0] != 0) {
DenemoRecordedNote *note = g_malloc0(sizeof(DenemoRecordedNote));
note->timing = aubio_onset_get_last(o);/* aubio_onset_get_delay_s(o) for seconds */
audio->notes = g_list_append (audio->notes, note);
}
pos = -1; /* so it will be zero next j loop */
} /* end of if pos==overlap_size-1 */
pos++;
}
del_aubio_onset (o);
del_fvec (ibuf);
del_fvec (onset);
aubio_cleanup ();
progressbar_stop ();
normal_cursor (Denemo.notebook);
}
