sigrid/aubio

plugins/puredata/aubiopitch~.c+2−1

 char aubiopitch_version[] = "aubiopitch~ version 0.1";
-aubio_pitchdetection_type type_pitch = aubio_pitch_mcomb;
+aubio_pitchdetection_type type_pitch = aubio_pitch_yinfft;
 aubio_pitchdetection_mode mode_pitch = aubio_pitchm_freq;
 static t_class *aubiopitch_tilde_class;
 	//FIXME: get the real samplerate
     	x->o = new_aubio_pitchdetection(x->bufsize*4,
                     x->hopsize, 1, 44100., type_pitch, mode_pitch);
+	aubio_pitchdetection_set_yinthresh(x->o, 0.7);
 	x->vec = (fvec_t *)new_fvec(x->hopsize,1);
   	//floatinlet_new (&x->x_obj, &x->threshold);

python/aubio/task/pitch.py+10−4

 	def __init__(self,input,params=None):
 		task.__init__(self,input,params=params)
 		self.shortlist = [0. for i in range(self.params.pitchsmooth)]
+		if self.params.pitchmode == 'yinfft':
+			yinthresh = self.params.yinfftthresh
+		elif self.params.pitchmode == 'yin':
+			yinthresh = self.params.yinthresh
+		else:
+			yinthresh = 0.
 		self.pitchdet  = pitchdetection(mode=get_pitch_mode(self.params.pitchmode),
 			bufsize=self.params.bufsize,
 			hopsize=self.params.hopsize,
 			channels=self.channels,
 			samplerate=self.srate,
 			omode=self.params.omode,
-			yinthresh=self.params.yinthresh)
+			yinthresh=yinthresh)
 	def __call__(self):
 		from aubio.median import short_find
 				time,pitch =[],[]
 				while(tasksil.readsize==tasksil.params.hopsize):
 					tasksil()
-					time.append(tasksil.params.step*tasksil.frameread)
+					time.append(tasksil.params.step*(tasksil.frameread))
 					if not tasksil.issilence:
 						pitch.append(self.truth)
 					else:
 			title=self.params.pitchmode))
-	def plotplot(self,wplot,oplots,outplot=None,multiplot = 1, midi = 1):
+	def plotplot(self,wplot,oplots,outplot=None,multiplot = 0, midi = 1):
 		from aubio.gnuplot import gnuplot_init, audio_to_array, make_audio_plot
 		import re
 		import Gnuplot
 			g('set yrange [100:%f]' % self.params.pitchmax)
 		else:
 			g.ylabel('pitch (midi)')
-			g('set yrange [%f:%f]' % (40, aubio_freqtomidi(self.params.pitchmax)))
+			g('set yrange [%f:%f]' % (aubio_freqtomidi(self.params.pitchmin), aubio_freqtomidi(self.params.pitchmax)))
 		g('set key right top')
 		g('set noclip one')
 		g('set format x ""')

python/aubio/task/utils.py+2−0

 		 return aubio_pitch_fcomb
 	elif nvalue == 'schmitt':
 		 return aubio_pitch_schmitt
+	elif nvalue == 'yinfft':
+		 return aubio_pitch_yinfft
 	else:
 		 import sys
 		 print "error: unknown pitch detection function selected"

python/aubiopitch+1−2

@@ -89,7 +89,7 @@ params.samplerate = float(sndfile(filename).samplerate()) · 88 unmodified lines
89	params.hopsize = int(options.hopsize)	89	params.hopsize = int(options.hopsize)
90	params.bufsize = int(options.bufsize)	90	params.bufsize = int(options.bufsize)
91	params.step = params.samplerate/float(params.hopsize)	91	params.step = params.samplerate/float(params.hopsize)
92	params.threshold = float(options.threshold)	92	params.yinthresh = float(options.threshold)
93	params.silence = float(options.silence)	93	params.silence = float(options.silence)
94	params.verbose = options.verbose	94	params.verbose = options.verbose
95	#mintol = float(options.mintol)*step	95	#mintol = float(options.mintol)*step
@@ -100,7 +100,6 @@ else: delay = 2./params.step · 4 unmodified lines
100	if options.note:	100	if options.note:
101	exit("not implemented yet")	101	exit("not implemented yet")
102		102
103
104	wplot,oplots = [],[]	103	wplot,oplots = [],[]
105	modes = options.mode.split(',')	104	modes = options.mode.split(',')
106	for i in range(len(modes)):	105	for i in range(len(modes)):

src/Makefile.am+3−0

 	pitchyin.h \
 	pitchschmitt.h \
 	pitchfcomb.h \
+	pitchyinfft.h \
 	beattracking.h \
 	filter.h
 nodist_pkginclude_HEADERS = config.h
 	pitchschmitt.h \
 	pitchfcomb.c \
 	pitchfcomb.h \
