aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorHans-Christoph Steiner <eighthave@users.sourceforge.net>2007-12-13 04:10:52 +0000
committerHans-Christoph Steiner <eighthave@users.sourceforge.net>2007-12-13 04:10:52 +0000
commit575e234b005d45dbcdf2afb274df56aac995ef2a (patch)
tree534cfe0964758295ef202aba842f59a0ab5fd230
imported jsarlo's DSP windowing objects from http://crca.ucsd.edu/~jsarlo/pd/windowing.tar.gz which has a date of 2002-04-06svn2git-root
svn path=/trunk/externals/windowing/; revision=9090
-rw-r--r--README18
-rw-r--r--bartlett~.c85
-rw-r--r--blackman~.c85
-rw-r--r--connes~.c85
-rw-r--r--cosine~.c85
-rw-r--r--gaussian~.c101
-rw-r--r--hamming~.c85
-rw-r--r--hanning~.c85
-rw-r--r--i0.c409
-rw-r--r--kaiser~.c99
-rw-r--r--lanczos~.c85
-rw-r--r--mconf.h200
-rw-r--r--welch~.c85
-rw-r--r--windowFunctions.c136
-rw-r--r--windowFunctions.h30
-rw-r--r--windowing.pd100
16 files changed, 1773 insertions, 0 deletions
diff --git a/README b/README
new file mode 100644
index 0000000..835705c
--- /dev/null
+++ b/README
@@ -0,0 +1,18 @@
+Porvides:
+ hammimng~, hanning~, blackman~, cosine~, connes~, bartlett~,
+ welch~, lanczos~, gaussian~, and kaiser~
+
+Usage:
+ Windows inlet signal on each DSP block and sends to outlet
+
+ gaussian~ takes one optional argument (standard deviation)
+ May be set by float in left inlet
+
+ kaiser~ takes one option argument (alpha)
+ May be set by float in left inlet
+
+ See windowing.pd
+
+To build:
+ Linux: make windowing_linux
+ Windows: nmake windowing_nt
diff --git a/bartlett~.c b/bartlett~.c
new file mode 100644
index 0000000..61d1127
--- /dev/null
+++ b/bartlett~.c
@@ -0,0 +1,85 @@
+/* bartlett~ - bartlett windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *bartlett_class;
+
+typedef struct _bartlett {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_bartlett;
+
+static t_int* bartlett_perform(t_int *w) {
+ t_bartlett *x = (t_bartlett *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillBartlett(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void bartlett_dsp(t_bartlett *x, t_signal **sp) {
+ dsp_add(bartlett_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* bartlett_new(void) {
+ t_bartlett *x = (t_bartlett *)pd_new(bartlett_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillBartlett(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void bartlett_free(t_bartlett *x) {
+ free(x->x_table);
+}
+
+void bartlett_tilde_setup(void) {
+ bartlett_class = class_new(gensym("bartlett~"),
+ (t_newmethod)bartlett_new,
+ (t_method)bartlett_free,
+ sizeof(t_bartlett),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(bartlett_class, nullfn, gensym("signal"), 0);
+ class_addmethod(bartlett_class, (t_method)bartlett_dsp, gensym("dsp"), 0);
+}
diff --git a/blackman~.c b/blackman~.c
new file mode 100644
index 0000000..1e48fcd
--- /dev/null
+++ b/blackman~.c
@@ -0,0 +1,85 @@
+/* blackman~ - blackman windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *blackman_class;
+
+typedef struct _blackman {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_blackman;
+
+static t_int* blackman_perform(t_int *w) {
+ t_blackman *x = (t_blackman *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillBlackman(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void blackman_dsp(t_blackman *x, t_signal **sp) {
+ dsp_add(blackman_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* blackman_new(void) {
+ t_blackman *x = (t_blackman *)pd_new(blackman_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillBlackman(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void blackman_free(t_blackman *x) {
+ free(x->x_table);
+}
+
+void blackman_tilde_setup(void) {
+ blackman_class = class_new(gensym("blackman~"),
+ (t_newmethod)blackman_new,
+ (t_method)blackman_free,
+ sizeof(t_blackman),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(blackman_class, nullfn, gensym("signal"), 0);
+ class_addmethod(blackman_class, (t_method)blackman_dsp, gensym("dsp"), 0);
+}
diff --git a/connes~.c b/connes~.c
new file mode 100644
index 0000000..5df68b0
--- /dev/null
+++ b/connes~.c
@@ -0,0 +1,85 @@
+/* connes~ - connes windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *connes_class;
+
+typedef struct _connes {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_connes;
+
+static t_int* connes_perform(t_int *w) {
+ t_connes *x = (t_connes *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillConnes(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void connes_dsp(t_connes *x, t_signal **sp) {
+ dsp_add(connes_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* connes_new(void) {
+ t_connes *x = (t_connes *)pd_new(connes_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillConnes(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void connes_free(t_connes *x) {
+ free(x->x_table);
+}
+
+void connes_tilde_setup(void) {
+ connes_class = class_new(gensym("connes~"),
+ (t_newmethod)connes_new,
+ (t_method)connes_free,
+ sizeof(t_connes),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(connes_class, nullfn, gensym("signal"), 0);
+ class_addmethod(connes_class, (t_method)connes_dsp, gensym("dsp"), 0);
+}
diff --git a/cosine~.c b/cosine~.c
new file mode 100644
index 0000000..76cdadf
--- /dev/null
+++ b/cosine~.c
@@ -0,0 +1,85 @@
+/* cosine~ - cosine windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *cosine_class;
+
+typedef struct _cosine {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_cosine;
+
+static t_int* cosine_perform(t_int *w) {
+ t_cosine *x = (t_cosine *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillCosine(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void cosine_dsp(t_cosine *x, t_signal **sp) {
+ dsp_add(cosine_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* cosine_new(void) {
+ t_cosine *x = (t_cosine *)pd_new(cosine_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillCosine(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void cosine_free(t_cosine *x) {
+ free(x->x_table);
+}
+
+void cosine_tilde_setup(void) {
+ cosine_class = class_new(gensym("cosine~"),
+ (t_newmethod)cosine_new,
+ (t_method)cosine_free,
+ sizeof(t_cosine),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(cosine_class, nullfn, gensym("signal"), 0);
+ class_addmethod(cosine_class, (t_method)cosine_dsp, gensym("dsp"), 0);
+}
diff --git a/gaussian~.c b/gaussian~.c
new file mode 100644
index 0000000..4716c8e
--- /dev/null
+++ b/gaussian~.c
@@ -0,0 +1,101 @@
+/* gaussian~ - gaussian windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFDELTA 0.5
+#define DEFBLOCKSIZE 64
+
+static t_class *gaussian_class;
+
+typedef struct _gaussian {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+ float x_delta;
+} t_gaussian;
+
+static t_int* gaussian_perform(t_int *w) {
+ t_gaussian *x = (t_gaussian *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillGaussian(x->x_table, x->x_blocksize, x->x_delta);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void gaussian_dsp(t_gaussian *x, t_signal **sp) {
+ dsp_add(gaussian_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void gaussian_float(t_gaussian *x, t_float delta) {
+ if (delta != 0) {
+ x->x_delta = delta;
+ fillGaussian(x->x_table, x->x_blocksize, x->x_delta);
+ }
+}
+
+static void* gaussian_new(float delta) {
+ t_gaussian *x = (t_gaussian *)pd_new(gaussian_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ if (delta == 0) {
+ x->x_delta = DEFDELTA;
+ }
+ else {
+ x->x_delta = delta;
+ }
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillGaussian(x->x_table, x->x_blocksize, x->x_delta);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void gaussian_free(t_gaussian *x) {
+ free(x->x_table);
+}
+
+void gaussian_tilde_setup(void) {
+ gaussian_class = class_new(gensym("gaussian~"),
+ (t_newmethod)gaussian_new,
+ (t_method)gaussian_free,
+ sizeof(t_gaussian),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(gaussian_class, nullfn, gensym("signal"), 0);
+ class_addmethod(gaussian_class, (t_method)gaussian_dsp, gensym("dsp"), 0);
+ class_addfloat(gaussian_class, (t_method)gaussian_float);
+}
diff --git a/hamming~.c b/hamming~.c
new file mode 100644
index 0000000..c5c10e2
--- /dev/null
+++ b/hamming~.c
@@ -0,0 +1,85 @@
+/* hamming~ - hamming windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *hamming_class;
+
+typedef struct _hamming {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_hamming;
+
+static t_int* hamming_perform(t_int *w) {
+ t_hamming *x = (t_hamming *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillHamming(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void hamming_dsp(t_hamming *x, t_signal **sp) {
+ dsp_add(hamming_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* hamming_new(void) {
+ t_hamming *x = (t_hamming *)pd_new(hamming_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillHamming(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void hamming_free(t_hamming *x) {
+ free(x->x_table);
+}
+
+void hamming_tilde_setup(void) {
+ hamming_class = class_new(gensym("hamming~"),
+ (t_newmethod)hamming_new,
+ (t_method)hamming_free,
+ sizeof(t_hamming),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(hamming_class, nullfn, gensym("signal"), 0);
+ class_addmethod(hamming_class, (t_method)hamming_dsp, gensym("dsp"), 0);
+}
diff --git a/hanning~.c b/hanning~.c
new file mode 100644
index 0000000..bf11a64
--- /dev/null
+++ b/hanning~.c
@@ -0,0 +1,85 @@
+/* hanning~ - hanning windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *hanning_class;
+
+typedef struct _hanning {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_hanning;
+
+static t_int* hanning_perform(t_int *w) {
+ t_hanning *x = (t_hanning *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillHanning(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void hanning_dsp(t_hanning *x, t_signal **sp) {
+ dsp_add(hanning_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* hanning_new(void) {
+ t_hanning *x = (t_hanning *)pd_new(hanning_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillHanning(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void hanning_free(t_hanning *x) {
+ free(x->x_table);
+}
+
+void hanning_tilde_setup(void) {
+ hanning_class = class_new(gensym("hanning~"),
+ (t_newmethod)hanning_new,
+ (t_method)hanning_free,
+ sizeof(t_hanning),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(hanning_class, nullfn, gensym("signal"), 0);
+ class_addmethod(hanning_class, (t_method)hanning_dsp, gensym("dsp"), 0);
+}
diff --git a/i0.c b/i0.c
new file mode 100644
index 0000000..b6a00f4
--- /dev/null
+++ b/i0.c
@@ -0,0 +1,409 @@
+/* i0.c
+ *
+ * Modified Bessel function of order zero
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, i0();
+ *
+ * y = i0( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns modified Bessel function of order zero of the
+ * argument.
+ *
+ * The function is defined as i0(x) = j0( ix ).
+ *
+ * The range is partitioned into the two intervals [0,8] and
+ * (8, infinity). Chebyshev polynomial expansions are employed
+ * in each interval.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ * Relative error:
+ * arithmetic domain # trials peak rms
+ * DEC 0,30 6000 8.2e-17 1.9e-17
+ * IEEE 0,30 30000 5.8e-16 1.4e-16
+ *
+ */
+ /* i0e.c
+ *
+ * Modified Bessel function of order zero,
+ * exponentially scaled
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, i0e();
+ *
+ * y = i0e( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns exponentially scaled modified Bessel function
+ * of order zero of the argument.
+ *
+ * The function is defined as i0e(x) = exp(-|x|) j0( ix ).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ * Relative error:
+ * arithmetic domain # trials peak rms
+ * IEEE 0,30 30000 5.4e-16 1.2e-16
+ * See i0().
+ *
+ */
+
+/* i0.c */
+
+
+/*
+Cephes Math Library Release 2.8: June, 2000
+Copyright 1984, 1987, 2000 by Stephen L. Moshier
+*/
+
+#include <math.h>
+#include "mconf.h"
+
+/* Chebyshev coefficients for exp(-x) I0(x)
+ * in the interval [0,8].
+ *
+ * lim(x->0){ exp(-x) I0(x) } = 1.
+ */
+
+#ifdef UNK
+static double A[] =
+{
+-4.41534164647933937950E-18,
+ 3.33079451882223809783E-17,
+-2.43127984654795469359E-16,
+ 1.71539128555513303061E-15,
+-1.16853328779934516808E-14,
+ 7.67618549860493561688E-14,
+-4.85644678311192946090E-13,
+ 2.95505266312963983461E-12,
+-1.72682629144155570723E-11,
+ 9.67580903537323691224E-11,
+-5.18979560163526290666E-10,
+ 2.65982372468238665035E-9,
+-1.30002500998624804212E-8,
+ 6.04699502254191894932E-8,
+-2.67079385394061173391E-7,
+ 1.11738753912010371815E-6,
+-4.41673835845875056359E-6,
+ 1.64484480707288970893E-5,
+-5.75419501008210370398E-5,
+ 1.88502885095841655729E-4,
+-5.76375574538582365885E-4,
+ 1.63947561694133579842E-3,
+-4.32430999505057594430E-3,
+ 1.05464603945949983183E-2,
+-2.37374148058994688156E-2,
+ 4.93052842396707084878E-2,
+-9.49010970480476444210E-2,
+ 1.71620901522208775349E-1,
+-3.04682672343198398683E-1,
+ 6.76795274409476084995E-1
+};
+#endif
+
+#ifdef DEC
+static unsigned short A[] = {
+0121642,0162671,0004646,0103567,
+0022431,0115424,0135755,0026104,
+0123214,0023533,0110365,0156635,
+0023767,0033304,0117662,0172716,
+0124522,0100426,0012277,0157531,
+0025254,0155062,0054461,0030465,
+0126010,0131143,0013560,0153604,
+0026517,0170577,0006336,0114437,
+0127227,0162253,0152243,0052734,
+0027724,0142766,0061641,0160200,
+0130416,0123760,0116564,0125262,
+0031066,0144035,0021246,0054641,
+0131537,0053664,0060131,0102530,
+0032201,0155664,0165153,0020652,
+0132617,0061434,0074423,0176145,
+0033225,0174444,0136147,0122542,
+0133624,0031576,0056453,0020470,
+0034211,0175305,0172321,0041314,
+0134561,0054462,0147040,0165315,
+0035105,0124333,0120203,0162532,
+0135427,0013750,0174257,0055221,
+0035726,0161654,0050220,0100162,
+0136215,0131361,0000325,0041110,
+0036454,0145417,0117357,0017352,
+0136702,0072367,0104415,0133574,
+0037111,0172126,0072505,0014544,
+0137302,0055601,0120550,0033523,
+0037457,0136543,0136544,0043002,
+0137633,0177536,0001276,0066150,
+0040055,0041164,0100655,0010521
+};
+#endif
+
+#ifdef IBMPC
+static unsigned short A[] = {
+0xd0ef,0x2134,0x5cb7,0xbc54,
+0xa589,0x977d,0x3362,0x3c83,
+0xbbb4,0x721e,0x84eb,0xbcb1,
+0x5eba,0x93f6,0xe6d8,0x3cde,
+0xfbeb,0xc297,0x5022,0xbd0a,
+0x2627,0x4b26,0x9b46,0x3d35,
+0x1af0,0x62ee,0x164c,0xbd61,
+0xd324,0xe19b,0xfe2f,0x3d89,
+0x6abc,0x7a94,0xfc95,0xbdb2,
+0x3c10,0xcc74,0x98be,0x3dda,
+0x9556,0x13ae,0xd4fe,0xbe01,
+0xcb34,0xa454,0xd903,0x3e26,
+0x30ab,0x8c0b,0xeaf6,0xbe4b,
+0x6435,0x9d4d,0x3b76,0x3e70,
+0x7f8d,0x8f22,0xec63,0xbe91,
+0xf4ac,0x978c,0xbf24,0x3eb2,
+0x6427,0xcba5,0x866f,0xbed2,
+0x2859,0xbe9a,0x3f58,0x3ef1,
+0x1d5a,0x59c4,0x2b26,0xbf0e,
+0x7cab,0x7410,0xb51b,0x3f28,
+0xeb52,0x1f15,0xe2fd,0xbf42,
+0x100e,0x8a12,0xdc75,0x3f5a,
+0xa849,0x201a,0xb65e,0xbf71,
+0xe3dd,0xf3dd,0x9961,0x3f85,
+0xb6f0,0xf121,0x4e9e,0xbf98,
+0xa32d,0xcea8,0x3e8a,0x3fa9,
+0x06ea,0x342d,0x4b70,0xbfb8,
+0x88c0,0x77ac,0xf7ac,0x3fc5,
+0xcd8d,0xc057,0x7feb,0xbfd3,
+0xa22a,0x9035,0xa84e,0x3fe5,
+};
+#endif
+
+#ifdef MIEEE
+static unsigned short A[] = {
+0xbc54,0x5cb7,0x2134,0xd0ef,
+0x3c83,0x3362,0x977d,0xa589,
+0xbcb1,0x84eb,0x721e,0xbbb4,
+0x3cde,0xe6d8,0x93f6,0x5eba,
+0xbd0a,0x5022,0xc297,0xfbeb,
+0x3d35,0x9b46,0x4b26,0x2627,
+0xbd61,0x164c,0x62ee,0x1af0,
+0x3d89,0xfe2f,0xe19b,0xd324,
+0xbdb2,0xfc95,0x7a94,0x6abc,
+0x3dda,0x98be,0xcc74,0x3c10,
+0xbe01,0xd4fe,0x13ae,0x9556,
+0x3e26,0xd903,0xa454,0xcb34,
+0xbe4b,0xeaf6,0x8c0b,0x30ab,
+0x3e70,0x3b76,0x9d4d,0x6435,
+0xbe91,0xec63,0x8f22,0x7f8d,
+0x3eb2,0xbf24,0x978c,0xf4ac,
+0xbed2,0x866f,0xcba5,0x6427,
+0x3ef1,0x3f58,0xbe9a,0x2859,
+0xbf0e,0x2b26,0x59c4,0x1d5a,
+0x3f28,0xb51b,0x7410,0x7cab,
+0xbf42,0xe2fd,0x1f15,0xeb52,
+0x3f5a,0xdc75,0x8a12,0x100e,
+0xbf71,0xb65e,0x201a,0xa849,
+0x3f85,0x9961,0xf3dd,0xe3dd,
+0xbf98,0x4e9e,0xf121,0xb6f0,
+0x3fa9,0x3e8a,0xcea8,0xa32d,
+0xbfb8,0x4b70,0x342d,0x06ea,
+0x3fc5,0xf7ac,0x77ac,0x88c0,
+0xbfd3,0x7feb,0xc057,0xcd8d,
+0x3fe5,0xa84e,0x9035,0xa22a
+};
+#endif
+
+
+/* Chebyshev coefficients for exp(-x) sqrt(x) I0(x)
+ * in the inverted interval [8,infinity].
+ *
+ * lim(x->inf){ exp(-x) sqrt(x) I0(x) } = 1/sqrt(2pi).
+ */
+
+#ifdef UNK
+static double B[] =
+{
+-7.23318048787475395456E-18,
+-4.83050448594418207126E-18,
+ 4.46562142029675999901E-17,
+ 3.46122286769746109310E-17,
+-2.82762398051658348494E-16,
+-3.42548561967721913462E-16,
+ 1.77256013305652638360E-15,
+ 3.81168066935262242075E-15,
+-9.55484669882830764870E-15,
+-4.15056934728722208663E-14,
+ 1.54008621752140982691E-14,
+ 3.85277838274214270114E-13,
+ 7.18012445138366623367E-13,
+-1.79417853150680611778E-12,
+-1.32158118404477131188E-11,
+-3.14991652796324136454E-11,
+ 1.18891471078464383424E-11,
+ 4.94060238822496958910E-10,
+ 3.39623202570838634515E-9,
+ 2.26666899049817806459E-8,
+ 2.04891858946906374183E-7,
+ 2.89137052083475648297E-6,
+ 6.88975834691682398426E-5,
+ 3.36911647825569408990E-3,
+ 8.04490411014108831608E-1
+};
+#endif
+
+#ifdef DEC
+static unsigned short B[] = {
+0122005,0066672,0123124,0054311,
+0121662,0033323,0030214,0104602,
+0022515,0170300,0113314,0020413,
+0022437,0117350,0035402,0007146,
+0123243,0000135,0057220,0177435,
+0123305,0073476,0144106,0170702,
+0023777,0071755,0017527,0154373,
+0024211,0052214,0102247,0033270,
+0124454,0017763,0171453,0012322,
+0125072,0166316,0075505,0154616,
+0024612,0133770,0065376,0025045,
+0025730,0162143,0056036,0001632,
+0026112,0015077,0150464,0063542,
+0126374,0101030,0014274,0065457,
+0127150,0077271,0125763,0157617,
+0127412,0104350,0040713,0120445,
+0027121,0023765,0057500,0001165,
+0030407,0147146,0003643,0075644,
+0031151,0061445,0044422,0156065,
+0031702,0132224,0003266,0125551,
+0032534,0000076,0147153,0005555,
+0033502,0004536,0004016,0026055,
+0034620,0076433,0142314,0171215,
+0036134,0146145,0013454,0101104,
+0040115,0171425,0062500,0047133
+};
+#endif
+
+#ifdef IBMPC
+static unsigned short B[] = {
+0x8b19,0x54ca,0xadb7,0xbc60,
+0x9130,0x6611,0x46da,0xbc56,
+0x8421,0x12d9,0xbe18,0x3c89,
+0x41cd,0x0760,0xf3dd,0x3c83,
+0x1fe4,0xabd2,0x600b,0xbcb4,
+0xde38,0xd908,0xaee7,0xbcb8,
+0xfb1f,0xa3ea,0xee7d,0x3cdf,
+0xe6d7,0x9094,0x2a91,0x3cf1,
+0x629a,0x7e65,0x83fe,0xbd05,
+0xbb32,0xcf68,0x5d99,0xbd27,
+0xc545,0x0d5f,0x56ff,0x3d11,
+0xc073,0x6b83,0x1c8c,0x3d5b,
+0x8cec,0xfa26,0x4347,0x3d69,
+0x8d66,0x0317,0x9043,0xbd7f,
+0x7bf2,0x357e,0x0fd7,0xbdad,
+0x7425,0x0839,0x511d,0xbdc1,
+0x004f,0xabe8,0x24fe,0x3daa,
+0x6f75,0xc0f4,0xf9cc,0x3e00,
+0x5b87,0xa922,0x2c64,0x3e2d,
+0xd56d,0x80d6,0x5692,0x3e58,
+0x616e,0xd9cd,0x8007,0x3e8b,
+0xc586,0xc101,0x412b,0x3ec8,
+0x9e52,0x7899,0x0fa3,0x3f12,
+0x9049,0xa2e5,0x998c,0x3f6b,
+0x09cb,0xaca8,0xbe62,0x3fe9
+};
+#endif
+
+#ifdef MIEEE
+static unsigned short B[] = {
+0xbc60,0xadb7,0x54ca,0x8b19,
+0xbc56,0x46da,0x6611,0x9130,
+0x3c89,0xbe18,0x12d9,0x8421,
+0x3c83,0xf3dd,0x0760,0x41cd,
+0xbcb4,0x600b,0xabd2,0x1fe4,
+0xbcb8,0xaee7,0xd908,0xde38,
+0x3cdf,0xee7d,0xa3ea,0xfb1f,
+0x3cf1,0x2a91,0x9094,0xe6d7,
+0xbd05,0x83fe,0x7e65,0x629a,
+0xbd27,0x5d99,0xcf68,0xbb32,
+0x3d11,0x56ff,0x0d5f,0xc545,
+0x3d5b,0x1c8c,0x6b83,0xc073,
+0x3d69,0x4347,0xfa26,0x8cec,
+0xbd7f,0x9043,0x0317,0x8d66,
+0xbdad,0x0fd7,0x357e,0x7bf2,
+0xbdc1,0x511d,0x0839,0x7425,
+0x3daa,0x24fe,0xabe8,0x004f,
+0x3e00,0xf9cc,0xc0f4,0x6f75,
+0x3e2d,0x2c64,0xa922,0x5b87,
+0x3e58,0x5692,0x80d6,0xd56d,
+0x3e8b,0x8007,0xd9cd,0x616e,
+0x3ec8,0x412b,0xc101,0xc586,
+0x3f12,0x0fa3,0x7899,0x9e52,
+0x3f6b,0x998c,0xa2e5,0x9049,
+0x3fe9,0xbe62,0xaca8,0x09cb
+};
+#endif
+
+double chbevl(double x, double array[], int n)
+{
+double b0, b1, b2, *p;
+int i;
+
+p = array;
+b0 = *p++;
+b1 = 0.0;
+i = n - 1;
+
+do
+ {
+ b2 = b1;
+ b1 = b0;
+ b0 = x * b1 - b2 + *p++;
+ }
+while( --i );
+
+return( 0.5*(b0-b2) );
+}
+
+double i0(double x)
+{
+double y;
+
+if( x < 0 )
+ x = -x;
+if( x <= 8.0 )
+ {
+ y = (x/2.0) - 2.0;
+ return( exp(x) * chbevl( y, A, 30 ) );
+ }
+
+return( exp(x) * chbevl( 32.0/x - 2.0, B, 25 ) / sqrt(x) );
+
+}
+
+
+
+
+double i0e(double x)
+{
+double y;
+
+if( x < 0 )
+ x = -x;
+if( x <= 8.0 )
+ {
+ y = (x/2.0) - 2.0;
+ return( chbevl( y, A, 30 ) );
+ }
+
+return( chbevl( 32.0/x - 2.0, B, 25 ) / sqrt(x) );
+
+}
diff --git a/kaiser~.c b/kaiser~.c
new file mode 100644
index 0000000..8267ba1
--- /dev/null
+++ b/kaiser~.c
@@ -0,0 +1,99 @@
+/* kaiser~ - kaiser windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFALPHA 10
+#define DEFBLOCKSIZE 64
+
+static t_class *kaiser_class;
+
+typedef struct _kaiser {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+ float x_alpha;
+} t_kaiser;
+
+static t_int* kaiser_perform(t_int *w) {
+ t_kaiser *x = (t_kaiser *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillKaiser(x->x_table, x->x_blocksize, x->x_alpha);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void kaiser_dsp(t_kaiser *x, t_signal **sp) {
+ dsp_add(kaiser_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void kaiser_float(t_kaiser *x, t_float alpha) {
+ x->x_alpha = alpha;
+ fillKaiser(x->x_table, x->x_blocksize, x->x_alpha);
+}
+
+static void* kaiser_new(float alpha) {
+ t_kaiser *x = (t_kaiser *)pd_new(kaiser_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ if (alpha == 0) {
+ x->x_alpha = DEFALPHA;
+ }
+ else {
+ x->x_alpha = alpha;
+ }
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillKaiser(x->x_table, x->x_blocksize, x->x_alpha);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void kaiser_free(t_kaiser *x) {
+ free(x->x_table);
+}
+
+void kaiser_tilde_setup(void) {
+ kaiser_class = class_new(gensym("kaiser~"),
+ (t_newmethod)kaiser_new,
+ (t_method)kaiser_free,
+ sizeof(t_kaiser),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(kaiser_class, nullfn, gensym("signal"), 0);
+ class_addmethod(kaiser_class, (t_method)kaiser_dsp, gensym("dsp"), 0);
+ class_addfloat(kaiser_class, (t_method)kaiser_float);
+}
diff --git a/lanczos~.c b/lanczos~.c
new file mode 100644
index 0000000..422b020
--- /dev/null
+++ b/lanczos~.c
@@ -0,0 +1,85 @@
+/* lanczos~ - lanczos windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *lanczos_class;
+
+typedef struct _lanczos {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_lanczos;
+
+static t_int* lanczos_perform(t_int *w) {
+ t_lanczos *x = (t_lanczos *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillLanczos(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void lanczos_dsp(t_lanczos *x, t_signal **sp) {
+ dsp_add(lanczos_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* lanczos_new(void) {
+ t_lanczos *x = (t_lanczos *)pd_new(lanczos_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillLanczos(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void lanczos_free(t_lanczos *x) {
+ free(x->x_table);
+}
+
+void lanczos_tilde_setup(void) {
+ lanczos_class = class_new(gensym("lanczos~"),
+ (t_newmethod)lanczos_new,
+ (t_method)lanczos_free,
+ sizeof(t_lanczos),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(lanczos_class, nullfn, gensym("signal"), 0);
+ class_addmethod(lanczos_class, (t_method)lanczos_dsp, gensym("dsp"), 0);
+}
diff --git a/mconf.h b/mconf.h
new file mode 100644
index 0000000..063158e
--- /dev/null
+++ b/mconf.h
@@ -0,0 +1,200 @@
+/* mconf.h
+ *
+ * Common include file for math routines
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * #include "mconf.h"
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * This file contains definitions for error codes that are
+ * passed to the common error handling routine mtherr()
+ * (which see).
+ *
+ * The file also includes a conditional assembly definition
+ * for the type of computer arithmetic (IEEE, DEC, Motorola
+ * IEEE, or UNKnown).
+ *
+ * For Digital Equipment PDP-11 and VAX computers, certain
+ * IBM systems, and others that use numbers with a 56-bit
+ * significand, the symbol DEC should be defined. In this
+ * mode, most floating point constants are given as arrays
+ * of octal integers to eliminate decimal to binary conversion
+ * errors that might be introduced by the compiler.
+ *
+ * For little-endian computers, such as IBM PC, that follow the
+ * IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE
+ * Std 754-1985), the symbol IBMPC should be defined. These
+ * numbers have 53-bit significands. In this mode, constants
+ * are provided as arrays of hexadecimal 16 bit integers.
+ *
+ * Big-endian IEEE format is denoted MIEEE. On some RISC
+ * systems such as Sun SPARC, double precision constants
+ * must be stored on 8-byte address boundaries. Since integer
+ * arrays may be aligned differently, the MIEEE configuration
+ * may fail on such machines.
+ *
+ * To accommodate other types of computer arithmetic, all
+ * constants are also provided in a normal decimal radix
+ * which one can hope are correctly converted to a suitable
+ * format by the available C language compiler. To invoke
+ * this mode, define the symbol UNK.
+ *
+ * An important difference among these modes is a predefined
+ * set of machine arithmetic constants for each. The numbers
+ * MACHEP (the machine roundoff error), MAXNUM (largest number
+ * represented), and several other parameters are preset by
+ * the configuration symbol. Check the file const.c to
+ * ensure that these values are correct for your computer.
+ *
+ * Configurations NANS, INFINITIES, MINUSZERO, and DENORMAL
+ * may fail on many systems. Verify that they are supposed
+ * to work on your computer.
+ */
+/*
+Cephes Math Library Release 2.3: June, 1995
+Copyright 1984, 1987, 1989, 1995 by Stephen L. Moshier
+*/
+
+
+/* Define if the `long double' type works. */
+#define HAVE_LONG_DOUBLE 1
+
+/* Define as the return type of signal handlers (int or void). */
+#define RETSIGTYPE void
+
+/* Define if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define if your processor stores words with the most significant
+ byte first (like Motorola and SPARC, unlike Intel and VAX). */
+/* #undef WORDS_BIGENDIAN */
+
+/* Define if floating point words are bigendian. */
+/* #undef FLOAT_WORDS_BIGENDIAN */
+
+/* The number of bytes in a int. */
+#define SIZEOF_INT 4
+
+/* Define if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Name of package */
+#define PACKAGE "cephes"
+
+/* Version number of package */
+#define VERSION "2.7"
+
+/* Constant definitions for math error conditions
+ */
+#ifndef NT
+#define DOMAIN 1 /* argument domain error */
+#define SING 2 /* argument singularity */
+#define OVERFLOW 3 /* overflow range error */
+#define UNDERFLOW 4 /* underflow range error */
+#define TLOSS 5 /* total loss of precision */
+#define PLOSS 6 /* partial loss of precision */
+#endif
+
+#define EDOM 33
+#define ERANGE 34
+/* Complex numeral. */
+typedef struct
+ {
+ double r;
+ double i;
+ } cmplx;
+
+#ifdef HAVE_LONG_DOUBLE
+/* Long double complex numeral. */
+typedef struct
+ {
+ long double r;
+ long double i;
+ } cmplxl;
+#endif
+
+
+/* Type of computer arithmetic */
+
+/* PDP-11, Pro350, VAX:
+ */
+/* #define DEC 1 */
+
+/* Intel IEEE, low order words come first:
+ */
+/* #define IBMPC 1 */
+
+/* Motorola IEEE, high order words come first
+ * (Sun 680x0 workstation):
+ */
+/* #define MIEEE 1 */
+
+/* UNKnown arithmetic, invokes coefficients given in
+ * normal decimal format. Beware of range boundary
+ * problems (MACHEP, MAXLOG, etc. in const.c) and
+ * roundoff problems in pow.c:
+ * (Sun SPARCstation)
+ */
+#define UNK 1
+
+/* If you define UNK, then be sure to set BIGENDIAN properly. */
+#ifdef FLOAT_WORDS_BIGENDIAN
+#define BIGENDIAN 1
+#else
+#define BIGENDIAN 0
+#endif
+/* Define this `volatile' if your compiler thinks
+ * that floating point arithmetic obeys the associative
+ * and distributive laws. It will defeat some optimizations
+ * (but probably not enough of them).
+ *
+ * #define VOLATILE volatile
+ */
+#define VOLATILE
+
+/* For 12-byte long doubles on an i386, pad a 16-bit short 0
+ * to the end of real constants initialized by integer arrays.
+ *
+ * #define XPD 0,
+ *
+ * Otherwise, the type is 10 bytes long and XPD should be
+ * defined blank (e.g., Microsoft C).
+ *
+ * #define XPD
+ */
+#define XPD 0,
+
+/* Define to support tiny denormal numbers, else undefine. */
+#define DENORMAL 1
+
+/* Define to ask for infinity support, else undefine. */
+#define INFINITIES 1
+
+/* Define to ask for support of numbers that are Not-a-Number,
+ else undefine. This may automatically define INFINITIES in some files. */
+#define NANS 1
+
+/* Define to distinguish between -0.0 and +0.0. */
+#define MINUSZERO 1
+
+/* Define 1 for ANSI C atan2() function
+ See atan.c and clog.c. */
+#define ANSIC 1
+
+/* Get ANSI function prototypes, if you want them. */
+#if 1
+/* #ifdef __STDC__ */
+#define ANSIPROT 1
+int mtherr ( char *, int );
+#else
+int mtherr();
+#endif
+
+/* Variable for error reporting. See mtherr.c. */
+extern int merror;
diff --git a/welch~.c b/welch~.c
new file mode 100644
index 0000000..ffae066
--- /dev/null
+++ b/welch~.c
@@ -0,0 +1,85 @@
+/* welch~ - welch windowing function for Pure Data
+**
+** Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include "m_pd.h"
+#include "windowFunctions.h"
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+#define DEFBLOCKSIZE 64
+
+static t_class *welch_class;
+
+typedef struct _welch {
+ t_object x_obj;
+ int x_blocksize;
+ float *x_table;
+} t_welch;
+
+static t_int* welch_perform(t_int *w) {
+ t_welch *x = (t_welch *)(w[1]);
+ t_float *in = (t_float *)(w[2]);
+ t_float *out = (t_float *)(w[3]);
+ int n = (int)(w[4]);
+ int i;
+ if (x->x_blocksize != n) {
+ if (x->x_blocksize < n) {
+ x->x_table = realloc(x->x_table, n * sizeof(float));
+ }
+ x->x_blocksize = n;
+ fillWelch(x->x_table, x->x_blocksize);
+ }
+ for (i = 0; i < n; i++) {
+ *out++ = *(in++) * x->x_table[i];
+ }
+ return (w + 5);
+}
+
+static void welch_dsp(t_welch *x, t_signal **sp) {
+ dsp_add(welch_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
+}
+
+static void* welch_new(void) {
+ t_welch *x = (t_welch *)pd_new(welch_class);
+ x->x_blocksize = DEFBLOCKSIZE;
+ x->x_table = malloc(x->x_blocksize * sizeof(float));
+ fillWelch(x->x_table, x->x_blocksize);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static void welch_free(t_welch *x) {
+ free(x->x_table);
+}
+
+void welch_tilde_setup(void) {
+ welch_class = class_new(gensym("welch~"),
+ (t_newmethod)welch_new,
+ (t_method)welch_free,
+ sizeof(t_welch),
+ 0,
+ A_DEFFLOAT,
+ 0);
+ class_addmethod(welch_class, nullfn, gensym("signal"), 0);
+ class_addmethod(welch_class, (t_method)welch_dsp, gensym("dsp"), 0);
+}
diff --git a/windowFunctions.c b/windowFunctions.c
new file mode 100644
index 0000000..acb7e9f
--- /dev/null
+++ b/windowFunctions.c
@@ -0,0 +1,136 @@
+/* Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#ifdef NT
+#define M_PI 3.14159265358979323846
+#endif
+
+/* modified bessel function of zeroth order */
+double i0(double x);
+
+void fillHanning(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)(0.5 * (1 + cos(M_PI * x)));
+ }
+}
+
+void fillHamming(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)(0.54 + 0.46 * cos(M_PI * x));
+ }
+}
+
+void fillBlackman(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)(0.42 + (0.5 * cos(M_PI * x)) + (0.08 * cos (2 * M_PI * x)));
+ }
+}
+
+void fillConnes(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)((1 - (x * x)) * (1 - (x * x)));
+ }
+}
+
+void fillCosine(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)cos(M_PI * x / 2);
+ }
+}
+
+void fillWelch(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = 1 - (x * x);
+ }
+}
+
+void fillBartlett(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)(1 - fabs(x));
+ }
+}
+
+void fillLanczos(float *vec, int n) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ if (x == 0) {
+ vec[i] = 1;
+ }
+ else {
+ vec[i] = (float)(sin(M_PI * x) / (M_PI * x));
+ }
+ }
+}
+
+void fillGaussian(float *vec, int n, float delta) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ if (delta == 0) {
+ delta = 1;
+ }
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)(pow(2, (-1 * (x / delta) * (x / delta))));
+ }
+}
+
+void fillKaiser(float *vec, int n, float alpha) {
+ int i;
+ float xShift = (float)n / 2;
+ float x;
+ for (i = 0; i < n; i++) {
+ x = (i - xShift) / xShift;
+ vec[i] = (float)(i0(alpha * sqrt(1 - (x * x))) / i0(alpha));
+ }
+}
diff --git a/windowFunctions.h b/windowFunctions.h
new file mode 100644
index 0000000..9aed7ba
--- /dev/null
+++ b/windowFunctions.h
@@ -0,0 +1,30 @@
+/* Copyright (C) 2002 Joseph A. Sarlo
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License
+** as published by the Free Software Foundation; either version 2
+** of the License, or (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+**
+** jsarlo@mambo.peabody.jhu.edu
+*/
+
+void fillHanning(float *vec, int n);
+void fillHamming(float *vec, int n);
+void fillBlackman(float *vec, int n);
+void fillConnes(float *vec, int n);
+void fillCosine(float *vec, int n);
+void fillWelch(float *vec, int n);
+void fillBartlett(float *vec, int n);
+void fillLanczos(float *vec, int n);
+void fillGaussian(float *vec, int n, float delta);
+void fillKaiser(float *vec, int n, float delta);
+
diff --git a/windowing.pd b/windowing.pd
new file mode 100644
index 0000000..5254373
--- /dev/null
+++ b/windowing.pd
@@ -0,0 +1,100 @@
+#N canvas 117 0 857 741 10;
+#X obj 13 70 hanning~;
+#X obj 13 96 tabsend~ hanning;
+#X obj 13 47 sig~ 1;
+#X obj 181 48 sig~ 1;
+#X obj 181 72 hamming~;
+#X obj 181 97 tabsend~ hamming;
+#X obj 15 186 sig~ 1;
+#X obj 183 187 sig~ 1;
+#X obj 15 209 blackman~;
+#X obj 183 211 connes~;
+#X obj 14 335 sig~ 1;
+#X obj 182 339 sig~ 1;
+#X obj 14 361 cosine~;
+#X obj 182 363 bartlett~;
+#X obj 15 492 sig~ 1;
+#X obj 183 494 sig~ 1;
+#X obj 15 515 welch~;
+#X obj 183 518 lanczos~;
+#X obj 16 624 sig~ 1;
+#X obj 16 683 tabsend~ gaussian;
+#X floatatom 68 624 5 0 0;
+#X obj 184 643 sig~ 1;
+#X floatatom 236 643 5 0 0;
+#X obj 184 702 tabsend~ kaiser;
+#X obj 15 235 tabsend~ blackman;
+#X obj 183 236 tabsend~ connes;
+#X obj 14 387 tabsend~ cosine;
+#X obj 182 388 tabsend~ bartlett;
+#X obj 15 542 tabsend~ welch;
+#X obj 183 543 tabsend~ lanczos;
+#X graph graph1 0 -1 63 1 369 152 569 12;
+#X array hanning 64 float 0;
+#X pop;
+#X graph graph2 0 -1 63 1 630 151 830 11;
+#X array hamming 64 float 0;
+#X pop;
+#X graph graph3 0 -1 63 1 369 295 569 155;
+#X array blackman 64 float 0;
+#X pop;
+#X graph graph4 0 -1 63 1 631 294 831 154;
+#X array connes 64 float 0;
+#X pop;
+#X graph graph5 0 -1 63 1 369 438 569 298;
+#X array cosine 64 float 0;
+#X pop;
+#X graph graph6 0 -1 63 1 631 437 831 297;
+#X array bartlett 64 float 0;
+#X pop;
+#X graph graph7 0 -1 63 1 369 582 569 442;
+#X array welch 64 float 0;
+#X pop;
+#X graph graph8 0 -1 63 1 631 581 831 441;
+#X array lanczos 64 float 0;
+#X pop;
+#X graph graph9 0 -1 63 1 369 726 569 586;
+#X array gaussian 64 float 0;
+#X pop;
+#X graph graph10 0 -1 63 1 631 725 831 585;
+#X array kaiser 64 float 0;
+#X pop;
+#X obj 16 657 gaussian~ 0.5;
+#X obj 184 676 kaiser~ 10;
+#X text 250 362 (triangle);
+#X text 245 518 (sinc);
+#X text 12 23 0.5*(1+cos(pi*x));
+#X text 179 24 0.54+0.46*(cos(pi*x));
+#X text 14 164 0.8*cos(2*pi*x);
+#X text 180 161 (1-x^2)^2;
+#X text 14 149 0.42+(0.5*cos(pi*x))+;
+#X text 13 311 cos(pi*x/2);
+#X text 179 312 1-x^2;
+#X text 14 465 1 - abs(x);
+#X text 180 466 sin(pi*x)/(pi*x);
+#X text 16 602 2^(-(x/d)^2);
+#X text 184 622 modified Bessel function;
+#X text 184 608 where Io is 0th order;
+#X text 183 593 Io(a*sqrt(1-x^2))/Io(a);
+#X connect 0 0 1 0;
+#X connect 2 0 0 0;
+#X connect 3 0 4 0;
+#X connect 4 0 5 0;
+#X connect 6 0 8 0;
+#X connect 7 0 9 0;
+#X connect 8 0 24 0;
+#X connect 9 0 25 0;
+#X connect 10 0 12 0;
+#X connect 11 0 13 0;
+#X connect 12 0 26 0;
+#X connect 13 0 27 0;
+#X connect 14 0 16 0;
+#X connect 15 0 17 0;
+#X connect 16 0 28 0;
+#X connect 17 0 29 0;
+#X connect 18 0 40 0;
+#X connect 20 0 40 0;
+#X connect 21 0 41 0;
+#X connect 22 0 41 0;
+#X connect 40 0 19 0;
+#X connect 41 0 23 0;