+	pitchyinfft.c \
+	pitchyinfft.h \
 	beattracking.c \
 	beattracking.h \
 	filter.c \

src/pitchdetection.c+25−1

 #include "pitchyin.h"
 #include "pitchfcomb.h"
 #include "pitchschmitt.h"
+#include "pitchyinfft.h"
 #include "pitchdetection.h"
 typedef smpl_t (*aubio_pitchdetection_func_t)(aubio_pitchdetection_t *p,
 	aubio_pitchmcomb_t * mcomb;
 	aubio_pitchfcomb_t * fcomb;
 	aubio_pitchschmitt_t * schmitt;
+	aubio_pitchyinfft_t * yinfft;
 	aubio_filter_t * filter;
 	/* for yin */
 	fvec_t * buf;
 		case aubio_pitch_mcomb:
 			p->pv       = new_aubio_pvoc(bufsize, hopsize, channels);
 			p->fftgrain = new_cvec(bufsize, channels);
-			p->mcomb    = new_aubio_pitchmcomb(bufsize,channels,samplerate);
+			p->mcomb    = new_aubio_pitchmcomb(bufsize,hopsize,channels,samplerate);
 			p->filter   = new_aubio_cdsgn_filter(samplerate);
                         p->callback = aubio_pitchdetection_mcomb;
 			break;
                         p->schmitt  = new_aubio_pitchschmitt(bufsize,samplerate);
                         p->callback = aubio_pitchdetection_schmitt;
                         break;
+		case aubio_pitch_yinfft:
+			p->buf      = new_fvec(bufsize,channels);
+                        p->yinfft   = new_aubio_pitchyinfft(bufsize);
+                        p->callback = aubio_pitchdetection_yinfft;
+			p->yinthres = 0.2;
+                        break;
                 default:
                         break;
 	}
 			del_fvec(p->buf);
                         del_aubio_pitchfcomb(p->fcomb);
                         break;
+                case aubio_pitch_yinfft:
+			del_fvec(p->buf);
+                        del_aubio_pitchyinfft(p->yinfft);
+                        break;
 		default:
 			break;
 	}
 }
+smpl_t aubio_pitchdetection_yinfft(aubio_pitchdetection_t *p, fvec_t *ibuf){
+	smpl_t pitch = 0.;
+	aubio_pitchdetection_slideblock(p,ibuf);
+	pitch = aubio_pitchyinfft_detect(p->yinfft,p->buf,p->yinthres);
+        if (pitch>0) {
+                pitch = p->srate/(pitch+0.);
+        } else {
+                pitch = 0.;
+        }
+	return pitch;
+}
 smpl_t aubio_pitchdetection_fcomb(aubio_pitchdetection_t *p, fvec_t *ibuf){
         aubio_pitchdetection_slideblock(p,ibuf);
         return aubio_pitchfcomb_detect(p->fcomb,p->buf);

src/pitchdetection.h+3−1

         aubio_pitch_yin,
         aubio_pitch_mcomb,
         aubio_pitch_schmitt,
-        aubio_pitch_fcomb
+        aubio_pitch_fcomb,
+	aubio_pitch_yinfft
 } aubio_pitchdetection_type;
 typedef enum {
 smpl_t aubio_pitchdetection_yin(aubio_pitchdetection_t *p, fvec_t *ibuf);
 smpl_t aubio_pitchdetection_schmitt(aubio_pitchdetection_t *p, fvec_t *ibuf);
 smpl_t aubio_pitchdetection_fcomb(aubio_pitchdetection_t *p, fvec_t *ibuf);
+smpl_t aubio_pitchdetection_yinfft(aubio_pitchdetection_t *p, fvec_t *ibuf);
 void aubio_pitchdetection_set_yinthresh(aubio_pitchdetection_t *p, smpl_t thres);
 void del_aubio_pitchdetection(aubio_pitchdetection_t * p);

src/pitchyinfft.c+163−0

@@ -0,0 +1,163 @@
	1	/*
	2	Copyright (C) 2003 Paul Brossier
	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2 of the License, or
	7	(at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software
	16	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	17	*/
	18
	19	/* This algorithm was developped by A. de Cheveigne and H. Kawahara and
	20	* published in:
	21	*
	22	* de Cheveigné, A., Kawahara, H. (2002) "YIN, a fundamental frequency
	23	* estimator for speech and music", J. Acoust. Soc. Am. 111, 1917-1930.
	24	*
	25	* see http://recherche.ircam.fr/equipes/pcm/pub/people/cheveign.html
	26	*
	27	* This implementation is using an FFT to compute the square difference
	28	* function, which allows spectral weighting
	29	*
	30	*/
	31
	32	#include "aubio_priv.h"
	33	#include "sample.h"
	34	#include "mathutils.h"
	35	#include "fft.h"
	36	#include "pitchyinfft.h"
	37
	38	struct _aubio_pitchyinfft_t {
	39	uint_t bufsize;
	40	uint_t rate;
	41	fvec_t * win;
	42	fvec_t * winput;
	43	cvec_t * res;
	44	fvec_t * sqrmag;
	45	fvec_t * weight;
	46	cvec_t * fftout;
	47	aubio_mfft_t * fft;
	48	fvec_t * yinfft;
	49	};
	50
	51	static const smpl_t freqs[] = {0., 20., 25., 31.5, 40., 50., 63., 80., 100.,
	52	125., 160., 200., 250., 315., 400., 500., 630., 800., 1000., 1250.,
	53	1600., 2000., 2500., 3150., 4000., 5000., 6300., 8000., 9000., 10000.,
	54	12500., 15000., 20000., 25100};
	55
	56	static const smpl_t weight[] = {-75.8, -70.1, -60.8, -52.1, -44.2, -37.5,
	57	-31.3, -25.6, -20.9, -16.5, -12.6, -9.6, -7.0, -4.7, -3.0, -1.8, -0.8,
	58	-0.2, -0.0, 0.5, 1.6, 3.2, 5.4, 7.8, 8.1, 5.3, -2.4, -11.1, -12.8,
	59	-12.2, -7.4, -17.8, -17.8, -17.8};
	60
	61	aubio_pitchyinfft_t * new_aubio_pitchyinfft (uint_t bufsize)
	62	{
	63	aubio_pitchyinfft_t * p = AUBIO_NEW(aubio_pitchyinfft_t);
	64	p->bufsize = bufsize;
	65	p->winput = new_fvec(bufsize,1);
	66	p->fft = new_aubio_mfft(bufsize, 1);
	67	p->fftout = new_cvec(bufsize,1);
	68	p->sqrmag = new_fvec(bufsize,1);
	69	p->res = new_cvec(bufsize,1);
	70	p->yinfft = new_fvec(bufsize/2+1,1);
	71	p->win = new_fvec(bufsize,1);
	72	aubio_window(p->win->data[0], bufsize, aubio_win_hanningz);
	73	p->weight = new_fvec(bufsize/2+1,1);
	74	{
	75	uint_t i = 0, j = 1;
	76	smpl_t freq = 0, a0 = 0, a1 = 0, f0 = 0, f1 = 0;
	77	for (i=0; i<p->weight->length; i++) {
	78	freq = (smpl_t)i/(smpl_t)bufsize*(smpl_t)44100.;
	79	while (freq > freqs[j]) {
	80	j +=1;
	81	}
	82	a0 = weight[j-1];
	83	f0 = freqs[j-1];
	84	a1 = weight[j];
	85	f1 = freqs[j];
	86	if (f0 == f1) { // just in case
	87	p->weight->data[0][i] = a0;
	88	} else if (f0 == 0) { // y = ax+b
	89	p->weight->data[0][i] = (a1-a0)/f1*freq + a0;
	90	} else {
	91	p->weight->data[0][i] = (a1-a0)/(f1-f0)*freq +
	92	(a0 - (a1 - a0)/(f1/f0 - 1.));
	93	}
	94	while (freq > freqs[j]) {
	95	j +=1;
	96	}
	97	//AUBIO_DBG("%f\n",p->weight->data[0][i]);
	98	p->weight->data[0][i] = DB2LIN(p->weight->data[0][i]);
	99	//p->weight->data[0][i] = SQRT(DB2LIN(p->weight->data[0][i]));
	100	}
	101	}
	102	return p;
	103	}
	104
	105	smpl_t aubio_pitchyinfft_detect(aubio_pitchyinfft_t * p, fvec_t * input, smpl_t tol) {
	106	uint_t tau, l = 0;
	107	uint_t halfperiod;
	108	smpl_t tmp = 0, sum = 0;
	109	cvec_t * res = (cvec_t *)p->res;
	110	fvec_t * yin = (fvec_t *)p->yinfft;
	111	for (l=0; l < input->length; l++){
	112	p->winput->data[0][l] = p->win->data[0][l] * input->data[0][l];
	113	}
	114	aubio_mfft_do(p->fft,p->winput,p->fftout);
	115	for (l=0; l < p->fftout->length; l++){
	116	p->sqrmag->data[0][l] = SQR(p->fftout->norm[0][l]);
	117	p->sqrmag->data[0][(p->fftout->length-1)*2-l] =
	118	SQR(p->fftout->norm[0][l]);
	119	p->sqrmag->data[0][l] *= p->weight->data[0][l];
	120	p->sqrmag->data[0][(p->fftout->length-1)2-l] =
	121	p->weight->data[0][l];
	122	}
	123	for (l=0; l < p->sqrmag->length/2+1; l++) {
	124	sum += p->sqrmag->data[0][l];
	125	}
	126	sum *= 2.;
	127	aubio_mfft_do(p->fft,p->sqrmag,res);
	128	yin->data[0][0] = 1.;
	129	for (tau=1; tau < yin->length; tau++) {
	130	yin->data[0][tau] = sum -
	131	res->norm[0][tau+1]*COS(res->phas[0][tau+1]);
	132	tmp += yin->data[0][tau];
	133	yin->data[0][tau] *= tau/tmp;
	134	}
	135	tau = vec_min_elem(yin);
	136	if (yin->data[0][tau] < tol) {
	137	/* no interpolation */
	138	//return tau+2;
	139	/* 3 point quadratic interpolation */
	140	//return vec_quadint_min(yin,tau,1);
	141	/* additional check nlikely octave doubling in higher frequencies */
	142	if (tau>35) {
	143	return vec_quadint_min(yin,tau,1)+1;
	144	} else {
	145	/* should compare the minimum value of each interpolated peaks */
	146	halfperiod = FLOOR(tau/2+.5);
	147	if (yin->data[0][halfperiod] < tol)
	148	return vec_quadint_min(yin,halfperiod,1)+1;
	149	else
	150	return vec_quadint_min(yin,tau,1)+1;
	151	}
	152	} else
	153	return 0;
	154	}
	155
	156	void del_aubio_pitchyinfft(aubio_pitchyinfft_t *p){
	157	del_fvec(p->win);
	158	del_aubio_mfft(p->fft);
	159	del_fvec(p->yinfft);
	160	del_fvec(p->sqrmag);
	161	del_cvec(p->res);
	162	del_cvec(p->fftout);
	163	}

src/pitchyinfft.h+45−0

@@ -0,0 +1,45 @@
	1	/*
	2	Copyright (C) 2003 Paul Brossier
	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2 of the License, or
	7	(at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software
	16	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	17	*/
	18
	19	/* This algorithm was developped by A. de Cheveigne and H. Kawahara and
	20	* published in:
	21	*
	22	* de Cheveigné, A., Kawahara, H. (2002) "YIN, a fundamental frequency
	23	* estimator for speech and music", J. Acoust. Soc. Am. 111, 1917-1930.
	24	*
	25	* see http://recherche.ircam.fr/equipes/pcm/pub/people/cheveign.html
	26	*/
	27
	28	#ifndef PITCHYINFFT_H
	29	#define PITCHYINFFT_H
	30
	31	#ifdef __cplusplus
	32	extern "C" {
	33	#endif
	34
	35	typedef struct _aubio_pitchyinfft_t aubio_pitchyinfft_t;
	36
	37	smpl_t aubio_pitchyinfft_detect (aubio_pitchyinfft_t p, fvec_t input, smpl_t tol);
	38	aubio_pitchyinfft_t * new_aubio_pitchyinfft (uint_t bufsize);
	39	void del_aubio_pitchyinfft (aubio_pitchyinfft_t *p);
	40
	41	#ifdef __cplusplus
	42	}
	43	#endif
	44
	45	#endif /PITCHYINFFT_H/

swig/aubio.i+4−3

         aubio_pitch_yin,
         aubio_pitch_mcomb,
         aubio_pitch_schmitt,
-        aubio_pitch_fcomb
+        aubio_pitch_fcomb,
+	aubio_pitch_yinfft
 } aubio_pitchdetection_type;
 typedef enum {
 /* pitch mcomb */
-aubio_pitchmcomb_t * new_aubio_pitchmcomb(uint_t size, uint_t channels, uint_t samplerate);
+aubio_pitchmcomb_t * new_aubio_pitchmcomb(uint_t bufsize, uint_t hopsize, uint_t channels, uint_t samplerate);
 smpl_t aubio_pitchmcomb_detect(aubio_pitchmcomb_t * p, cvec_t * fftgrain);
 uint_t aubio_pitch_cands(aubio_pitchmcomb_t * p, cvec_t * fftgrain, smpl_t * cands);
 void del_aubio_pitchmcomb (aubio_pitchmcomb_t *p);
 void aubio_pitchyin_diff(fvec_t *input, fvec_t *yin);
 void aubio_pitchyin_getcum(fvec_t *yin);
 uint_t aubio_pitchyin_getpitch(fvec_t *yin);
-uint_t aubio_pitchyin_getpitchfast(fvec_t * input, fvec_t *yin, smpl_t tol);
+smpl_t aubio_pitchyin_getpitchfast(fvec_t * input, fvec_t *yin, smpl_t tol);
 /* pitch schmitt */
 aubio_pitchschmitt_t * new_aubio_pitchschmitt (uint_t size, uint_t samplerate);

add yinfft method, make it default for pd plugin add yinfft method, make it default for pd plugin

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code